Repository: alexhiggins732/IdentityServer8 Branch: master Commit: 08051c9b2b7a Files: 1862 Total size: 34.8 MB Directory structure: gitextract__ksyciu0/ ├── .config/ │ └── dotnet-tools.json ├── .editorconfig ├── .gitattributes ├── .github/ │ ├── CONTRIBUTING.md │ ├── FUNDING.yml │ ├── ISSUE_TEMPLATE/ │ │ ├── Question.md │ │ ├── bug_report.md │ │ └── feature_request.md │ ├── PULL_REQUEST_TEMPLATE.md │ ├── dependabot.yml │ └── workflows/ │ ├── codeql.yml │ ├── develop.yml │ ├── master.yml │ ├── pre-release.yml │ └── release.yml ├── .gitignore ├── .readthedocs.yaml ├── Directory.Build.props ├── Directory.Build.targets ├── Directory.Packages.props ├── GitReleaseManager.yaml ├── IdentityServer8.DotNet.ruleset ├── LICENSE ├── LicenseHeader.txt ├── NuGet.config ├── README.md ├── SECURITY.MD ├── SPONSORS.md ├── docker-compose.dcproj ├── docker-compose.override.yml ├── docker-compose.vs.debug.yml ├── docker-compose.vs.release.yml ├── docker-compose.yml ├── docs/ │ ├── CHANGELOG.md │ ├── Makefile │ ├── autobuild.bat │ ├── build-documentation.ps1 │ ├── conf.py │ ├── docker-build.ps1 │ ├── dockerfile │ ├── endpoints/ │ │ ├── authorize.rst │ │ ├── device_authorization.rst │ │ ├── discovery.rst │ │ ├── endsession.rst │ │ ├── introspection.rst │ │ ├── revocation.rst │ │ ├── token.rst │ │ └── userinfo.rst │ ├── identityserver docs figures.pptx │ ├── index.rst │ ├── intro/ │ │ ├── big_picture.rst │ │ ├── contributing.rst │ │ ├── packaging.rst │ │ ├── specs.rst │ │ ├── support.rst │ │ ├── terminology.rst │ │ └── test.rst │ ├── make.bat │ ├── misc/ │ │ ├── blogs.rst │ │ ├── training.rst │ │ └── videos.rst │ ├── quickstarts/ │ │ ├── 0_overview.rst │ │ ├── 1_client_credentials.rst │ │ ├── 2_interactive_aspnetcore.rst │ │ ├── 3_aspnetcore_and_apis.rst │ │ ├── 4_javascript_client.rst │ │ ├── 5_entityframework.rst │ │ ├── 6_aspnet_identity.rst │ │ └── community.rst │ ├── readme.md │ ├── reference/ │ │ ├── api_resource.rst │ │ ├── api_scope.rst │ │ ├── aspnet_identity.rst │ │ ├── client.rst │ │ ├── deviceflow_interactionservice.rst │ │ ├── ef.rst │ │ ├── grant_validation_result.rst │ │ ├── identity_resource.rst │ │ ├── interactionservice.rst │ │ ├── options.rst │ │ └── profileservice.rst │ ├── requirements.txt │ └── topics/ │ ├── add_apis.rst │ ├── add_protocols.rst │ ├── apis.rst │ ├── client_authentication.rst │ ├── clients.rst │ ├── consent.rst │ ├── cors.rst │ ├── crypto.rst │ ├── custom_token_request_validation.rst │ ├── deployment.rst │ ├── discovery.rst │ ├── events.rst │ ├── extension_grants.rst │ ├── federation_gateway.rst │ ├── grant_types.rst │ ├── logging.rst │ ├── mtls.rst │ ├── persisted_grants.rst │ ├── pop.rst │ ├── reference_tokens.rst │ ├── refresh_tokens.rst │ ├── request_object.rst │ ├── resource_owner.rst │ ├── resources.rst │ ├── signin.rst │ ├── signin_external_providers.rst │ ├── signout.rst │ ├── signout_external_providers.rst │ ├── signout_federated.rst │ ├── startup.rst │ ├── tools.rst │ └── windows.rst ├── global.json ├── key.snk ├── main.cmd ├── samples/ │ ├── Clients/ │ │ ├── Clients.sln.licenseheader │ │ ├── ClientsGlobalUsings.cs │ │ ├── Directory.Build.props │ │ ├── old/ │ │ │ ├── Clients.sln │ │ │ ├── Clients.sln.licenseheader │ │ │ ├── Directory.Build.props │ │ │ ├── MvcHybrid/ │ │ │ │ ├── Controllers/ │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── MvcHybrid.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── CallApi.cshtml │ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ │ └── Secure.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ └── _Layout.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── appsettings.json │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ └── site.css │ │ │ │ └── js/ │ │ │ │ └── site.js │ │ │ ├── MvcHybridAutomaticRefresh/ │ │ │ │ ├── AutomaticTokenManagement/ │ │ │ │ │ ├── AutomaticTokenManagementBuilderExtensions.cs │ │ │ │ │ ├── AutomaticTokenManagementConfigureCookieOptions.cs │ │ │ │ │ ├── AutomaticTokenManagementCookieEvents.cs │ │ │ │ │ ├── AutomaticTokenManagementOptions.cs │ │ │ │ │ └── TokenEndpointService.cs │ │ │ │ ├── Controllers/ │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── MvcHybridAutomaticRefresh.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Views/ │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── CallApi.cshtml │ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ │ └── Secure.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ └── _Layout.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── appsettings.json │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ └── site.css │ │ │ │ └── js/ │ │ │ │ └── site.js │ │ │ ├── MvcImplicit/ │ │ │ │ ├── Controllers/ │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── MvcImplicit.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ │ └── Secure.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ └── _Layout.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ └── site.css │ │ │ │ └── js/ │ │ │ │ └── site.js │ │ │ ├── MvcImplicitJwtRequest/ │ │ │ │ ├── Controllers/ │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── MvcImplicitJwtRequest.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ │ └── Secure.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ └── _Layout.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ └── site.css │ │ │ │ └── js/ │ │ │ │ └── site.js │ │ │ ├── MvcManual/ │ │ │ │ ├── Controllers/ │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── MvcManual.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ │ └── Secure.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ └── _Layout.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ └── site.css │ │ │ │ └── js/ │ │ │ │ └── site.js │ │ │ └── MvcUsings.cs │ │ ├── readme.md │ │ ├── shared/ │ │ │ └── Constants/ │ │ │ ├── ConsoleExtensions.cs │ │ │ ├── Constants.cs │ │ │ ├── Constants.csproj │ │ │ └── TokenResponseExtensions.cs │ │ └── src/ │ │ ├── APIs/ │ │ │ ├── ResourceBasedApi/ │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ └── ResourceBasedApi.csproj │ │ │ └── SimpleApi/ │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ └── SimpleApi.csproj │ │ ├── Clients.sln │ │ ├── ConsoleClientCredentialsFlow/ │ │ │ ├── ConsoleClientCredentialsFlow.csproj │ │ │ └── Program.cs │ │ ├── ConsoleClientCredentialsFlowCallingIdentityServerApi/ │ │ │ ├── ConsoleClientCredentialsFlowCallingIdentityServerApi.csproj │ │ │ └── Program.cs │ │ ├── ConsoleClientCredentialsFlowPostBody/ │ │ │ ├── ConsoleClientCredentialsFlowPostBody.csproj │ │ │ └── Program.cs │ │ ├── ConsoleCode/ │ │ │ ├── ConsoleCode.csproj │ │ │ ├── Program.cs │ │ │ └── SystemBrowser.cs │ │ ├── ConsoleCustomGrant/ │ │ │ ├── ConsoleExtensionGrant.csproj │ │ │ └── Program.cs │ │ ├── ConsoleDeviceFlow/ │ │ │ ├── ConsoleDeviceFlow.csproj │ │ │ └── Program.cs │ │ ├── ConsoleEphemeralMtlsClient/ │ │ │ ├── ConsoleEphemeralMtlsClient.csproj │ │ │ ├── GlobalUsings.cs │ │ │ └── Program.cs │ │ ├── ConsoleIntrospectionClient/ │ │ │ ├── ConsoleIntrospectionClient.csproj │ │ │ └── Program.cs │ │ ├── ConsoleMTLSClient/ │ │ │ ├── ConsoleMTLSClient.csproj │ │ │ ├── Program.cs │ │ │ └── client.p12 │ │ ├── ConsoleParameterizedScopeClient/ │ │ │ ├── ConsoleParameterizedScopeClient.csproj │ │ │ └── Program.cs │ │ ├── ConsolePrivateKeyJwtClient/ │ │ │ ├── ConsolePrivateKeyJwtClient.csproj │ │ │ ├── Program.cs │ │ │ └── client.p12 │ │ ├── ConsoleResourceOwnerFlow/ │ │ │ ├── ConsoleResourceOwnerFlow.csproj │ │ │ └── Program.cs │ │ ├── ConsoleResourceOwnerFlowPublic/ │ │ │ ├── ConsoleResourceOwnerFlowPublic.csproj │ │ │ └── Program.cs │ │ ├── ConsoleResourceOwnerFlowReference/ │ │ │ ├── ConsoleResourceOwnerFlowReference.csproj │ │ │ └── Program.cs │ │ ├── ConsoleResourceOwnerFlowRefreshToken/ │ │ │ ├── ConsoleResourceOwnerFlowRefreshToken.csproj │ │ │ ├── GlobalUsings.cs │ │ │ └── Program.cs │ │ ├── ConsoleResourceOwnerFlowUserInfo/ │ │ │ ├── ConsoleResourceOwnerFlowUserInfo.csproj │ │ │ └── Program.cs │ │ ├── Directory.Build.props │ │ ├── JsOidc/ │ │ │ ├── JsOidc.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── web.config │ │ │ └── wwwroot/ │ │ │ ├── StyleSheet.css │ │ │ ├── app.js │ │ │ ├── callback.html │ │ │ ├── callback.js │ │ │ ├── index.html │ │ │ ├── libs/ │ │ │ │ ├── oidc-client.d.ts │ │ │ │ ├── oidc-client.js │ │ │ │ ├── oidc-client.rsa256.slim.js │ │ │ │ └── oidc-client.slim.js │ │ │ ├── popup.html │ │ │ ├── popup.js │ │ │ ├── silent.html │ │ │ └── silent.js │ │ ├── MvcAutomaticTokenManagement/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── MvcAutomaticTokenManagement.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── CallApi.cshtml │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Secure.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ └── _ValidationScriptsPartial.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── MvcCode/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── MvcCode.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── CallApi.cshtml │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Secure.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ └── _ValidationScriptsPartial.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── MvcHybridBackChannel/ │ │ │ ├── Controllers/ │ │ │ │ ├── HomeController.cs │ │ │ │ └── LogoutController.cs │ │ │ ├── CookieEventHandler.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── LogoutSessionManager.cs │ │ │ ├── MvcHybridBackChannel.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── CallApi.cshtml │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Secure.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ └── _Layout.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── _references.js │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ └── WindowsConsoleSystemBrowser/ │ │ ├── CallbackManager.cs │ │ ├── Program.cs │ │ ├── RegistryConfig.cs │ │ └── WindowsConsoleSystemBrowser.csproj │ ├── Directory.Build.props │ ├── KeyManagement/ │ │ ├── Directory.Build.props │ │ ├── FileSystemKeys/ │ │ │ ├── Directory.Build.props │ │ │ ├── FileSystem/ │ │ │ │ ├── Config.cs │ │ │ │ ├── FileSystemSample.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ └── appsettings.json │ │ │ ├── KeyManagement.sln │ │ │ ├── KeyManagement.sln.licenseheader │ │ │ └── database/ │ │ │ ├── EF/ │ │ │ │ ├── Config.cs │ │ │ │ ├── EfSample.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ └── appsettings.json │ │ │ └── migrations/ │ │ │ ├── Migrations/ │ │ │ │ ├── KeyManagement/ │ │ │ │ │ ├── 20200327143521_KeyManagement.Designer.cs │ │ │ │ │ ├── 20200327143521_KeyManagement.cs │ │ │ │ │ └── KeyManagementDbContextModelSnapshot.cs │ │ │ │ └── KeyManagement.sql │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Startup.cs │ │ │ ├── appsettings.json │ │ │ ├── builddb.bat │ │ │ └── migrations.csproj │ │ └── KeyManagementGlobalUsings.cs │ ├── Quickstarts/ │ │ ├── 1_ClientCredentials/ │ │ │ ├── Directory.Build.props │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ └── IdentityServer/ │ │ │ ├── GlobalUsings.cs │ │ │ ├── IdentityServer.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ └── libman.json │ │ ├── 2_InteractiveAspNetCore/ │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ ├── IdentityServer/ │ │ │ │ ├── Config.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── IdentityServer.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Quickstart/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ │ └── DeviceController.cs │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ │ ├── Extensions.cs │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ │ └── HomeController.cs │ │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ │ └── TestUsers.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ │ └── Logout.cshtml │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Home/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ ├── site.css │ │ │ │ │ └── site.scss │ │ │ │ └── js/ │ │ │ │ ├── signin-redirect.js │ │ │ │ └── signout-redirect.js │ │ │ └── MvcClient/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Models/ │ │ │ │ └── ErrorViewModel.cs │ │ │ ├── MvcClient.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Privacy.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ │ └── json.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── 3_AspNetCoreAndApis/ │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ ├── IdentityServer/ │ │ │ │ ├── Config.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── IdentityServer.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Quickstart/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ │ └── DeviceController.cs │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ │ ├── Extensions.cs │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ │ └── HomeController.cs │ │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ │ └── TestUsers.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ │ └── Logout.cshtml │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Home/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ ├── site.css │ │ │ │ │ └── site.scss │ │ │ │ └── js/ │ │ │ │ ├── signin-redirect.js │ │ │ │ └── signout-redirect.js │ │ │ └── MvcClient/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Models/ │ │ │ │ └── ErrorViewModel.cs │ │ │ ├── MvcClient.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Privacy.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ │ └── json.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── 4_JavaScriptClient/ │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ ├── IdentityServer/ │ │ │ │ ├── Config.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── IdentityServer.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Quickstart/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ │ └── DeviceController.cs │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ │ ├── Extensions.cs │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ │ └── HomeController.cs │ │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ │ └── TestUsers.cs │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ │ └── Logout.cshtml │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Home/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ ├── site.css │ │ │ │ │ └── site.scss │ │ │ │ └── js/ │ │ │ │ ├── signin-redirect.js │ │ │ │ └── signout-redirect.js │ │ │ ├── JavaScriptClient/ │ │ │ │ ├── JavaScriptClient.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Startup.cs │ │ │ │ ├── appsettings.Development.json │ │ │ │ ├── appsettings.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── app.js │ │ │ │ ├── callback.html │ │ │ │ ├── index.html │ │ │ │ └── oidc-client.js │ │ │ └── MvcClient/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Models/ │ │ │ │ └── ErrorViewModel.cs │ │ │ ├── MvcClient.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Startup.cs │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Privacy.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ │ └── json.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── 5_EntityFramework/ │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ ├── IdentityServer/ │ │ │ │ ├── Config.cs │ │ │ │ ├── Data/ │ │ │ │ │ └── Migrations/ │ │ │ │ │ └── IdentityServer/ │ │ │ │ │ ├── ConfigurationDb/ │ │ │ │ │ │ ├── 20200625203625_InitialIdentityServerConfigurationDbMigration.Designer.cs │ │ │ │ │ │ ├── 20200625203625_InitialIdentityServerConfigurationDbMigration.cs │ │ │ │ │ │ └── ConfigurationDbContextModelSnapshot.cs │ │ │ │ │ └── PersistedGrantDb/ │ │ │ │ │ ├── 20200625203357_InitialIdentityServerPersistedGrantDbMigration.Designer.cs │ │ │ │ │ ├── 20200625203357_InitialIdentityServerPersistedGrantDbMigration.cs │ │ │ │ │ └── PersistedGrantDbContextModelSnapshot.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── IdentityServer.csproj │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Quickstart/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ │ └── DeviceController.cs │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ │ ├── Extensions.cs │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ │ └── HomeController.cs │ │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ │ └── TestUsers.cs │ │ │ │ ├── Startup.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ │ └── Logout.cshtml │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Home/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── libman.json │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ ├── site.css │ │ │ │ │ └── site.scss │ │ │ │ └── js/ │ │ │ │ ├── signin-redirect.js │ │ │ │ └── signout-redirect.js │ │ │ └── MvcClient/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Models/ │ │ │ │ └── ErrorViewModel.cs │ │ │ ├── MvcClient.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Privacy.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ │ └── json.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── 6_AspNetIdentity/ │ │ │ ├── Quickstart.sln │ │ │ ├── Quickstart.sln.licenseheader │ │ │ └── src/ │ │ │ ├── IdentityServerAspNetIdentity/ │ │ │ │ ├── Config.cs │ │ │ │ ├── Data/ │ │ │ │ │ ├── ApplicationDbContext.cs │ │ │ │ │ └── Migrations/ │ │ │ │ │ ├── 20180109192453_CreateIdentitySchema.Designer.cs │ │ │ │ │ ├── 20180109192453_CreateIdentitySchema.cs │ │ │ │ │ └── ApplicationDbContextModelSnapshot.cs │ │ │ │ ├── GlobalUsings.cs │ │ │ │ ├── IdentityServerAspNetIdentity.csproj │ │ │ │ ├── Models/ │ │ │ │ │ └── ApplicationUser.cs │ │ │ │ ├── Program.cs │ │ │ │ ├── Properties/ │ │ │ │ │ └── launchSettings.json │ │ │ │ ├── Quickstart/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ │ └── DeviceController.cs │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ │ ├── Extensions.cs │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ │ ├── Home/ │ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ │ └── HomeController.cs │ │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ │ └── TestUsers.cs │ │ │ │ ├── SeedData.cs │ │ │ │ ├── Views/ │ │ │ │ │ ├── Account/ │ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ │ └── Logout.cshtml │ │ │ │ │ ├── Consent/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Device/ │ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ │ ├── Diagnostics/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Grants/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Home/ │ │ │ │ │ │ └── Index.cshtml │ │ │ │ │ ├── Shared/ │ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ │ └── _ViewStart.cshtml │ │ │ │ ├── appsettings.json │ │ │ │ ├── libman.json │ │ │ │ ├── updateUI.ps1 │ │ │ │ └── wwwroot/ │ │ │ │ ├── css/ │ │ │ │ │ ├── site.css │ │ │ │ │ └── site.scss │ │ │ │ └── js/ │ │ │ │ ├── signin-redirect.js │ │ │ │ └── signout-redirect.js │ │ │ └── MvcClient/ │ │ │ ├── Controllers/ │ │ │ │ └── HomeController.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Models/ │ │ │ │ └── ErrorViewModel.cs │ │ │ ├── MvcClient.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Views/ │ │ │ │ ├── Home/ │ │ │ │ │ ├── Index.cshtml │ │ │ │ │ └── Privacy.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ │ └── json.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.Development.json │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ └── site.css │ │ │ └── js/ │ │ │ └── site.js │ │ ├── Directory.Build.props │ │ ├── Quickstart.sln.licenseheader │ │ └── Shared/ │ │ └── src/ │ │ ├── Api/ │ │ │ ├── Api.csproj │ │ │ ├── Program.cs │ │ │ └── Properties/ │ │ │ └── launchSettings.json │ │ ├── Client/ │ │ │ ├── Client.csproj │ │ │ └── Program.cs │ │ ├── IdentityServer/ │ │ │ ├── Config.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── IdentityServer.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Quickstart/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ ├── Consent/ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ ├── Device/ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ └── DeviceController.cs │ │ │ │ ├── Diagnostics/ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ ├── Extensions.cs │ │ │ │ ├── Grants/ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ ├── Home/ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ └── TestUsers.cs │ │ │ ├── Views/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ └── Logout.cshtml │ │ │ │ ├── Consent/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Device/ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ ├── Diagnostics/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Grants/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Home/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ ├── site.css │ │ │ │ └── site.scss │ │ │ └── js/ │ │ │ ├── signin-redirect.js │ │ │ └── signout-redirect.js │ │ └── MvcClient/ │ │ ├── Controllers/ │ │ │ └── HomeController.cs │ │ ├── GlobalUsings.cs │ │ ├── Models/ │ │ │ └── ErrorViewModel.cs │ │ ├── MvcClient.csproj │ │ ├── Program.cs │ │ ├── Properties/ │ │ │ └── launchSettings.json │ │ ├── Views/ │ │ │ ├── Home/ │ │ │ │ ├── Index.cshtml │ │ │ │ └── Privacy.cshtml │ │ │ ├── Shared/ │ │ │ │ ├── Error.cshtml │ │ │ │ ├── _Layout.cshtml │ │ │ │ ├── _ValidationScriptsPartial.cshtml │ │ │ │ └── json.cshtml │ │ │ ├── _ViewImports.cshtml │ │ │ └── _ViewStart.cshtml │ │ ├── appsettings.Development.json │ │ ├── appsettings.json │ │ ├── libman.json │ │ └── wwwroot/ │ │ ├── css/ │ │ │ └── site.css │ │ └── js/ │ │ └── site.js │ └── SamplesGlobalUsings.cs ├── src/ │ ├── AspNetIdentity/ │ │ ├── Directory.Build.props │ │ ├── IdentityServer8.AspNetIdentity.sln │ │ ├── README.md │ │ ├── build.cmd │ │ ├── build.ps1 │ │ ├── build.sh │ │ ├── host/ │ │ │ ├── Configuration/ │ │ │ │ ├── Clients.cs │ │ │ │ ├── ClientsConsole.cs │ │ │ │ ├── ClientsWeb.cs │ │ │ │ └── Resources.cs │ │ │ ├── Data/ │ │ │ │ └── ApplicationDbContext.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Host.csproj │ │ │ ├── Models/ │ │ │ │ ├── AccountViewModels/ │ │ │ │ │ ├── ExternalLoginViewModel.cs │ │ │ │ │ ├── ForgotPasswordViewModel.cs │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ ├── LoginWith2faViewModel.cs │ │ │ │ │ ├── LoginWithRecoveryCodeViewModel.cs │ │ │ │ │ ├── RegisterViewModel.cs │ │ │ │ │ └── ResetPasswordViewModel.cs │ │ │ │ ├── ApplicationUser.cs │ │ │ │ └── ManageViewModels/ │ │ │ │ ├── ChangePasswordViewModel.cs │ │ │ │ ├── EnableAuthenticatorViewModel.cs │ │ │ │ ├── ExternalLoginsViewModel.cs │ │ │ │ ├── GenerateRecoveryCodesViewModel.cs │ │ │ │ ├── IndexViewModel.cs │ │ │ │ ├── RemoveLoginViewModel.cs │ │ │ │ ├── SetPasswordViewModel.cs │ │ │ │ └── TwoFactorAuthenticationViewModel.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Quickstart/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ ├── Consent/ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ ├── Device/ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ └── DeviceController.cs │ │ │ │ ├── Diagnostics/ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ ├── Extensions.cs │ │ │ │ ├── Grants/ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ ├── Home/ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ └── TestUsers.cs │ │ │ ├── Startup.cs │ │ │ ├── Views/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ └── Logout.cshtml │ │ │ │ ├── Consent/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Device/ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ ├── Diagnostics/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Grants/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Home/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.json │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ ├── site.css │ │ │ │ └── site.scss │ │ │ └── js/ │ │ │ ├── signin-redirect.js │ │ │ └── signout-redirect.js │ │ ├── migrations/ │ │ │ └── SqlServer/ │ │ │ ├── GlobalUsings.cs │ │ │ ├── Migrations/ │ │ │ │ ├── UsersDb/ │ │ │ │ │ ├── 20200323135751_Users.Designer.cs │ │ │ │ │ ├── 20200323135751_Users.cs │ │ │ │ │ └── ApplicationDbContextModelSnapshot.cs │ │ │ │ └── UsersDb.sql │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── SeedData.cs │ │ │ ├── SqlServer.csproj │ │ │ ├── Startup.cs │ │ │ ├── appsettings.json │ │ │ └── builddb.bat │ │ └── src/ │ │ ├── Decorator.cs │ │ ├── GlobalUsings.cs │ │ ├── IdentityServer8.AspNetIdentity.csproj │ │ ├── IdentityServerBuilderExtensions.cs │ │ ├── ProfileService.cs │ │ ├── ResourceOwnerPasswordValidator.cs │ │ ├── SecurityStampValidatorCallback.cs │ │ └── UserClaimsFactory.cs │ ├── Directory.Build.props │ ├── Directory.BuildOld.targets │ ├── EntityFramework/ │ │ ├── Directory.Build.props │ │ ├── IdentityServer8.EntityFramework.sln │ │ ├── README.md │ │ ├── build.cmd │ │ ├── build.ps1 │ │ ├── build.sh │ │ ├── dropdb.bat │ │ ├── host/ │ │ │ ├── GlobalUsings.cs │ │ │ ├── Host.csproj │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Quickstart/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ ├── Consent/ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ ├── Device/ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ └── DeviceController.cs │ │ │ │ ├── Diagnostics/ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ ├── Extensions.cs │ │ │ │ ├── Grants/ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ ├── Home/ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ └── TestUsers.cs │ │ │ ├── Startup.cs │ │ │ ├── TestOperationalStoreNotification.cs │ │ │ ├── Views/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ └── Logout.cshtml │ │ │ │ ├── Consent/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Device/ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ ├── Diagnostics/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Grants/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Home/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ ├── site.css │ │ │ │ └── site.scss │ │ │ └── js/ │ │ │ ├── signin-redirect.js │ │ │ └── signout-redirect.js │ │ ├── migrations/ │ │ │ └── SqlServer/ │ │ │ ├── Configuration/ │ │ │ │ ├── Clients.cs │ │ │ │ ├── ClientsConsole.cs │ │ │ │ ├── ClientsWeb.cs │ │ │ │ └── Resources.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── SeedData.cs │ │ │ ├── SqlServer.csproj │ │ │ ├── Startup.cs │ │ │ └── appsettings.json │ │ ├── migrations.bat │ │ ├── src/ │ │ │ ├── GlobalUsings.cs │ │ │ ├── IdentityServer8.EntityFramework.csproj │ │ │ ├── IdentityServerEntityFrameworkBuilderExtensions.cs │ │ │ ├── Services/ │ │ │ │ └── CorsPolicyService.cs │ │ │ └── TokenCleanupHost.cs │ │ ├── test/ │ │ │ └── IdentityServer8.EntityFramework.Tests/ │ │ │ ├── DatabaseProviderBuilder.cs │ │ │ ├── DatabaseProviderFixture.cs │ │ │ ├── FakeLogger.cs │ │ │ ├── IdentityServer8.EntityFramework.Tests.csproj │ │ │ ├── IntegrationTest.cs │ │ │ └── Services/ │ │ │ └── CorsPolicyServiceTests.cs │ │ └── updatedb.bat │ ├── EntityFramework.Storage/ │ │ ├── Directory.Build.props │ │ ├── IdentityServer8.EntityFramework.Storage.sln │ │ ├── README.md │ │ ├── build.cmd │ │ ├── build.ps1 │ │ ├── build.sh │ │ ├── host/ │ │ │ ├── ConsoleHost/ │ │ │ │ ├── ConsoleHost.csproj │ │ │ │ ├── GlobalUsings.cs │ │ │ │ └── Program.cs │ │ │ └── Directory.Build.props │ │ ├── migrations/ │ │ │ ├── Directory.Build.props │ │ │ └── SqlServer/ │ │ │ ├── GlobalUsings.cs │ │ │ ├── Migrations/ │ │ │ │ ├── ConfigurationDb/ │ │ │ │ │ ├── 20200522172542_Config.Designer.cs │ │ │ │ │ ├── 20200522172542_Config.cs │ │ │ │ │ └── ConfigurationDbContextModelSnapshot.cs │ │ │ │ ├── ConfigurationDb.sql │ │ │ │ ├── PersistedGrantDb/ │ │ │ │ │ ├── 20200522172538_Grants.Designer.cs │ │ │ │ │ ├── 20200522172538_Grants.cs │ │ │ │ │ └── PersistedGrantDbContextModelSnapshot.cs │ │ │ │ └── PersistedGrantDb.sql │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── SqlServer.csproj │ │ │ ├── Startup.cs │ │ │ ├── appsettings.json │ │ │ ├── buildschema.bat │ │ │ └── createdb.bat │ │ ├── src/ │ │ │ ├── Configuration/ │ │ │ │ └── ServiceCollectionExtensions.cs │ │ │ ├── DbContexts/ │ │ │ │ ├── ConfigurationDbContext.cs │ │ │ │ └── PersistedGrantDbContext.cs │ │ │ ├── Entities/ │ │ │ │ ├── ApiResource.cs │ │ │ │ ├── ApiResourceClaim.cs │ │ │ │ ├── ApiResourceProperty.cs │ │ │ │ ├── ApiResourceScope.cs │ │ │ │ ├── ApiResourceSecret.cs │ │ │ │ ├── ApiScope.cs │ │ │ │ ├── ApiScopeClaim.cs │ │ │ │ ├── ApiScopeProperty.cs │ │ │ │ ├── Client.cs │ │ │ │ ├── ClientClaim.cs │ │ │ │ ├── ClientCorsOrigin.cs │ │ │ │ ├── ClientGrantType.cs │ │ │ │ ├── ClientIdPRestriction.cs │ │ │ │ ├── ClientPostLogoutRedirectUri.cs │ │ │ │ ├── ClientProperty.cs │ │ │ │ ├── ClientRedirectUri.cs │ │ │ │ ├── ClientScope.cs │ │ │ │ ├── ClientSecret.cs │ │ │ │ ├── DeviceFlowCodes.cs │ │ │ │ ├── IdentityResource.cs │ │ │ │ ├── IdentityResourceClaim.cs │ │ │ │ ├── IdentityResourceProperty.cs │ │ │ │ ├── PersistedGrant.cs │ │ │ │ ├── Property.cs │ │ │ │ ├── Secret.cs │ │ │ │ └── UserClaim.cs │ │ │ ├── Extensions/ │ │ │ │ └── ModelBuilderExtensions.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── IdentityServer8.EntityFramework.Storage.csproj │ │ │ ├── Interfaces/ │ │ │ │ ├── IConfigurationDbContext.cs │ │ │ │ └── IPersistedGrantDbContext.cs │ │ │ ├── Mappers/ │ │ │ │ ├── AllowedSigningAlgorithmsConverter.cs │ │ │ │ ├── ApiResourceMapperProfile.cs │ │ │ │ ├── ApiResourceMappers.cs │ │ │ │ ├── ClientMapperProfile.cs │ │ │ │ ├── ClientMappers.cs │ │ │ │ ├── IdentityResourceMapperProfile.cs │ │ │ │ ├── IdentityResourceMappers.cs │ │ │ │ ├── PersistedGrantMapperProfile.cs │ │ │ │ ├── PersistedGrantMappers.cs │ │ │ │ ├── ScopeMapperProfile.cs │ │ │ │ └── ScopeMappers.cs │ │ │ ├── Options/ │ │ │ │ ├── ConfigurationStoreOptions.cs │ │ │ │ ├── OperationalStoreOptions.cs │ │ │ │ └── TableConfiguration.cs │ │ │ ├── Properties/ │ │ │ │ └── AssemblyInfo.cs │ │ │ ├── Stores/ │ │ │ │ ├── ClientStore.cs │ │ │ │ ├── DeviceFlowStore.cs │ │ │ │ ├── PersistedGrantStore.cs │ │ │ │ └── ResourceStore.cs │ │ │ └── TokenCleanup/ │ │ │ ├── IOperationalStoreNotification.cs │ │ │ └── TokenCleanupService.cs │ │ └── test/ │ │ ├── Directory.Build.props │ │ ├── IntegrationTests/ │ │ │ ├── DatabaseProviderBuilder.cs │ │ │ ├── DatabaseProviderFixture.cs │ │ │ ├── DbContexts/ │ │ │ │ └── ClientDbContextTests.cs │ │ │ ├── FakeLogger.cs │ │ │ ├── IdentityServer8.EntityFramework.IntegrationTests.csproj │ │ │ ├── IntegrationTest.cs │ │ │ ├── Stores/ │ │ │ │ ├── ClientStoreTests.cs │ │ │ │ ├── DeviceFlowStoreTests.cs │ │ │ │ ├── PersistedGrantStoreTests.cs │ │ │ │ └── ResourceStoreTests.cs │ │ │ └── TokenCleanup/ │ │ │ └── TokenCleanupTests.cs │ │ └── UnitTests/ │ │ ├── IdentityServer8.EntityFramework.UnitTests.csproj │ │ └── Mappers/ │ │ ├── ApiResourceMappersTests.cs │ │ ├── ClientMappersTests.cs │ │ ├── IdentityResourcesMappersTests.cs │ │ ├── PersistedGrantMappersTests.cs │ │ └── ScopeMappersTests.cs │ ├── IdentityServer8/ │ │ ├── Directory.Build.props │ │ ├── IdentityServer8.sln │ │ ├── build.cmd │ │ ├── build.ps1 │ │ ├── build.sh │ │ ├── host/ │ │ │ ├── Configuration/ │ │ │ │ ├── Clients.cs │ │ │ │ ├── ClientsConsole.cs │ │ │ │ ├── ClientsWeb.cs │ │ │ │ └── Resources.cs │ │ │ ├── Extensions/ │ │ │ │ ├── ExtensionGrantValidator.cs │ │ │ │ ├── HostProfileService.cs │ │ │ │ ├── NoSubjectExtensionGrantValidator.cs │ │ │ │ ├── ParameterizedScopeParser.cs │ │ │ │ ├── ParameterizedScopeTokenRequestValidator.cs │ │ │ │ └── SameSiteHandlingExtensions.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Host.csproj │ │ │ ├── Keys/ │ │ │ │ ├── identityserver.test.ecdsa.p12 │ │ │ │ └── identityserver.test.rsa.p12 │ │ │ ├── LocalApiController.cs │ │ │ ├── Program.cs │ │ │ ├── Properties/ │ │ │ │ └── launchSettings.json │ │ │ ├── Quickstart/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccountController.cs │ │ │ │ │ ├── AccountOptions.cs │ │ │ │ │ ├── ExternalController.cs │ │ │ │ │ ├── ExternalProvider.cs │ │ │ │ │ ├── LoggedOutViewModel.cs │ │ │ │ │ ├── LoginInputModel.cs │ │ │ │ │ ├── LoginViewModel.cs │ │ │ │ │ ├── LogoutInputModel.cs │ │ │ │ │ ├── LogoutViewModel.cs │ │ │ │ │ └── RedirectViewModel.cs │ │ │ │ ├── Consent/ │ │ │ │ │ ├── ConsentController.cs │ │ │ │ │ ├── ConsentInputModel.cs │ │ │ │ │ ├── ConsentOptions.cs │ │ │ │ │ ├── ConsentViewModel.cs │ │ │ │ │ ├── ProcessConsentResult.cs │ │ │ │ │ └── ScopeViewModel.cs │ │ │ │ ├── Device/ │ │ │ │ │ ├── DeviceAuthorizationInputModel.cs │ │ │ │ │ ├── DeviceAuthorizationViewModel.cs │ │ │ │ │ └── DeviceController.cs │ │ │ │ ├── Diagnostics/ │ │ │ │ │ ├── DiagnosticsController.cs │ │ │ │ │ └── DiagnosticsViewModel.cs │ │ │ │ ├── Extensions.cs │ │ │ │ ├── Grants/ │ │ │ │ │ ├── GrantsController.cs │ │ │ │ │ └── GrantsViewModel.cs │ │ │ │ ├── Home/ │ │ │ │ │ ├── ErrorViewModel.cs │ │ │ │ │ └── HomeController.cs │ │ │ │ ├── SecurityHeadersAttribute.cs │ │ │ │ └── TestUsers.cs │ │ │ ├── Startup.cs │ │ │ ├── Views/ │ │ │ │ ├── Account/ │ │ │ │ │ ├── AccessDenied.cshtml │ │ │ │ │ ├── LoggedOut.cshtml │ │ │ │ │ ├── Login.cshtml │ │ │ │ │ └── Logout.cshtml │ │ │ │ ├── Consent/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Device/ │ │ │ │ │ ├── Success.cshtml │ │ │ │ │ ├── UserCodeCapture.cshtml │ │ │ │ │ └── UserCodeConfirmation.cshtml │ │ │ │ ├── Diagnostics/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Grants/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Home/ │ │ │ │ │ └── Index.cshtml │ │ │ │ ├── Shared/ │ │ │ │ │ ├── Error.cshtml │ │ │ │ │ ├── Redirect.cshtml │ │ │ │ │ ├── _Layout.cshtml │ │ │ │ │ ├── _Nav.cshtml │ │ │ │ │ ├── _ScopeListItem.cshtml │ │ │ │ │ └── _ValidationSummary.cshtml │ │ │ │ ├── _ViewImports.cshtml │ │ │ │ └── _ViewStart.cshtml │ │ │ ├── appsettings.json │ │ │ ├── compilerconfig.json │ │ │ ├── compilerconfig.json.defaults │ │ │ ├── libman.json │ │ │ └── wwwroot/ │ │ │ ├── css/ │ │ │ │ ├── site.css │ │ │ │ └── site.scss │ │ │ └── js/ │ │ │ ├── signin-redirect.js │ │ │ └── signout-redirect.js │ │ ├── src/ │ │ │ ├── Configuration/ │ │ │ │ ├── CryptoHelper.cs │ │ │ │ ├── DependencyInjection/ │ │ │ │ │ ├── BuilderExtensions/ │ │ │ │ │ │ ├── Additional.cs │ │ │ │ │ │ ├── Core.cs │ │ │ │ │ │ ├── Crypto.cs │ │ │ │ │ │ └── InMemory.cs │ │ │ │ │ ├── ConfigureInternalCookieOptions.cs │ │ │ │ │ ├── ConfigureOpenIdConnectOptions.cs │ │ │ │ │ ├── Decorator.cs │ │ │ │ │ ├── IIdentityServerBuilder.cs │ │ │ │ │ ├── IdentityServerBuilder.cs │ │ │ │ │ ├── IdentityServerServiceCollectionExtensions.cs │ │ │ │ │ └── Options/ │ │ │ │ │ ├── AuthenticationOptions.cs │ │ │ │ │ ├── CachingOptions.cs │ │ │ │ │ ├── CorsOptions.cs │ │ │ │ │ ├── CspOptions.cs │ │ │ │ │ ├── DeviceFlowOptions.cs │ │ │ │ │ ├── DiscoveryOptions.cs │ │ │ │ │ ├── EndpointOptions.cs │ │ │ │ │ ├── EventsOptions.cs │ │ │ │ │ ├── IdentityServerOptions.cs │ │ │ │ │ ├── InputLengthRestrictions.cs │ │ │ │ │ ├── LoggingOptions.cs │ │ │ │ │ ├── MtlsOptions.cs │ │ │ │ │ ├── UserInteractionOptions.cs │ │ │ │ │ └── ValidationOptions.cs │ │ │ │ ├── IdentityServerApplicationBuilderExtensions.cs │ │ │ │ └── IdentityServerMiddlewareOptions.cs │ │ │ ├── Constants.cs │ │ │ ├── Endpoints/ │ │ │ │ ├── AuthorizeCallbackEndpoint.cs │ │ │ │ ├── AuthorizeEndpoint.cs │ │ │ │ ├── AuthorizeEndpointBase.cs │ │ │ │ ├── CheckSessionEndpoint.cs │ │ │ │ ├── DeviceAuthorizationEndpoint.cs │ │ │ │ ├── DiscoveryEndpoint.cs │ │ │ │ ├── DiscoveryKeyEndpoint.cs │ │ │ │ ├── EndSessionCallbackEndpoint.cs │ │ │ │ ├── EndSessionEndpoint.cs │ │ │ │ ├── IntrospectionEndpoint.cs │ │ │ │ ├── Results/ │ │ │ │ │ ├── AuthorizeResult.cs │ │ │ │ │ ├── BadRequestResult.cs │ │ │ │ │ ├── CheckSessionResult.cs │ │ │ │ │ ├── ConsentPageResult.cs │ │ │ │ │ ├── CustomRedirectResult.cs │ │ │ │ │ ├── DeviceAuthorizationResult.cs │ │ │ │ │ ├── DiscoveryDocumentResult.cs │ │ │ │ │ ├── EndSessionCallbackResult.cs │ │ │ │ │ ├── EndSessionResult.cs │ │ │ │ │ ├── IntrospectionResult.cs │ │ │ │ │ ├── JsonWebKeysResult.cs │ │ │ │ │ ├── LoginPageResult.cs │ │ │ │ │ ├── ProtectedResourceErrorResult.cs │ │ │ │ │ ├── StatusCodeResult.cs │ │ │ │ │ ├── TokenErrorResult.cs │ │ │ │ │ ├── TokenResult.cs │ │ │ │ │ ├── TokenRevocationErrorResult.cs │ │ │ │ │ └── UserInfoResult.cs │ │ │ │ ├── TokenEndpoint.cs │ │ │ │ ├── TokenRevocationEndpoint.cs │ │ │ │ └── UserInfoEndpoint.cs │ │ │ ├── Events/ │ │ │ │ ├── ApiAuthenticationFailureEvent.cs │ │ │ │ ├── ApiAuthenticationSuccessEvent.cs │ │ │ │ ├── ClientAuthenticationFailureEvent.cs │ │ │ │ ├── ClientAuthenticationSuccessEvent.cs │ │ │ │ ├── ConsentDeniedEvent.cs │ │ │ │ ├── ConsentGrantedEvent.cs │ │ │ │ ├── DeviceAuthorizationFailureEvent.cs │ │ │ │ ├── DeviceAuthorizationSuccessEvent.cs │ │ │ │ ├── GrantsRevokedEvent.cs │ │ │ │ ├── Infrastructure/ │ │ │ │ │ ├── Event.cs │ │ │ │ │ ├── EventCategories.cs │ │ │ │ │ ├── EventIds.cs │ │ │ │ │ └── EventType.cs │ │ │ │ ├── InvalidClientConfiguration.cs │ │ │ │ ├── TokenIntrospectionFailureEvent.cs │ │ │ │ ├── TokenIntrospectionSuccessEvent.cs │ │ │ │ ├── TokenIssuedFailureEvent.cs │ │ │ │ ├── TokenIssuedSuccessEvent.cs │ │ │ │ ├── TokenRevokedSuccessEvent.cs │ │ │ │ ├── UnhandledExceptionEvent.cs │ │ │ │ ├── UserLoginFailureEvent.cs │ │ │ │ ├── UserLoginSuccessEvent.cs │ │ │ │ └── UserLogoutSuccessEvent.cs │ │ │ ├── Extensions/ │ │ │ │ ├── AuthenticationPropertiesExtensions.cs │ │ │ │ ├── AuthorizeResponseExtensions.cs │ │ │ │ ├── ClaimsExtensions.cs │ │ │ │ ├── ClientExtensions.cs │ │ │ │ ├── DateTimeExtensions.cs │ │ │ │ ├── EndpointOptionsExtensions.cs │ │ │ │ ├── HashExtensions.cs │ │ │ │ ├── HttpContextAuthenticationExtensions.cs │ │ │ │ ├── HttpContextExtensions.cs │ │ │ │ ├── HttpRequestExtensions.cs │ │ │ │ ├── HttpResponseExtensions.cs │ │ │ │ ├── ICacheExtensions.cs │ │ │ │ ├── IClientStoreExtensions.cs │ │ │ │ ├── IEnumerableExtensions.cs │ │ │ │ ├── IReadableStringCollectionExtensions.cs │ │ │ │ ├── IResourceStoreExtensions.cs │ │ │ │ ├── IUserSessionExtensions.cs │ │ │ │ ├── IdentityServerToolsExtensions.cs │ │ │ │ ├── JsonExtensions.cs │ │ │ │ ├── NameValueCollectionExtensions.cs │ │ │ │ ├── PrincipalExtensions.cs │ │ │ │ ├── ProfileDataRequestContextExtensions.cs │ │ │ │ ├── ResourceExtensions.cs │ │ │ │ ├── ScopeExtensions.cs │ │ │ │ ├── StringsExtensions.cs │ │ │ │ ├── TokenExtensions.cs │ │ │ │ ├── ValidatedAuthorizeRequestExtensions.cs │ │ │ │ └── X509CertificateExtensions.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── Hosting/ │ │ │ │ ├── BaseUrlMiddleware.cs │ │ │ │ ├── CorsMiddleware.cs │ │ │ │ ├── CorsPolicyProvider.cs │ │ │ │ ├── Endpoint.cs │ │ │ │ ├── EndpointRouter.cs │ │ │ │ ├── FederatedSignOut/ │ │ │ │ │ ├── AuthenticationRequestHandlerWrapper.cs │ │ │ │ │ ├── AuthenticationRequestSignInHandlerWrapper.cs │ │ │ │ │ ├── AuthenticationRequestSignOutHandlerWrapper.cs │ │ │ │ │ └── FederatedSignoutAuthenticationHandlerProvider.cs │ │ │ │ ├── IEndpointHandler.cs │ │ │ │ ├── IEndpointResult.cs │ │ │ │ ├── IEndpointRouter.cs │ │ │ │ ├── IdentityServerAuthenticationService.cs │ │ │ │ ├── IdentityServerMiddleware.cs │ │ │ │ ├── LocalApiAuthentication/ │ │ │ │ │ ├── LocalApiAuthenticationEvents.cs │ │ │ │ │ ├── LocalApiAuthenticationExtensions.cs │ │ │ │ │ ├── LocalApiAuthenticationHandler.cs │ │ │ │ │ └── LocalApiAuthenticationOptions.cs │ │ │ │ └── MutualTlsEndpointMiddleware.cs │ │ │ ├── IdentityServer8.csproj │ │ │ ├── IdentityServerConstants.cs │ │ │ ├── IdentityServerTools.cs │ │ │ ├── IdentityServerUser.cs │ │ │ ├── Infrastructure/ │ │ │ │ ├── DistributedCacheStateDataFormatter.cs │ │ │ │ ├── MessageCookie.cs │ │ │ │ └── ObjectSerializer.cs │ │ │ ├── Logging/ │ │ │ │ ├── LogSerializer.cs │ │ │ │ └── Models/ │ │ │ │ ├── AuthorizeRequestValidationLog.cs │ │ │ │ ├── AuthorizeResponseLog.cs │ │ │ │ ├── DeviceAuthorizationRequestValidationLog.cs │ │ │ │ ├── EndSessionRequestValidationLog.cs │ │ │ │ ├── TokenRequestValidationLog.cs │ │ │ │ └── TokenValidationLog.cs │ │ │ ├── Models/ │ │ │ │ ├── Contexts/ │ │ │ │ │ ├── IsActiveContext.cs │ │ │ │ │ ├── LogoutNotificationContext.cs │ │ │ │ │ └── ProfileDataRequestContext.cs │ │ │ │ ├── DeviceFlowAuthorizationRequest.cs │ │ │ │ ├── DeviceFlowInteractionResult.cs │ │ │ │ ├── DiscoveryDocument.cs │ │ │ │ ├── Grant.cs │ │ │ │ ├── GrantTypes.cs │ │ │ │ ├── IdentityResources.cs │ │ │ │ ├── JsonWebKey.cs │ │ │ │ ├── Messages/ │ │ │ │ │ ├── AuthorizationRequest.cs │ │ │ │ │ ├── ConsentRequest.cs │ │ │ │ │ ├── ConsentResponse.cs │ │ │ │ │ ├── ErrorMessage.cs │ │ │ │ │ ├── LogoutRequest.cs │ │ │ │ │ └── Message.cs │ │ │ │ ├── ParsedSecret.cs │ │ │ │ ├── SecurityKeyInfo.cs │ │ │ │ ├── TokenCreationRequest.cs │ │ │ │ └── TokenRequestErrors.cs │ │ │ ├── Properties/ │ │ │ │ └── AssemblyInfo.cs │ │ │ ├── ResponseHandling/ │ │ │ │ ├── Default/ │ │ │ │ │ ├── AuthorizeInteractionResponseGenerator.cs │ │ │ │ │ ├── AuthorizeResponseGenerator.cs │ │ │ │ │ ├── DeviceAuthorizationResponseGenerator.cs │ │ │ │ │ ├── DiscoveryResponseGenerator.cs │ │ │ │ │ ├── IntrospectionResponseGenerator.cs │ │ │ │ │ ├── TokenResponseGenerator.cs │ │ │ │ │ ├── TokenRevocationResponseGenerator.cs │ │ │ │ │ └── UserInfoResponseGenerator.cs │ │ │ │ ├── IAuthorizeInteractionResponseGenerator.cs │ │ │ │ ├── IAuthorizeResponseGenerator.cs │ │ │ │ ├── IDeviceAuthorizationResponseGenerator.cs │ │ │ │ ├── IDiscoveryResponseGenerator.cs │ │ │ │ ├── IIntrospectionResponseGenerator.cs │ │ │ │ ├── ITokenResponseGenerator.cs │ │ │ │ ├── ITokenRevocationResponseGenerator.cs │ │ │ │ ├── IUserInfoResponseGenerator.cs │ │ │ │ └── Models/ │ │ │ │ ├── AuthorizeResponse.cs │ │ │ │ ├── DeviceAuthorizationResponse.cs │ │ │ │ ├── InteractionResponse.cs │ │ │ │ ├── TokenErrorResponse.cs │ │ │ │ ├── TokenResponse.cs │ │ │ │ └── TokenRevocationResponse.cs │ │ │ ├── Services/ │ │ │ │ ├── Default/ │ │ │ │ │ ├── BackChannelLogoutHttpClient.cs │ │ │ │ │ ├── DefaultBackChannelLogoutService.cs │ │ │ │ │ ├── DefaultCache.cs │ │ │ │ │ ├── DefaultClaimsService.cs │ │ │ │ │ ├── DefaultConsentService.cs │ │ │ │ │ ├── DefaultCorsPolicyService.cs │ │ │ │ │ ├── DefaultDeviceFlowCodeService.cs │ │ │ │ │ ├── DefaultDeviceFlowInteractionService.cs │ │ │ │ │ ├── DefaultEventService.cs │ │ │ │ │ ├── DefaultEventSink.cs │ │ │ │ │ ├── DefaultHandleGenerationService.cs │ │ │ │ │ ├── DefaultIdentityServerInteractionService.cs │ │ │ │ │ ├── DefaultJwtRequestUriHttpClient.cs │ │ │ │ │ ├── DefaultKeyMaterialService.cs │ │ │ │ │ ├── DefaultPersistedGrantService.cs │ │ │ │ │ ├── DefaultProfileService.cs │ │ │ │ │ ├── DefaultRefreshTokenService.cs │ │ │ │ │ ├── DefaultReplayCache.cs │ │ │ │ │ ├── DefaultTokenCreationService.cs │ │ │ │ │ ├── DefaultTokenService.cs │ │ │ │ │ ├── DefaultUserCodeService.cs │ │ │ │ │ ├── DefaultUserSession.cs │ │ │ │ │ ├── DistributedDeviceFlowThrottlingService.cs │ │ │ │ │ ├── LogoutNotificationService.cs │ │ │ │ │ ├── NumericUserCodeGenerator.cs │ │ │ │ │ ├── OidcReturnUrlParser.cs │ │ │ │ │ └── ReturnUrlParser.cs │ │ │ │ ├── IBackChannelLogoutHttpClient.cs │ │ │ │ ├── IBackChannelLogoutService.cs │ │ │ │ ├── ICache.cs │ │ │ │ ├── IClaimsService.cs │ │ │ │ ├── IConsentService.cs │ │ │ │ ├── IDeviceFlowCodeService.cs │ │ │ │ ├── IDeviceFlowInteractionService.cs │ │ │ │ ├── IDeviceFlowThrottlingService.cs │ │ │ │ ├── IEventService.cs │ │ │ │ ├── IEventSink.cs │ │ │ │ ├── IHandleGenerationService.cs │ │ │ │ ├── IIdentityServerInteractionService.cs │ │ │ │ ├── IJwtRequestUriHttpClient.cs │ │ │ │ ├── IKeyMaterialService.cs │ │ │ │ ├── ILogoutNotificationService.cs │ │ │ │ ├── IPersistedGrantService.cs │ │ │ │ ├── IProfileService.cs │ │ │ │ ├── IRefreshTokenService.cs │ │ │ │ ├── IReplayCache.cs │ │ │ │ ├── IReturnUrlParser.cs │ │ │ │ ├── ITokenCreationService.cs │ │ │ │ ├── ITokenService.cs │ │ │ │ ├── IUserCodeGenerator.cs │ │ │ │ ├── IUserCodeService.cs │ │ │ │ ├── IUserSession.cs │ │ │ │ └── InMemory/ │ │ │ │ └── InMemoryCorsPolicyService.cs │ │ │ ├── Stores/ │ │ │ │ ├── Caching/ │ │ │ │ │ ├── CachingClientStore.cs │ │ │ │ │ ├── CachingCorsPolicyService.cs │ │ │ │ │ └── CachingResourceStore.cs │ │ │ │ ├── Default/ │ │ │ │ │ ├── ConsentMessageStore.cs │ │ │ │ │ ├── DefaultAuthorizationCodeStore.cs │ │ │ │ │ ├── DefaultGrantStore.cs │ │ │ │ │ ├── DefaultReferenceTokenStore.cs │ │ │ │ │ ├── DefaultRefreshTokenStore.cs │ │ │ │ │ ├── DefaultUserConsentStore.cs │ │ │ │ │ ├── DistributedCacheAuthorizationParametersMessageStore.cs │ │ │ │ │ ├── ProtectedDataMessageStore.cs │ │ │ │ │ └── QueryStringAuthorizationParametersMessageStore.cs │ │ │ │ ├── IAuthorizationParametersMessageStore.cs │ │ │ │ ├── IConsentMessageStore.cs │ │ │ │ ├── IMessageStore.cs │ │ │ │ ├── ISigningCredentialStore.cs │ │ │ │ ├── IValidationKeysStore.cs │ │ │ │ ├── InMemory/ │ │ │ │ │ ├── InMemoryClientStore.cs │ │ │ │ │ ├── InMemoryDeviceFlowStore.cs │ │ │ │ │ ├── InMemoryPersistedGrantStore.cs │ │ │ │ │ ├── InMemoryResourcesStore.cs │ │ │ │ │ ├── InMemorySigningCredentialsStore.cs │ │ │ │ │ └── InMemoryValidationKeysStore.cs │ │ │ │ └── ValidatingClientStore.cs │ │ │ ├── Test/ │ │ │ │ ├── IdentityServerBuilderExtensions.cs │ │ │ │ ├── TestUser.cs │ │ │ │ ├── TestUserProfileService.cs │ │ │ │ ├── TestUserResourceOwnerPasswordValidator.cs │ │ │ │ └── TestUserStore.cs │ │ │ └── Validation/ │ │ │ ├── Contexts/ │ │ │ │ ├── ClientConfigurationValidationContext.cs │ │ │ │ ├── CustomAuthorizeRequestValidationContext.cs │ │ │ │ ├── CustomTokenRequestValidationContext.cs │ │ │ │ ├── ExtensionGrantValidationContext.cs │ │ │ │ ├── ResourceOwnerPasswordValidationContext.cs │ │ │ │ └── ResourceValidationContext.cs │ │ │ ├── Default/ │ │ │ │ ├── ApiSecretValidator.cs │ │ │ │ ├── AuthorizeRequestValidator.cs │ │ │ │ ├── BasicAuthenticationSecretParser.cs │ │ │ │ ├── BearerTokenUsageValidator.cs │ │ │ │ ├── ClientSecretValidator.cs │ │ │ │ ├── DefaultClientConfigurationValidator.cs │ │ │ │ ├── DefaultCustomAuthorizeRequestValidator.cs │ │ │ │ ├── DefaultCustomTokenRequestValidator.cs │ │ │ │ ├── DefaultCustomTokenValidator.cs │ │ │ │ ├── DefaultResourceValidator.cs │ │ │ │ ├── DefaultScopeParser.cs │ │ │ │ ├── DeviceAuthorizationRequestValidator.cs │ │ │ │ ├── DeviceCodeValidator.cs │ │ │ │ ├── EndSessionRequestValidator.cs │ │ │ │ ├── ExtensionGrantValidator.cs │ │ │ │ ├── HashedSharedSecretValidator.cs │ │ │ │ ├── IntrospectionRequestValidator.cs │ │ │ │ ├── JwtBearerClientAssertionSecretParser.cs │ │ │ │ ├── JwtRequestValidator.cs │ │ │ │ ├── MutualTlsSecretParser.cs │ │ │ │ ├── NopClientConfigurationValidator.cs │ │ │ │ ├── NotSupportedResouceOwnerCredentialValidator.cs │ │ │ │ ├── PlainTextSharedSecretValidator.cs │ │ │ │ ├── PostBodySecretParser.cs │ │ │ │ ├── PrivateKeyJwtSecretValidator.cs │ │ │ │ ├── ResponseTypeEqualityComparer.cs │ │ │ │ ├── SecretParser.cs │ │ │ │ ├── SecretValidator.cs │ │ │ │ ├── StrictRedirectUriValidator.cs │ │ │ │ ├── StrictRedirectUriValidatorAppAuth.cs │ │ │ │ ├── TokenRequestValidator.cs │ │ │ │ ├── TokenRevocationRequestValidator.cs │ │ │ │ ├── TokenValidator.cs │ │ │ │ ├── UserInfoRequestValidator.cs │ │ │ │ ├── X509NameSecretValidator.cs │ │ │ │ └── X509ThumbprintSecretValidator.cs │ │ │ ├── IApiSecretValidator.cs │ │ │ ├── IAuthorizeRequestValidator.cs │ │ │ ├── IClientConfigurationValidator.cs │ │ │ ├── IClientSecretValidator.cs │ │ │ ├── ICustomAuthorizeRequestValidator.cs │ │ │ ├── ICustomTokenRequestValidator.cs │ │ │ ├── ICustomTokenValidator.cs │ │ │ ├── IDeviceAuthorizationRequestValidator.cs │ │ │ ├── IDeviceCodeValidator.cs │ │ │ ├── IEndSessionRequestValidator.cs │ │ │ ├── IExtensionGrantValidator.cs │ │ │ ├── IIntrospectionRequestValidator.cs │ │ │ ├── IRedirectUriValidator.cs │ │ │ ├── IResourceOwnerPasswordValidator.cs │ │ │ ├── IResourceValidator.cs │ │ │ ├── IScopeParser.cs │ │ │ ├── ISecretParser.cs │ │ │ ├── ISecretValidator.cs │ │ │ ├── ISecretsListParser.cs │ │ │ ├── ISecretsListValidator.cs │ │ │ ├── ITokenRequestValidator.cs │ │ │ ├── ITokenRevocationRequestValidator.cs │ │ │ ├── ITokenValidator.cs │ │ │ ├── IUserInfoRequestValidator.cs │ │ │ └── Models/ │ │ │ ├── AuthorizeRequestValidationResult.cs │ │ │ ├── BearerTokenUsageType.cs │ │ │ ├── BearerTokenUsageValidationResult.cs │ │ │ ├── ClientSecretValidationResult.cs │ │ │ ├── DeviceAuthorizationRequestValidationResult.cs │ │ │ ├── DeviceCodeValidationContext.cs │ │ │ ├── EndSessionCallbackValidationResult.cs │ │ │ ├── EndSessionValidationResult.cs │ │ │ ├── GrantValidationResult.cs │ │ │ ├── IntrospectionRequestValidationResult.cs │ │ │ ├── JwtRequestValidationResult.cs │ │ │ ├── ParsedScopeValidationError.cs │ │ │ ├── ParsedScopeValue.cs │ │ │ ├── ParsedScopesResult.cs │ │ │ ├── ResourceValidationRequest.cs │ │ │ ├── ResourceValidationResult.cs │ │ │ ├── ScopeSecretValidationResult.cs │ │ │ ├── SecretValidationResult.cs │ │ │ ├── TokenRequestValidationResult.cs │ │ │ ├── TokenRevocationRequestValidationResult.cs │ │ │ ├── TokenValidationResult.cs │ │ │ ├── UserInfoRequestValidationResult.cs │ │ │ ├── ValidatedAuthorizeRequest.cs │ │ │ ├── ValidatedDeviceAuthorizationRequest.cs │ │ │ ├── ValidatedEndSessionRequest.cs │ │ │ ├── ValidatedRequest.cs │ │ │ ├── ValidatedTokenRequest.cs │ │ │ └── ValidationResult.cs │ │ └── test/ │ │ ├── IdentityServer.IntegrationTests/ │ │ │ ├── Clients/ │ │ │ │ ├── ClientAssertionClient.cs │ │ │ │ ├── ClientCredentialsAndResourceOwnerClient.cs │ │ │ │ ├── ClientCredentialsClient.cs │ │ │ │ ├── CustomTokenRequestValidatorClient.cs │ │ │ │ ├── CustomTokenResponseClients.cs │ │ │ │ ├── DiscoveryClient.cs │ │ │ │ ├── ExtensionGrantClient.cs │ │ │ │ ├── RefreshTokenClient.cs │ │ │ │ ├── ResourceOwnerClient.cs │ │ │ │ ├── RevocationClient.cs │ │ │ │ ├── Setup/ │ │ │ │ │ ├── Clients.cs │ │ │ │ │ ├── ConfirmationSecretValidator.cs │ │ │ │ │ ├── CustomProfileService.cs │ │ │ │ │ ├── CustomResponseDto.cs │ │ │ │ │ ├── CustomResponseExtensionGrantValidator.cs │ │ │ │ │ ├── CustomResponseResourceOwnerValidator.cs │ │ │ │ │ ├── DynamicParameterExtensionGrantValidator.cs │ │ │ │ │ ├── ExtensionGrantValidator.cs │ │ │ │ │ ├── ExtensionGrantValidator2.cs │ │ │ │ │ ├── NoSubjectExtensionGrantValidator.cs │ │ │ │ │ ├── Scopes.cs │ │ │ │ │ ├── Startup.cs │ │ │ │ │ ├── StartupWithCustomTokenResponses.cs │ │ │ │ │ ├── TestCustomTokenRequestValidator.cs │ │ │ │ │ └── Users.cs │ │ │ │ └── UserInfoClient.cs │ │ │ ├── Common/ │ │ │ │ ├── BrowserClient.cs │ │ │ │ ├── BrowserHandler.cs │ │ │ │ ├── IdentityServerPipeline.cs │ │ │ │ ├── MessageHandlerWrapper.cs │ │ │ │ ├── NetworkHandler.cs │ │ │ │ └── TestCert.cs │ │ │ ├── Conformance/ │ │ │ │ ├── Basic/ │ │ │ │ │ ├── ClientAuthenticationTests.cs │ │ │ │ │ ├── CodeFlowTests.cs │ │ │ │ │ ├── RedirectUriTests.cs │ │ │ │ │ └── ResponseTypeResponseModeTests.cs │ │ │ │ └── Pkce/ │ │ │ │ └── PkceTests.cs │ │ │ ├── Endpoints/ │ │ │ │ ├── Authorize/ │ │ │ │ │ ├── AuthorizeTests.cs │ │ │ │ │ ├── ConsentTests.cs │ │ │ │ │ ├── JwtRequestAuthorizeTests.cs │ │ │ │ │ ├── RestrictAccessTokenViaBrowserTests.cs │ │ │ │ │ └── SessionIdTests.cs │ │ │ │ ├── CheckSession/ │ │ │ │ │ └── CheckSessionTests.cs │ │ │ │ ├── DeviceAuthorization/ │ │ │ │ │ └── DeviceAuthorizationTests.cs │ │ │ │ ├── Discovery/ │ │ │ │ │ └── DiscoveryEndpointTests.cs │ │ │ │ ├── EndSession/ │ │ │ │ │ └── EndSessionTests.cs │ │ │ │ ├── Introspection/ │ │ │ │ │ ├── IntrospectionTests.cs │ │ │ │ │ └── Setup/ │ │ │ │ │ ├── Clients.cs │ │ │ │ │ ├── Scopes.cs │ │ │ │ │ ├── Startup.cs │ │ │ │ │ └── Users.cs │ │ │ │ ├── Revocation/ │ │ │ │ │ └── RevocationTests.cs │ │ │ │ └── Token/ │ │ │ │ └── TokenEndpointTests.cs │ │ │ ├── Extensibility/ │ │ │ │ └── CustomProfileServiceTests.cs │ │ │ ├── IdentityServer.IntegrationTests.csproj │ │ │ ├── Pipeline/ │ │ │ │ ├── CorsTests.cs │ │ │ │ ├── FederatedSignoutTests.cs │ │ │ │ └── SubpathHosting.cs │ │ │ ├── identityserver_testing.cer │ │ │ └── xunit.runner.json │ │ └── IdentityServer.UnitTests/ │ │ ├── Common/ │ │ │ ├── IAuthenticationSchemeHandler.cs │ │ │ ├── MockAuthenticationHandler.cs │ │ │ ├── MockAuthenticationHandlerProvider.cs │ │ │ ├── MockAuthenticationSchemeProvider.cs │ │ │ ├── MockAuthenticationService.cs │ │ │ ├── MockClaimsService.cs │ │ │ ├── MockClientSessionService.cs │ │ │ ├── MockConsentMessageStore.cs │ │ │ ├── MockConsentService.cs │ │ │ ├── MockHttpContextAccessor.cs │ │ │ ├── MockKeyMaterialService.cs │ │ │ ├── MockLogoutNotificationService.cs │ │ │ ├── MockMessageStore.cs │ │ │ ├── MockPersistedGrantService.cs │ │ │ ├── MockProfileService.cs │ │ │ ├── MockReferenceTokenStore.cs │ │ │ ├── MockResourceValidator.cs │ │ │ ├── MockReturnUrlParser.cs │ │ │ ├── MockSessionIdService.cs │ │ │ ├── MockSystemClock.cs │ │ │ ├── MockTokenCreationService.cs │ │ │ ├── MockUserSession.cs │ │ │ ├── NetworkHandler.cs │ │ │ ├── StubAuthorizeResponseGenerator.cs │ │ │ ├── StubClock.cs │ │ │ ├── StubHandleGenerationService.cs │ │ │ ├── TestCert.cs │ │ │ ├── TestEventService.cs │ │ │ ├── TestExtensions.cs │ │ │ ├── TestIdentityServerOptions.cs │ │ │ ├── TestLogger.cs │ │ │ └── TestUserConsentStore.cs │ │ ├── Cors/ │ │ │ ├── MockCorsPolicyProvider.cs │ │ │ ├── MockCorsPolicyService.cs │ │ │ └── PolicyProviderTests.cs │ │ ├── Endpoints/ │ │ │ ├── Authorize/ │ │ │ │ ├── AuthorizeCallbackEndpointTests.cs │ │ │ │ ├── AuthorizeEndpointBaseTests.cs │ │ │ │ ├── AuthorizeEndpointTests.cs │ │ │ │ ├── StubAuthorizeInteractionResponseGenerator.cs │ │ │ │ └── StubAuthorizeRequestValidator.cs │ │ │ ├── EndSession/ │ │ │ │ ├── EndSessionCallbackEndpointTests.cs │ │ │ │ ├── EndSessionCallbackResultTests.cs │ │ │ │ ├── StubBackChannelLogoutClient.cs │ │ │ │ └── StubEndSessionRequestValidator.cs │ │ │ └── Results/ │ │ │ ├── AuthorizeResultTests.cs │ │ │ ├── CheckSessionResultTests.cs │ │ │ ├── EndSessionCallbackResultTests.cs │ │ │ └── EndSessionResultTests.cs │ │ ├── Extensions/ │ │ │ ├── ApiResourceSigningAlgorithmSelectionTests.cs │ │ │ ├── EndpointOptionsExtensionsTests.cs │ │ │ ├── HttpRequestExtensionsTests.cs │ │ │ ├── IResourceStoreExtensionsTests.cs │ │ │ ├── IdentityServerBuilderExtensionsCacheStoreTests.cs │ │ │ ├── IdentityServerBuilderExtensionsCryptoTests.cs │ │ │ ├── JwtPayloadCreationTests.cs │ │ │ ├── StringExtensionsTests.cs │ │ │ └── ValidatedAuthorizeRequestExtensionsTests.cs │ │ ├── Hosting/ │ │ │ └── EndpointRouterTests.cs │ │ ├── IdentityServer.UnitTests.csproj │ │ ├── Infrastructure/ │ │ │ └── ObjectSerializerTests.cs │ │ ├── ResponseHandling/ │ │ │ ├── AuthorizeInteractionResponseGenerator/ │ │ │ │ ├── AuthorizeInteractionResponseGeneratorTests.cs │ │ │ │ ├── AuthorizeInteractionResponseGeneratorTests_Consent.cs │ │ │ │ ├── AuthorizeInteractionResponseGeneratorTests_Custom.cs │ │ │ │ └── AuthorizeInteractionResponseGeneratorTests_Login.cs │ │ │ ├── DeviceAuthorizationResponseGeneratorTests.cs │ │ │ └── UserInfoResponseGeneratorTests.cs │ │ ├── Services/ │ │ │ ├── Default/ │ │ │ │ ├── DefaultClaimsServiceTests.cs │ │ │ │ ├── DefaultConsentServiceTests.cs │ │ │ │ ├── DefaultCorsPolicyServiceTests.cs │ │ │ │ ├── DefaultIdentityServerInteractionServiceTests.cs │ │ │ │ ├── DefaultPersistedGrantServiceTests.cs │ │ │ │ ├── DefaultRefreshTokenServiceTests.cs │ │ │ │ ├── DefaultTokenServiceTests.cs │ │ │ │ ├── DefaultUserSessionTests.cs │ │ │ │ ├── DistributedDeviceFlowThrottlingServiceTests.cs │ │ │ │ └── NumericUserCodeServiceTests.cs │ │ │ └── InMemory/ │ │ │ └── InMemoryCorsPolicyService.cs │ │ ├── Stores/ │ │ │ ├── Default/ │ │ │ │ └── DefaultPersistedGrantStoreTests.cs │ │ │ ├── InMemoryClientStoreTests.cs │ │ │ ├── InMemoryDeviceFlowStoreTests.cs │ │ │ ├── InMemoryPersistedGrantStoreTests.cs │ │ │ └── InMemoryResourcesStoreTests.cs │ │ ├── Validation/ │ │ │ ├── AccessTokenValidation.cs │ │ │ ├── AuthorizeRequest Validation/ │ │ │ │ ├── Authorize_ClientValidation_Code.cs │ │ │ │ ├── Authorize_ClientValidation_IdToken.cs │ │ │ │ ├── Authorize_ClientValidation_Invalid.cs │ │ │ │ ├── Authorize_ClientValidation_Token.cs │ │ │ │ ├── Authorize_ClientValidation_Valid.cs │ │ │ │ ├── Authorize_ProtocolValidation_CustomValidator.cs │ │ │ │ ├── Authorize_ProtocolValidation_Invalid.cs │ │ │ │ ├── Authorize_ProtocolValidation_PKCE.cs │ │ │ │ └── Authorize_ProtocolValidation_Valid.cs │ │ │ ├── BearerTokenUsageValidation.cs │ │ │ ├── ClientConfigurationValidation.cs │ │ │ ├── DeviceAuthorizationRequestValidation.cs │ │ │ ├── DeviceCodeValidation.cs │ │ │ ├── EndSessionRequestValidation/ │ │ │ │ ├── EndSessionRequestValidatorTests.cs │ │ │ │ ├── StubRedirectUriValidator.cs │ │ │ │ └── StubTokenValidator.cs │ │ │ ├── GrantTypesValidation.cs │ │ │ ├── IdentityTokenValidation.cs │ │ │ ├── IntrospectionRequestValidatorTests.cs │ │ │ ├── ResourceValidation.cs │ │ │ ├── ResponseTypeEqualityComparison.cs │ │ │ ├── RevocationRequestValidation.cs │ │ │ ├── Secrets/ │ │ │ │ ├── BasicAuthenticationCredentialParsing.cs │ │ │ │ ├── ClientAssertionSecretParsing.cs │ │ │ │ ├── ClientSecretValidation.cs │ │ │ │ ├── FormPostCredentialParsing.cs │ │ │ │ ├── HashedSharedSecretValidation.cs │ │ │ │ ├── MutualTlsSecretValidation.cs │ │ │ │ ├── PlainTextClientSecretValidation.cs │ │ │ │ ├── PrivateKeyJwtSecretValidation.cs │ │ │ │ └── SecretValidation.cs │ │ │ ├── Setup/ │ │ │ │ ├── ClientValidationTestClients.cs │ │ │ │ ├── Factory.cs │ │ │ │ ├── TestClients.cs │ │ │ │ ├── TestDeviceCodeValidator.cs │ │ │ │ ├── TestDeviceFlowThrottlingService.cs │ │ │ │ ├── TestGrantValidator.cs │ │ │ │ ├── TestProfileService.cs │ │ │ │ ├── TestResourceOwnerPasswordValidator.cs │ │ │ │ ├── TestScopes.cs │ │ │ │ ├── TestTokenValidator.cs │ │ │ │ ├── TokenFactory.cs │ │ │ │ └── ValidationExtensions.cs │ │ │ ├── StrictRedirectUriValidatorAppAuthValidation.cs │ │ │ ├── TokenRequest Validation/ │ │ │ │ ├── TokenRequestValidation_ClientCredentials_Invalid.cs │ │ │ │ ├── TokenRequestValidation_Code_Invalid.cs │ │ │ │ ├── TokenRequestValidation_DeviceCode_Invalid.cs │ │ │ │ ├── TokenRequestValidation_ExtensionGrants_Invalid.cs │ │ │ │ ├── TokenRequestValidation_General_Invalid.cs │ │ │ │ ├── TokenRequestValidation_PKCE.cs │ │ │ │ ├── TokenRequestValidation_RefreshToken_Invalid.cs │ │ │ │ ├── TokenRequestValidation_ResourceOwner_Invalid.cs │ │ │ │ └── TokenRequestValidation_Valid.cs │ │ │ └── UserInfoRequestValidation.cs │ │ ├── identityserver_testing.cer │ │ └── xunit.runner.json │ ├── IdentityServer8.sln │ ├── IdentityServer8.sln.licenseheader │ ├── Security/ │ │ ├── Directory.Build.props │ │ ├── IdentityServer8.Security/ │ │ │ ├── Extensions.cs │ │ │ ├── GlobalUsings.cs │ │ │ ├── IdentityServer8.Security.csproj │ │ │ ├── RedirectService.cs │ │ │ ├── RedirectUrlParser.cs │ │ │ ├── RedirectUrlServiceExtensions.cs │ │ │ ├── Sanitizer.cs │ │ │ └── SanitizerServiceExtensions.cs │ │ └── test/ │ │ └── IdentityServer8.Santizer.Tests/ │ │ ├── IdentityServer8.Sanitizer.Tests.csproj │ │ ├── RedirectServiceTests.cs │ │ └── Services/ │ │ └── SanitizerTests.cs │ └── Storage/ │ ├── Directory.Build.props │ ├── IdentityServer8.Storage.sln │ ├── README.md │ ├── build/ │ │ ├── Program.cs │ │ └── build.csproj │ ├── build.cmd │ ├── build.ps1 │ ├── build.sh │ └── src/ │ ├── Constants.cs │ ├── Extensions/ │ │ ├── IEnumerableExtensions.cs │ │ ├── PersistedGrantFilterExtensions.cs │ │ └── StringsExtensions.cs │ ├── GlobalUsings.cs │ ├── IdentityServer8.Storage.csproj │ ├── IdentityServerConstants.cs │ ├── IdentityServerUser.cs │ ├── Models/ │ │ ├── ApiResource.cs │ │ ├── ApiScope.cs │ │ ├── AuthorizationCode.cs │ │ ├── Client.cs │ │ ├── ClientClaim.cs │ │ ├── Consent.cs │ │ ├── DeviceCode.cs │ │ ├── Enums.cs │ │ ├── GrantType.cs │ │ ├── IdentityResource.cs │ │ ├── PersistedGrant.cs │ │ ├── RefreshToken.cs │ │ ├── Resource.cs │ │ ├── Resources.cs │ │ ├── Secret.cs │ │ └── Token.cs │ ├── Services/ │ │ └── ICorsPolicyService.cs │ └── Stores/ │ ├── IAuthorizationCodeStore.cs │ ├── IClientStore.cs │ ├── IDeviceFlowStore.cs │ ├── IPersistedGrantStore.cs │ ├── IReferenceTokenStore.cs │ ├── IRefreshTokenStore.cs │ ├── IResourceStore.cs │ ├── IUserConsentStore.cs │ ├── PersistedGrantFilter.cs │ └── Serialization/ │ ├── ClaimConverter.cs │ ├── ClaimLite.cs │ ├── ClaimsPrincipalConverter.cs │ ├── ClaimsPrincipalLite.cs │ ├── CustomContractResolver.cs │ ├── IPersistentGrantSerializer.cs │ └── PersistentGrantSerializer.cs └── version.json ================================================ FILE CONTENTS ================================================ ================================================ FILE: .config/dotnet-tools.json ================================================ { "version": 1, "isRoot": true, "tools": { "signclient": { "version": "1.2.17", "commands": [ "SignClient" ] }, "dotnet-ef": { "version": "3.1.0", "commands": [ "dotnet-ef" ] } } } ================================================ FILE: .editorconfig ================================================ root=true # Remove the line below if you want to inherit .editorconfig settings from higher directories # C# files [*.cs] #### Core EditorConfig Options #### # Indentation and spacing indent_size=4 indent_style=space tab_width=4 # New line preferences end_of_line=crlf insert_final_newline=false #### .NET Coding Conventions #### # this. and Me. preferences dotnet_style_qualification_for_event=false:warning dotnet_style_qualification_for_field=false:warning dotnet_style_qualification_for_method=false:warning dotnet_style_qualification_for_property=false:warning # Language keywords vs BCL types preferences dotnet_style_predefined_type_for_locals_parameters_members=true:silent dotnet_style_predefined_type_for_member_access=true:silent # Parentheses preferences dotnet_style_parentheses_in_arithmetic_binary_operators=always_for_clarity:silent dotnet_style_parentheses_in_other_binary_operators=always_for_clarity:silent dotnet_style_parentheses_in_other_operators=never_if_unnecessary:silent dotnet_style_parentheses_in_relational_binary_operators=always_for_clarity:silent # Modifier preferences dotnet_style_require_accessibility_modifiers=for_non_interface_members:silent # Expression-level preferences csharp_style_deconstructed_variable_declaration=true:suggestion csharp_style_inlined_variable_declaration=true:suggestion csharp_style_throw_expression=true:suggestion dotnet_style_coalesce_expression=true:suggestion dotnet_style_collection_initializer=true:suggestion dotnet_style_explicit_tuple_names=true:suggestion dotnet_style_null_propagation=true:suggestion dotnet_style_object_initializer=true:suggestion dotnet_style_prefer_auto_properties=true:silent dotnet_style_prefer_compound_assignment=true:suggestion dotnet_style_prefer_conditional_expression_over_assignment=true:silent dotnet_style_prefer_conditional_expression_over_return=true:silent dotnet_style_prefer_inferred_anonymous_type_member_names=true:suggestion dotnet_style_prefer_inferred_tuple_names=true:suggestion dotnet_style_prefer_is_null_check_over_reference_equality_method=true:suggestion # Field preferences dotnet_style_readonly_field=true:suggestion # Parameter preferences dotnet_code_quality_unused_parameters=all:suggestion #### C# Coding Conventions #### # var preferences csharp_style_var_elsewhere=false:silent csharp_style_var_for_built_in_types=false:silent csharp_style_var_when_type_is_apparent=false:silent # Expression-bodied members csharp_style_expression_bodied_accessors=true:silent csharp_style_expression_bodied_constructors=false:silent csharp_style_expression_bodied_indexers=true:silent csharp_style_expression_bodied_lambdas=true:silent csharp_style_expression_bodied_local_functions=false:silent csharp_style_expression_bodied_methods=false:silent csharp_style_expression_bodied_operators=false:silent csharp_style_expression_bodied_properties=true:silent # Pattern matching preferences csharp_style_pattern_matching_over_as_with_null_check=true:suggestion csharp_style_pattern_matching_over_is_with_cast_check=true:suggestion # Null-checking preferences csharp_style_conditional_delegate_call=true:suggestion # Modifier preferences csharp_preferred_modifier_order=public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async # Code-block preferences csharp_prefer_braces=true:silent # Expression-level preferences csharp_prefer_simple_default_expression=true:suggestion csharp_style_pattern_local_over_anonymous_function=true:suggestion csharp_style_prefer_index_operator=true:suggestion csharp_style_prefer_range_operator=true:suggestion csharp_style_unused_value_assignment_preference=discard_variable:suggestion csharp_style_unused_value_expression_statement_preference=discard_variable:silent #### C# Formatting Rules #### # New line preferences csharp_new_line_before_catch=true csharp_new_line_before_else=true csharp_new_line_before_finally=true csharp_new_line_before_members_in_anonymous_types=true csharp_new_line_before_members_in_object_initializers=true csharp_new_line_before_open_brace=all csharp_new_line_between_query_expression_clauses=true # Indentation preferences csharp_indent_block_contents=true csharp_indent_braces=false csharp_indent_case_contents=true csharp_indent_case_contents_when_block=true csharp_indent_labels=one_less_than_current csharp_indent_switch_labels=true # Space preferences csharp_space_after_cast=false csharp_space_after_colon_in_inheritance_clause=true csharp_space_after_comma=true csharp_space_after_dot=false csharp_space_after_keywords_in_control_flow_statements=true csharp_space_after_semicolon_in_for_statement=true csharp_space_around_binary_operators=before_and_after csharp_space_around_declaration_statements=false csharp_space_before_colon_in_inheritance_clause=true csharp_space_before_comma=false csharp_space_before_dot=false csharp_space_before_open_square_brackets=false csharp_space_before_semicolon_in_for_statement=false csharp_space_between_empty_square_brackets=false csharp_space_between_method_call_empty_parameter_list_parentheses=false csharp_space_between_method_call_name_and_opening_parenthesis=false csharp_space_between_method_call_parameter_list_parentheses=false csharp_space_between_method_declaration_empty_parameter_list_parentheses=false csharp_space_between_method_declaration_name_and_open_parenthesis=false csharp_space_between_method_declaration_parameter_list_parentheses=false csharp_space_between_parentheses=false csharp_space_between_square_brackets=false # Wrapping preferences csharp_preserve_single_line_blocks=true csharp_preserve_single_line_statements=true [*] charset=utf-8 end_of_line=lf trim_trailing_whitespace=false insert_final_newline=false indent_style=space indent_size=4 # Microsoft .NET properties csharp_indent_braces=false csharp_indent_switch_labels=true csharp_new_line_before_catch=true csharp_new_line_before_else=true csharp_new_line_before_finally=true csharp_new_line_before_members_in_object_initializers=false csharp_new_line_before_open_brace=all csharp_new_line_between_query_expression_clauses=true csharp_preferred_modifier_order=public, private, protected, internal, new, abstract, virtual, sealed, override, static, readonly, extern, unsafe, volatile, async:suggestion csharp_preserve_single_line_blocks=true csharp_space_after_cast=true csharp_space_after_colon_in_inheritance_clause=true csharp_space_after_comma=true csharp_space_after_dot=false csharp_space_after_keywords_in_control_flow_statements=true csharp_space_after_semicolon_in_for_statement=true csharp_space_around_binary_operators=before_and_after csharp_space_before_colon_in_inheritance_clause=true csharp_space_before_comma=false csharp_space_before_dot=false csharp_space_before_open_square_brackets=false csharp_space_before_semicolon_in_for_statement=false csharp_space_between_empty_square_brackets=false csharp_space_between_method_call_empty_parameter_list_parentheses=false csharp_space_between_method_call_name_and_opening_parenthesis=false csharp_space_between_method_call_parameter_list_parentheses=false csharp_space_between_method_declaration_empty_parameter_list_parentheses=false csharp_space_between_method_declaration_name_and_open_parenthesis=false csharp_space_between_method_declaration_parameter_list_parentheses=false csharp_space_between_parentheses=false csharp_space_between_square_brackets=false csharp_style_var_elsewhere=true:suggestion csharp_style_var_for_built_in_types=true:suggestion csharp_style_var_when_type_is_apparent=true:suggestion csharp_using_directive_placement=outside_namespace:silent dotnet_naming_rule.constants_rule.severity=warning dotnet_naming_rule.constants_rule.style=upper_camel_case_style dotnet_naming_rule.constants_rule.symbols=constants_symbols dotnet_naming_rule.event_rule.severity=warning dotnet_naming_rule.event_rule.style=upper_camel_case_style dotnet_naming_rule.event_rule.symbols=event_symbols dotnet_naming_rule.interfaces_rule.severity=warning dotnet_naming_rule.interfaces_rule.style=i_upper_camel_case_style dotnet_naming_rule.interfaces_rule.symbols=interfaces_symbols dotnet_naming_rule.locals_rule.severity=warning dotnet_naming_rule.locals_rule.style=lower_camel_case_style_1 dotnet_naming_rule.locals_rule.symbols=locals_symbols dotnet_naming_rule.local_constants_rule.severity=warning dotnet_naming_rule.local_constants_rule.style=lower_camel_case_style_1 dotnet_naming_rule.local_constants_rule.symbols=local_constants_symbols dotnet_naming_rule.local_functions_rule.severity=warning dotnet_naming_rule.local_functions_rule.style=upper_camel_case_style dotnet_naming_rule.local_functions_rule.symbols=local_functions_symbols dotnet_naming_rule.method_rule.severity=warning dotnet_naming_rule.method_rule.style=upper_camel_case_style dotnet_naming_rule.method_rule.symbols=method_symbols dotnet_naming_rule.parameters_rule.severity=warning dotnet_naming_rule.parameters_rule.style=lower_camel_case_style_1 dotnet_naming_rule.parameters_rule.symbols=parameters_symbols dotnet_naming_rule.private_constants_rule.severity=warning dotnet_naming_rule.private_constants_rule.style=upper_camel_case_style dotnet_naming_rule.private_constants_rule.symbols=private_constants_symbols dotnet_naming_rule.private_instance_fields_rule.severity=warning dotnet_naming_rule.private_instance_fields_rule.style=lower_camel_case_style dotnet_naming_rule.private_instance_fields_rule.symbols=private_instance_fields_symbols dotnet_naming_rule.private_static_fields_rule.severity=warning dotnet_naming_rule.private_static_fields_rule.style=lower_camel_case_style dotnet_naming_rule.private_static_fields_rule.symbols=private_static_fields_symbols dotnet_naming_rule.private_static_readonly_rule.severity=warning dotnet_naming_rule.private_static_readonly_rule.style=upper_camel_case_style dotnet_naming_rule.private_static_readonly_rule.symbols=private_static_readonly_symbols dotnet_naming_rule.property_rule.severity=warning dotnet_naming_rule.property_rule.style=upper_camel_case_style dotnet_naming_rule.property_rule.symbols=property_symbols dotnet_naming_rule.public_fields_rule.severity=warning dotnet_naming_rule.public_fields_rule.style=upper_camel_case_style dotnet_naming_rule.public_fields_rule.symbols=public_fields_symbols dotnet_naming_rule.static_readonly_rule.severity=warning dotnet_naming_rule.static_readonly_rule.style=upper_camel_case_style dotnet_naming_rule.static_readonly_rule.symbols=static_readonly_symbols dotnet_naming_rule.types_and_namespaces_rule.severity=warning dotnet_naming_rule.types_and_namespaces_rule.style=upper_camel_case_style dotnet_naming_rule.types_and_namespaces_rule.symbols=types_and_namespaces_symbols dotnet_naming_rule.type_parameters_rule.severity=warning dotnet_naming_rule.type_parameters_rule.style=t_upper_camel_case_style dotnet_naming_rule.type_parameters_rule.symbols=type_parameters_symbols dotnet_naming_style.i_upper_camel_case_style.capitalization=pascal_case dotnet_naming_style.i_upper_camel_case_style.required_prefix=I dotnet_naming_style.lower_camel_case_style.capitalization=camel_case dotnet_naming_style.lower_camel_case_style.required_prefix=_ dotnet_naming_style.lower_camel_case_style_1.capitalization=camel_case dotnet_naming_style.t_upper_camel_case_style.capitalization=pascal_case dotnet_naming_style.t_upper_camel_case_style.required_prefix=T dotnet_naming_style.upper_camel_case_style.capitalization=pascal_case dotnet_naming_symbols.constants_symbols.applicable_accessibilities=public,internal,protected,protected_internal,private_protected dotnet_naming_symbols.constants_symbols.applicable_kinds=field dotnet_naming_symbols.constants_symbols.required_modifiers=const dotnet_naming_symbols.event_symbols.applicable_accessibilities=* dotnet_naming_symbols.event_symbols.applicable_kinds=event dotnet_naming_symbols.interfaces_symbols.applicable_accessibilities=* dotnet_naming_symbols.interfaces_symbols.applicable_kinds=interface dotnet_naming_symbols.locals_symbols.applicable_accessibilities=* dotnet_naming_symbols.locals_symbols.applicable_kinds=local dotnet_naming_symbols.local_constants_symbols.applicable_accessibilities=* dotnet_naming_symbols.local_constants_symbols.applicable_kinds=local dotnet_naming_symbols.local_constants_symbols.required_modifiers=const dotnet_naming_symbols.local_functions_symbols.applicable_accessibilities=* dotnet_naming_symbols.local_functions_symbols.applicable_kinds=local_function dotnet_naming_symbols.method_symbols.applicable_accessibilities=* dotnet_naming_symbols.method_symbols.applicable_kinds=method dotnet_naming_symbols.parameters_symbols.applicable_accessibilities=* dotnet_naming_symbols.parameters_symbols.applicable_kinds=parameter dotnet_naming_symbols.private_constants_symbols.applicable_accessibilities=private dotnet_naming_symbols.private_constants_symbols.applicable_kinds=field dotnet_naming_symbols.private_constants_symbols.required_modifiers=const dotnet_naming_symbols.private_instance_fields_symbols.applicable_accessibilities=private dotnet_naming_symbols.private_instance_fields_symbols.applicable_kinds=field dotnet_naming_symbols.private_static_fields_symbols.applicable_accessibilities=private dotnet_naming_symbols.private_static_fields_symbols.applicable_kinds=field dotnet_naming_symbols.private_static_fields_symbols.required_modifiers=static dotnet_naming_symbols.private_static_readonly_symbols.applicable_accessibilities=private dotnet_naming_symbols.private_static_readonly_symbols.applicable_kinds=field dotnet_naming_symbols.private_static_readonly_symbols.required_modifiers=static,readonly dotnet_naming_symbols.property_symbols.applicable_accessibilities=* dotnet_naming_symbols.property_symbols.applicable_kinds=property dotnet_naming_symbols.public_fields_symbols.applicable_accessibilities=public,internal,protected,protected_internal,private_protected dotnet_naming_symbols.public_fields_symbols.applicable_kinds=field dotnet_naming_symbols.static_readonly_symbols.applicable_accessibilities=public,internal,protected,protected_internal,private_protected dotnet_naming_symbols.static_readonly_symbols.applicable_kinds=field dotnet_naming_symbols.static_readonly_symbols.required_modifiers=static,readonly dotnet_naming_symbols.types_and_namespaces_symbols.applicable_accessibilities=* dotnet_naming_symbols.types_and_namespaces_symbols.applicable_kinds=namespace,class,struct,enum,delegate dotnet_naming_symbols.type_parameters_symbols.applicable_accessibilities=* dotnet_naming_symbols.type_parameters_symbols.applicable_kinds=type_parameter dotnet_style_parentheses_in_arithmetic_binary_operators=never_if_unnecessary:none dotnet_style_parentheses_in_other_binary_operators=never_if_unnecessary:none dotnet_style_parentheses_in_relational_binary_operators=never_if_unnecessary:none dotnet_style_predefined_type_for_locals_parameters_members=true:suggestion dotnet_style_predefined_type_for_member_access=true:suggestion dotnet_style_qualification_for_event=false:suggestion dotnet_style_qualification_for_field=false:suggestion dotnet_style_qualification_for_method=false:suggestion dotnet_style_qualification_for_property=false:suggestion dotnet_style_require_accessibility_modifiers=for_non_interface_members:suggestion # ReSharper properties resharper_accessor_owner_body=expression_body resharper_alignment_tab_fill_style=use_spaces resharper_align_first_arg_by_paren=false resharper_align_linq_query=false resharper_align_multiline_array_and_object_initializer=false resharper_align_multiline_array_initializer=true resharper_align_multiline_binary_expressions_chain=true resharper_align_multiline_calls_chain=false resharper_align_multiline_extends_list=false resharper_align_multiline_for_stmt=false resharper_align_multiline_implements_list=true resharper_align_multiline_switch_expression=false resharper_align_multline_type_parameter_constrains=false resharper_align_multline_type_parameter_list=false resharper_align_tuple_components=false resharper_allow_alias=true resharper_allow_comment_after_lbrace=false resharper_always_use_end_of_line_brace_style=false resharper_apply_auto_detected_rules=true resharper_apply_on_completion=false resharper_arguments_anonymous_function=positional resharper_arguments_literal=positional resharper_arguments_named=positional resharper_arguments_other=positional resharper_arguments_skip_single=false resharper_arguments_string_literal=positional resharper_attribute_style=do_not_touch resharper_autodetect_indent_settings=true resharper_blank_lines_after_block_statements=1 resharper_blank_lines_after_case=0 resharper_blank_lines_after_control_transfer_statements=0 resharper_blank_lines_after_imports=1 resharper_blank_lines_after_multiline_statements=0 resharper_blank_lines_after_options=1 resharper_blank_lines_after_start_comment=1 resharper_blank_lines_after_using_list=1 resharper_blank_lines_around_auto_property=1 resharper_blank_lines_around_block_case_section=0 resharper_blank_lines_around_field=1 resharper_blank_lines_around_global_attribute=0 resharper_blank_lines_around_invocable=1 resharper_blank_lines_around_local_method=1 resharper_blank_lines_around_multiline_case_section=0 resharper_blank_lines_around_namespace=1 resharper_blank_lines_around_property=1 resharper_blank_lines_around_razor_functions=1 resharper_blank_lines_around_razor_helpers=1 resharper_blank_lines_around_razor_sections=1 resharper_blank_lines_around_region=1 resharper_blank_lines_around_single_line_auto_property=0 resharper_blank_lines_around_single_line_field=0 resharper_blank_lines_around_single_line_invocable=0 resharper_blank_lines_around_single_line_local_method=0 resharper_blank_lines_around_single_line_property=0 resharper_blank_lines_around_type=1 resharper_blank_lines_before_block_statements=0 resharper_blank_lines_before_case=0 resharper_blank_lines_before_control_transfer_statements=0 resharper_blank_lines_before_multiline_statements=0 resharper_blank_lines_before_single_line_comment=0 resharper_blank_lines_between_using_groups=0 resharper_blank_lines_inside_namespace=0 resharper_blank_lines_inside_region=1 resharper_blank_lines_inside_type=0 resharper_blank_line_after_pi=true resharper_braces_for_dowhile=required resharper_braces_for_fixed=required resharper_braces_for_for=not_required resharper_braces_for_foreach=not_required resharper_braces_for_ifelse=not_required_for_both resharper_braces_for_lock=required resharper_braces_for_using=required resharper_braces_for_while=not_required resharper_braces_redundant=true resharper_can_use_global_alias=true resharper_constructor_or_destructor_body=block_body resharper_continuous_indent_multiplier=1 resharper_csharp_align_multiline_argument=false resharper_csharp_align_multiline_expression=false resharper_csharp_align_multiline_parameter=false resharper_csharp_align_multiple_declaration=false resharper_csharp_max_line_length=120 resharper_csharp_naming_rule.enum_member=AaBb resharper_csharp_naming_rule.method_property_event=AaBb resharper_csharp_naming_rule.other=AaBb resharper_csharp_prefer_qualified_reference=false resharper_csharp_wrap_lines=true resharper_default_exception_variable_name=e resharper_delete_quotes_from_solid_values=false resharper_disable_blank_line_changes=false resharper_disable_formatter=false resharper_disable_indenter=false resharper_disable_int_align=false resharper_disable_line_break_changes=false resharper_disable_line_break_removal=false resharper_disable_space_changes=false resharper_empty_block_style=multiline resharper_enable_wrapping=false resharper_enforce_line_ending_style=false resharper_event_handler_pattern_long=$object$On$event$ resharper_event_handler_pattern_short=On$event$ resharper_extra_spaces=remove_all resharper_force_attribute_style=separate resharper_force_chop_compound_do_expression=false resharper_force_chop_compound_if_expression=false resharper_force_chop_compound_while_expression=false resharper_format_leading_spaces_decl=false resharper_html_attribute_indent=align_by_first_attribute resharper_html_linebreak_before_elements=body,div,p,form,h1,h2,h3 resharper_html_max_blank_lines_between_tags=2 resharper_html_max_line_length=120 resharper_html_pi_attribute_style=on_single_line resharper_html_space_before_self_closing=false resharper_html_wrap_lines=true resharper_ignore_space_preservation=false resharper_include_prefix_comment_in_indent=false resharper_indent_anonymous_method_block=false resharper_indent_case_from_select=true resharper_indent_child_elements=OneIndent resharper_indent_inside_namespace=true resharper_indent_invocation_pars=inside resharper_indent_method_decl_pars=inside resharper_indent_nested_fixed_stmt=false resharper_indent_nested_foreach_stmt=false resharper_indent_nested_for_stmt=false resharper_indent_nested_lock_stmt=false resharper_indent_nested_usings_stmt=false resharper_indent_nested_while_stmt=false resharper_indent_pars=inside resharper_indent_preprocessor_if=no_indent resharper_indent_preprocessor_other=no_indent resharper_indent_preprocessor_region=usual_indent resharper_indent_statement_pars=inside resharper_indent_text=OneIndent resharper_indent_typearg_angles=inside resharper_indent_typeparam_angles=inside resharper_indent_type_constraints=true resharper_instance_members_qualify_declared_in=this_class, base_class resharper_int_align=false resharper_keep_blank_lines_in_code=2 resharper_keep_blank_lines_in_declarations=2 resharper_keep_existing_attribute_arrangement=false resharper_keep_existing_declaration_block_arrangement=false resharper_keep_existing_declaration_parens_arrangement=true resharper_keep_existing_embedded_arrangement=true resharper_keep_existing_embedded_block_arrangement=false resharper_keep_existing_enum_arrangement=false resharper_keep_existing_expr_member_arrangement=true resharper_keep_existing_invocation_parens_arrangement=true resharper_keep_existing_switch_expression_arrangement=true resharper_keep_nontrivial_alias=true resharper_keep_user_linebreaks=true resharper_keep_user_wrapping=true resharper_linebreaks_around_razor_statements=true resharper_linebreaks_inside_tags_for_elements_longer_than=2147483647 resharper_linebreaks_inside_tags_for_elements_with_child_elements=true resharper_linebreaks_inside_tags_for_multiline_elements=true resharper_linebreak_before_all_elements=false resharper_linebreak_before_multiline_elements=true resharper_linebreak_before_singleline_elements=false resharper_local_function_body=block_body resharper_max_array_initializer_elements_on_line=10000 resharper_max_attribute_length_for_same_line=38 resharper_max_enum_members_on_line=3 resharper_max_formal_parameters_on_line=10000 resharper_max_initializer_elements_on_line=4 resharper_max_invocation_arguments_on_line=10000 resharper_method_or_operator_body=block_body resharper_nested_ternary_style=autodetect resharper_new_line_before_while=false resharper_normalize_tag_names=false resharper_no_indent_inside_elements=html,body,thead,tbody,tfoot resharper_no_indent_inside_if_element_longer_than=200 resharper_old_engine=false resharper_outdent_binary_ops=false resharper_outdent_commas=false resharper_outdent_dots=false resharper_outdent_ternary_ops=false resharper_parentheses_non_obvious_operations=none, shift, bitwise_and, bitwise_exclusive_or, bitwise_inclusive_or, bitwise resharper_parentheses_redundancy_style=remove_if_not_clarifies_precedence resharper_pi_attributes_indent=align_by_first_attribute resharper_place_accessorholder_attribute_on_same_line=if_owner_is_single_line resharper_place_accessor_attribute_on_same_line=if_owner_is_single_line resharper_place_comments_at_first_column=false resharper_place_constructor_initializer_on_same_line=true resharper_place_event_attribute_on_same_line=false resharper_place_expr_accessor_on_single_line=if_owner_is_single_line resharper_place_expr_method_on_single_line=if_owner_is_single_line resharper_place_expr_property_on_single_line=if_owner_is_single_line resharper_place_field_attribute_on_same_line=true resharper_place_linq_into_on_new_line=true resharper_place_method_attribute_on_same_line=false resharper_place_property_attribute_on_same_line=false resharper_place_simple_case_statement_on_same_line=false resharper_place_simple_embedded_statement_on_same_line=if_owner_is_single_line resharper_place_simple_initializer_on_single_line=true resharper_place_simple_switch_expression_on_single_line=false resharper_place_type_attribute_on_same_line=false resharper_place_type_constraints_on_same_line=true resharper_prefer_explicit_discard_declaration=false resharper_prefer_separate_deconstructed_variables_declaration=false resharper_preserve_spaces_inside_tags=pre,textarea resharper_qualified_using_at_nested_scope=false resharper_quote_style=doublequoted resharper_razor_prefer_qualified_reference=true resharper_remove_blank_lines_near_braces=false resharper_remove_blank_lines_near_braces_in_code=true resharper_remove_blank_lines_near_braces_in_declarations=true resharper_remove_this_qualifier=true resharper_resx_attribute_indent=single_indent resharper_resx_linebreak_before_elements= resharper_resx_max_blank_lines_between_tags=0 resharper_resx_max_line_length=2147483647 resharper_resx_pi_attribute_style=do_not_touch resharper_resx_space_before_self_closing=false resharper_resx_wrap_lines=false resharper_resx_wrap_tags_and_pi=false resharper_resx_wrap_text=false resharper_show_autodetect_configure_formatting_tip=true resharper_sort_attributes=false resharper_sort_class_selectors=false resharper_sort_usings=true resharper_sort_usings_lowercase_first=false resharper_sort_usings_with_system_first=true resharper_spaces_around_eq_in_attribute=false resharper_spaces_around_eq_in_pi_attribute=false resharper_spaces_inside_tags=false resharper_space_after_attributes=true resharper_space_after_attribute_target_colon=true resharper_space_after_colon=true resharper_space_after_colon_in_case=true resharper_space_after_comma=true resharper_space_after_last_attribute=false resharper_space_after_last_pi_attribute=false resharper_space_after_operator_keyword=true resharper_space_after_triple_slash=true resharper_space_after_type_parameter_constraint_colon=true resharper_space_after_unary_operator=false resharper_space_around_additive_op=true resharper_space_around_alias_eq=true resharper_space_around_assignment_op=true resharper_space_around_lambda_arrow=true resharper_space_around_member_access_operator=false resharper_space_around_relational_op=true resharper_space_around_shift_op=true resharper_space_around_stmt_colon=true resharper_space_around_ternary_operator=true resharper_space_before_array_rank_parentheses=false resharper_space_before_attribute_target_colon=false resharper_space_before_checked_parentheses=false resharper_space_before_colon=false resharper_space_before_colon_in_case=false resharper_space_before_comma=false resharper_space_before_default_parentheses=false resharper_space_before_empty_invocation_parentheses=false resharper_space_before_empty_method_parentheses=false resharper_space_before_invocation_parentheses=false resharper_space_before_label_colon=false resharper_space_before_method_parentheses=false resharper_space_before_nameof_parentheses=false resharper_space_before_nullable_mark=false resharper_space_before_pointer_asterik_declaration=false resharper_space_before_semicolon=false resharper_space_before_singleline_accessorholder=true resharper_space_before_sizeof_parentheses=false resharper_space_before_trailing_comment=true resharper_space_before_typeof_parentheses=false resharper_space_before_type_argument_angle=false resharper_space_before_type_parameter_angle=false resharper_space_before_type_parameter_constraint_colon=true resharper_space_before_type_parameter_parentheses=true resharper_space_between_accessors_in_singleline_property=true resharper_space_between_attribute_sections=true resharper_space_between_keyword_and_expression=true resharper_space_between_keyword_and_type=true resharper_space_in_singleline_accessorholder=true resharper_space_in_singleline_anonymous_method=true resharper_space_in_singleline_method=true resharper_space_near_postfix_and_prefix_op=false resharper_space_within_array_initialization_braces=false resharper_space_within_array_rank_empty_parentheses=false resharper_space_within_array_rank_parentheses=false resharper_space_within_attribute_angles=false resharper_space_within_checked_parentheses=false resharper_space_within_default_parentheses=false resharper_space_within_empty_braces=true resharper_space_within_empty_invocation_parentheses=false resharper_space_within_empty_method_parentheses=false resharper_space_within_expression_parentheses=false resharper_space_within_invocation_parentheses=false resharper_space_within_method_parentheses=false resharper_space_within_nameof_parentheses=false resharper_space_within_single_line_array_initializer_braces=true resharper_space_within_sizeof_parentheses=false resharper_space_within_tuple_parentheses=false resharper_space_within_typeof_parentheses=false resharper_space_within_type_argument_angles=false resharper_space_within_type_parameter_angles=false resharper_space_within_type_parameter_parentheses=false resharper_special_else_if_treatment=true resharper_static_members_qualify_members=none resharper_static_members_qualify_with=do_not_change, declared_type resharper_stick_comment=true resharper_support_vs_event_naming_pattern=true resharper_trailing_comma_in_multiline_lists=false resharper_trailing_comma_in_singleline_lists=false resharper_use_continuous_indent_inside_initializer_braces=true resharper_use_continuous_indent_inside_parens=true resharper_use_heuristics_for_body_style=true resharper_use_indents_from_main_language_in_file=true resharper_use_indent_from_previous_element=true resharper_use_indent_from_vs=false resharper_use_roslyn_logic_for_evident_types=false resharper_vb_align_multiline_argument=true resharper_vb_align_multiline_expression=true resharper_vb_align_multiline_parameter=true resharper_vb_align_multiple_declaration=true resharper_vb_max_line_length=120 resharper_vb_place_field_attribute_on_same_line=true resharper_vb_place_method_attribute_on_same_line=false resharper_vb_place_type_attribute_on_same_line=false resharper_vb_prefer_qualified_reference=false resharper_vb_space_around_multiplicative_op=false resharper_vb_wrap_lines=true resharper_wrap_after_declaration_lpar=false resharper_wrap_after_dot_in_method_calls=false resharper_wrap_after_invocation_lpar=false resharper_wrap_arguments_style=wrap_if_long resharper_wrap_around_elements=true resharper_wrap_array_initializer_style=wrap_if_long resharper_wrap_before_arrow_with_expressions=false resharper_wrap_before_binary_opsign=false resharper_wrap_before_comma=false resharper_wrap_before_declaration_lpar=false resharper_wrap_before_declaration_rpar=false resharper_wrap_before_extends_colon=false resharper_wrap_before_first_type_parameter_constraint=false resharper_wrap_before_invocation_lpar=false resharper_wrap_before_invocation_rpar=false resharper_wrap_before_linq_expression=false resharper_wrap_before_ternary_opsigns=true resharper_wrap_before_type_parameter_langle=false resharper_wrap_chained_binary_expressions=wrap_if_long resharper_wrap_chained_method_calls=wrap_if_long resharper_wrap_enum_declaration=chop_always resharper_wrap_extends_list_style=wrap_if_long resharper_wrap_for_stmt_header_style=chop_if_long resharper_wrap_multiple_declaration_style=chop_if_long resharper_wrap_multiple_type_parameter_constraints_style=chop_if_long resharper_wrap_object_and_collection_initializer_style=chop_if_long resharper_wrap_parameters_style=wrap_if_long resharper_wrap_switch_expression=chop_always resharper_wrap_ternary_expr_style=chop_if_long resharper_wrap_verbatim_interpolated_strings=no_wrap resharper_xmldoc_attribute_indent=single_indent resharper_xmldoc_linebreak_before_elements=summary,remarks,example,returns,param,typeparam,value,para resharper_xmldoc_max_blank_lines_between_tags=0 resharper_xmldoc_max_line_length=120 resharper_xmldoc_pi_attribute_style=do_not_touch resharper_xmldoc_space_before_self_closing=true resharper_xmldoc_wrap_lines=true resharper_xmldoc_wrap_tags_and_pi=true resharper_xmldoc_wrap_text=true resharper_xml_attribute_indent=align_by_first_attribute resharper_xml_linebreak_before_elements= resharper_xml_max_blank_lines_between_tags=2 resharper_xml_max_line_length=120 resharper_xml_pi_attribute_style=do_not_touch resharper_xml_space_before_self_closing=true resharper_xml_wrap_lines=true resharper_xml_wrap_tags_and_pi=true resharper_xml_wrap_text=false # ReSharper inspection severities resharper_abstract_class_constructor_can_be_made_protected_highlighting=hint resharper_access_rights_in_text_highlighting=warning resharper_access_to_disposed_closure_highlighting=warning resharper_access_to_for_each_variable_in_closure_highlighting=warning resharper_access_to_modified_closure_highlighting=warning resharper_access_to_static_member_via_derived_type_highlighting=warning resharper_address_of_marshal_by_ref_object_highlighting=warning resharper_amd_dependency_path_problem_highlighting=none resharper_angular_html_banana_highlighting=warning resharper_annotate_can_be_null_parameter_highlighting=none resharper_annotate_can_be_null_type_member_highlighting=none resharper_annotate_not_null_parameter_highlighting=none resharper_annotate_not_null_type_member_highlighting=none resharper_annotation_conflict_in_hierarchy_highlighting=warning resharper_annotation_redundancy_at_value_type_highlighting=warning resharper_annotation_redundancy_in_hierarchy_highlighting=warning resharper_arguments_style_anonymous_function_highlighting=hint resharper_arguments_style_literal_highlighting=hint resharper_arguments_style_named_expression_highlighting=hint resharper_arguments_style_other_highlighting=hint resharper_arguments_style_string_literal_highlighting=hint resharper_arrange_accessor_owner_body_highlighting=suggestion resharper_arrange_attributes_highlighting=none resharper_arrange_constructor_or_destructor_body_highlighting=none resharper_arrange_local_function_body_highlighting=none resharper_arrange_method_or_operator_body_highlighting=none resharper_arrange_redundant_parentheses_highlighting=hint resharper_arrange_static_member_qualifier_highlighting=hint resharper_arrange_this_qualifier_highlighting=hint resharper_arrange_trailing_comma_in_multiline_lists_highlighting=hint resharper_arrange_trailing_comma_in_singleline_lists_highlighting=hint resharper_arrange_type_member_modifiers_highlighting=hint resharper_arrange_type_modifiers_highlighting=hint resharper_arrange_var_keywords_in_deconstructing_declaration_highlighting=suggestion resharper_asp0000_highlighting=warning resharper_asp0001_highlighting=warning resharper_asp_content_placeholder_not_resolved_highlighting=error resharper_asp_custom_page_parser_filter_type_highlighting=warning resharper_asp_dead_code_highlighting=warning resharper_asp_entity_highlighting=warning resharper_asp_image_highlighting=warning resharper_asp_invalid_control_type_highlighting=error resharper_asp_not_resolved_highlighting=error resharper_asp_ods_method_reference_resolve_error_highlighting=error resharper_asp_resolve_warning_highlighting=warning resharper_asp_skin_not_resolved_highlighting=error resharper_asp_tag_attribute_with_optional_value_highlighting=warning resharper_asp_theme_not_resolved_highlighting=error resharper_asp_unused_register_directive_highlighting_highlighting=warning resharper_asp_warning_highlighting=warning resharper_assigned_value_is_never_used_highlighting=warning resharper_assigned_value_wont_be_assigned_to_corresponding_field_highlighting=warning resharper_assignment_in_conditional_expression_highlighting=warning resharper_assignment_in_condition_expression_highlighting=warning resharper_assignment_is_fully_discarded_highlighting=warning resharper_assign_null_to_not_null_attribute_highlighting=warning resharper_assign_to_constant_highlighting=error resharper_assign_to_implicit_global_in_function_scope_highlighting=warning resharper_asxx_path_error_highlighting=warning resharper_async_iterator_invocation_without_await_foreach_highlighting=warning resharper_auto_property_can_be_made_get_only_global_highlighting=suggestion resharper_auto_property_can_be_made_get_only_local_highlighting=suggestion resharper_bad_attribute_brackets_spaces_highlighting=none resharper_bad_braces_spaces_highlighting=none resharper_bad_child_statement_indent_highlighting=warning resharper_bad_colon_spaces_highlighting=none resharper_bad_comma_spaces_highlighting=none resharper_bad_control_braces_indent_highlighting=suggestion resharper_bad_control_braces_line_breaks_highlighting=none resharper_bad_declaration_braces_indent_highlighting=none resharper_bad_declaration_braces_line_breaks_highlighting=none resharper_bad_empty_braces_line_breaks_highlighting=none resharper_bad_expression_braces_indent_highlighting=none resharper_bad_expression_braces_line_breaks_highlighting=none resharper_bad_generic_brackets_spaces_highlighting=none resharper_bad_indent_highlighting=none resharper_bad_linq_line_breaks_highlighting=none resharper_bad_list_line_breaks_highlighting=none resharper_bad_member_access_spaces_highlighting=none resharper_bad_namespace_braces_indent_highlighting=none resharper_bad_parens_line_breaks_highlighting=none resharper_bad_parens_spaces_highlighting=none resharper_bad_preprocessor_indent_highlighting=none resharper_bad_semicolon_spaces_highlighting=none resharper_bad_spaces_after_keyword_highlighting=none resharper_bad_square_brackets_spaces_highlighting=none resharper_bad_switch_braces_indent_highlighting=none resharper_bad_symbol_spaces_highlighting=none resharper_base_member_has_params_highlighting=warning resharper_base_method_call_with_default_parameter_highlighting=warning resharper_base_object_equals_is_object_equals_highlighting=warning resharper_base_object_get_hash_code_call_in_get_hash_code_highlighting=warning resharper_bitwise_operator_on_enum_without_flags_highlighting=warning resharper_bl0001_highlighting=error resharper_bl0002_highlighting=warning resharper_bl0003_highlighting=warning resharper_bl0004_highlighting=error resharper_bl0005_highlighting=warning resharper_bl0006_highlighting=warning resharper_block_scope_redeclaration_highlighting=error resharper_built_in_type_reference_style_for_member_access_highlighting=hint resharper_built_in_type_reference_style_highlighting=hint resharper_by_ref_argument_is_volatile_field_highlighting=warning resharper_caller_callee_using_error_highlighting=error resharper_caller_callee_using_highlighting=warning resharper_cannot_apply_equality_operator_to_type_highlighting=warning resharper_center_tag_is_obsolete_highlighting=warning resharper_check_for_reference_equality_instead_1_highlighting=suggestion resharper_check_for_reference_equality_instead_2_highlighting=suggestion resharper_check_for_reference_equality_instead_3_highlighting=suggestion resharper_check_for_reference_equality_instead_4_highlighting=suggestion resharper_check_namespace_highlighting=warning resharper_class_cannot_be_instantiated_highlighting=warning resharper_class_can_be_sealed_global_highlighting=none resharper_class_can_be_sealed_local_highlighting=none resharper_class_never_instantiated_global_highlighting=suggestion resharper_class_never_instantiated_local_highlighting=suggestion resharper_class_with_virtual_members_never_inherited_global_highlighting=suggestion resharper_class_with_virtual_members_never_inherited_local_highlighting=suggestion resharper_clear_attribute_is_obsolete_all_highlighting=warning resharper_clear_attribute_is_obsolete_highlighting=warning resharper_closure_on_modified_variable_highlighting=warning resharper_coerced_equals_using_highlighting=warning resharper_coerced_equals_using_with_null_undefined_highlighting=none resharper_collection_never_queried_global_highlighting=warning resharper_collection_never_queried_local_highlighting=warning resharper_collection_never_updated_global_highlighting=warning resharper_collection_never_updated_local_highlighting=warning resharper_comma_not_valid_here_highlighting=error resharper_comment_typo_highlighting=suggestion resharper_compare_non_constrained_generic_with_null_highlighting=none resharper_compare_of_floats_by_equality_operator_highlighting=warning resharper_conditional_ternary_equal_branch_highlighting=warning resharper_condition_is_always_const_highlighting=warning resharper_condition_is_always_true_or_false_highlighting=warning resharper_confusing_char_as_integer_in_constructor_highlighting=warning resharper_constant_conditional_access_qualifier_highlighting=warning resharper_constant_null_coalescing_condition_highlighting=warning resharper_constructor_call_not_used_highlighting=warning resharper_constructor_initializer_loop_highlighting=warning resharper_container_annotation_redundancy_highlighting=warning resharper_context_value_is_provided_highlighting=none resharper_contract_annotation_not_parsed_highlighting=warning resharper_convert_closure_to_method_group_highlighting=suggestion resharper_convert_conditional_ternary_expression_to_switch_expression_highlighting=hint resharper_convert_if_do_to_while_highlighting=suggestion resharper_convert_if_statement_to_conditional_ternary_expression_highlighting=suggestion resharper_convert_if_statement_to_null_coalescing_assignment_highlighting=suggestion resharper_convert_if_statement_to_null_coalescing_expression_highlighting=suggestion resharper_convert_if_statement_to_return_statement_highlighting=hint resharper_convert_if_statement_to_switch_expression_highlighting=hint resharper_convert_if_statement_to_switch_statement_highlighting=hint resharper_convert_if_to_or_expression_highlighting=suggestion resharper_convert_nullable_to_short_form_highlighting=suggestion resharper_convert_switch_statement_to_switch_expression_highlighting=hint resharper_convert_to_auto_property_highlighting=suggestion resharper_convert_to_auto_property_when_possible_highlighting=hint resharper_convert_to_auto_property_with_private_setter_highlighting=hint resharper_convert_to_compound_assignment_highlighting=hint resharper_convert_to_constant_global_highlighting=hint resharper_convert_to_constant_local_highlighting=hint resharper_convert_to_lambda_expression_highlighting=suggestion resharper_convert_to_lambda_expression_when_possible_highlighting=none resharper_convert_to_local_function_highlighting=suggestion resharper_convert_to_null_coalescing_compound_assignment_highlighting=suggestion resharper_convert_to_static_class_highlighting=suggestion resharper_convert_to_using_declaration_highlighting=suggestion resharper_convert_to_vb_auto_property_highlighting=suggestion resharper_convert_to_vb_auto_property_when_possible_highlighting=hint resharper_convert_to_vb_auto_property_with_private_setter_highlighting=hint resharper_co_variant_array_conversion_highlighting=warning resharper_create_specialized_overload_highlighting=hint resharper_css_browser_compatibility_highlighting=warning resharper_css_caniuse_feature_requires_prefix_highlighting=hint resharper_css_caniuse_unsupported_feature_highlighting=hint resharper_css_not_resolved_highlighting=error resharper_css_obsolete_highlighting=hint resharper_css_property_does_not_override_vendor_property_highlighting=warning resharper_cyclic_reference_comment_highlighting=none resharper_c_sharp_warnings_cs0078_highlighting=warning resharper_c_sharp_warnings_cs0108_cs0114_highlighting=warning resharper_c_sharp_warnings_cs0109_highlighting=warning resharper_c_sharp_warnings_cs0162_highlighting=warning resharper_c_sharp_warnings_cs0183_highlighting=warning resharper_c_sharp_warnings_cs0184_highlighting=warning resharper_c_sharp_warnings_cs0197_highlighting=warning resharper_c_sharp_warnings_cs0252_cs0253_highlighting=warning resharper_c_sharp_warnings_cs0420_highlighting=warning resharper_c_sharp_warnings_cs0465_highlighting=warning resharper_c_sharp_warnings_cs0469_highlighting=warning resharper_c_sharp_warnings_cs0612_highlighting=warning resharper_c_sharp_warnings_cs0618_highlighting=warning resharper_c_sharp_warnings_cs0628_highlighting=warning resharper_c_sharp_warnings_cs0642_highlighting=warning resharper_c_sharp_warnings_cs0657_highlighting=warning resharper_c_sharp_warnings_cs0658_highlighting=warning resharper_c_sharp_warnings_cs0659_highlighting=warning resharper_c_sharp_warnings_cs0660_cs0661_highlighting=warning resharper_c_sharp_warnings_cs0665_highlighting=warning resharper_c_sharp_warnings_cs0672_highlighting=warning resharper_c_sharp_warnings_cs0693_highlighting=warning resharper_c_sharp_warnings_cs1030_highlighting=warning resharper_c_sharp_warnings_cs1058_highlighting=warning resharper_c_sharp_warnings_cs1066_highlighting=warning resharper_c_sharp_warnings_cs1522_highlighting=warning resharper_c_sharp_warnings_cs1570_highlighting=warning resharper_c_sharp_warnings_cs1571_highlighting=warning resharper_c_sharp_warnings_cs1572_highlighting=warning resharper_c_sharp_warnings_cs1573_highlighting=warning resharper_c_sharp_warnings_cs1574_cs1584_cs1581_cs1580_highlighting=warning resharper_c_sharp_warnings_cs1574_highlighting=warning resharper_c_sharp_warnings_cs1580_highlighting=warning resharper_c_sharp_warnings_cs1584_highlighting=warning resharper_c_sharp_warnings_cs1587_highlighting=warning resharper_c_sharp_warnings_cs1589_highlighting=warning resharper_c_sharp_warnings_cs1590_highlighting=warning resharper_c_sharp_warnings_cs1591_highlighting=warning resharper_c_sharp_warnings_cs1592_highlighting=warning resharper_c_sharp_warnings_cs1710_highlighting=warning resharper_c_sharp_warnings_cs1711_highlighting=warning resharper_c_sharp_warnings_cs1712_highlighting=warning resharper_c_sharp_warnings_cs1717_highlighting=warning resharper_c_sharp_warnings_cs1723_highlighting=warning resharper_c_sharp_warnings_cs1911_highlighting=warning resharper_c_sharp_warnings_cs1957_highlighting=warning resharper_c_sharp_warnings_cs1981_highlighting=warning resharper_c_sharp_warnings_cs1998_highlighting=warning resharper_c_sharp_warnings_cs4014_highlighting=warning resharper_c_sharp_warnings_cs7095_highlighting=warning resharper_c_sharp_warnings_cs8094_highlighting=warning resharper_c_sharp_warnings_cs8123_highlighting=warning resharper_c_sharp_warnings_cs8383_highlighting=warning resharper_c_sharp_warnings_cs8416_highlighting=warning resharper_c_sharp_warnings_cs8417_highlighting=warning resharper_c_sharp_warnings_cs8425_highlighting=warning resharper_c_sharp_warnings_cs8509_highlighting=warning resharper_c_sharp_warnings_cs8597_highlighting=warning resharper_c_sharp_warnings_cs8600_highlighting=warning resharper_c_sharp_warnings_cs8601_highlighting=warning resharper_c_sharp_warnings_cs8602_highlighting=warning resharper_c_sharp_warnings_cs8603_highlighting=warning resharper_c_sharp_warnings_cs8604_highlighting=warning resharper_c_sharp_warnings_cs8605_highlighting=warning resharper_c_sharp_warnings_cs8606_highlighting=warning resharper_c_sharp_warnings_cs8608_highlighting=warning resharper_c_sharp_warnings_cs8609_highlighting=warning resharper_c_sharp_warnings_cs8610_highlighting=warning resharper_c_sharp_warnings_cs8611_highlighting=warning resharper_c_sharp_warnings_cs8612_highlighting=warning resharper_c_sharp_warnings_cs8613_highlighting=warning resharper_c_sharp_warnings_cs8614_highlighting=warning resharper_c_sharp_warnings_cs8615_highlighting=warning resharper_c_sharp_warnings_cs8616_highlighting=warning resharper_c_sharp_warnings_cs8617_highlighting=warning resharper_c_sharp_warnings_cs8618_highlighting=warning resharper_c_sharp_warnings_cs8619_highlighting=warning resharper_c_sharp_warnings_cs8620_highlighting=warning resharper_c_sharp_warnings_cs8621_highlighting=warning resharper_c_sharp_warnings_cs8622_highlighting=warning resharper_c_sharp_warnings_cs8624_highlighting=warning resharper_c_sharp_warnings_cs8625_highlighting=warning resharper_c_sharp_warnings_cs8629_highlighting=warning resharper_c_sharp_warnings_cs8631_highlighting=warning resharper_c_sharp_warnings_cs8632_highlighting=warning resharper_c_sharp_warnings_cs8633_highlighting=warning resharper_c_sharp_warnings_cs8634_highlighting=warning resharper_c_sharp_warnings_cs8643_highlighting=warning resharper_c_sharp_warnings_cs8644_highlighting=warning resharper_c_sharp_warnings_cs8645_highlighting=warning resharper_c_sharp_warnings_cs8656_highlighting=warning resharper_c_sharp_warnings_cs8667_highlighting=warning resharper_c_sharp_warnings_cs8714_highlighting=warning resharper_c_sharp_warnings_wme006_highlighting=warning resharper_declaration_hides_highlighting=hint resharper_declaration_is_empty_highlighting=warning resharper_declaration_visibility_error_highlighting=error resharper_default_value_attribute_for_optional_parameter_highlighting=warning resharper_delegate_subtraction_highlighting=warning resharper_deleting_non_qualified_reference_highlighting=error resharper_dl_tag_contains_non_dt_or_dd_elements_highlighting=hint resharper_double_colons_expected_highlighting=error resharper_double_colons_preferred_highlighting=suggestion resharper_double_negation_of_boolean_highlighting=warning resharper_double_negation_operator_highlighting=suggestion resharper_duplicate_identifier_error_highlighting=error resharper_duplicate_reference_comment_highlighting=warning resharper_duplicate_resource_highlighting=warning resharper_duplicating_local_declaration_highlighting=warning resharper_duplicating_parameter_declaration_error_highlighting=error resharper_duplicating_property_declaration_error_highlighting=error resharper_duplicating_property_declaration_highlighting=warning resharper_duplicating_switch_label_highlighting=warning resharper_dynamic_shift_right_op_is_not_int_highlighting=warning resharper_ef1001_highlighting=warning resharper_elided_trailing_element_highlighting=warning resharper_empty_constructor_highlighting=warning resharper_empty_destructor_highlighting=warning resharper_empty_embedded_statement_highlighting=warning resharper_empty_for_statement_highlighting=warning resharper_empty_general_catch_clause_highlighting=warning resharper_empty_namespace_highlighting=warning resharper_empty_object_property_declaration_highlighting=error resharper_empty_return_value_for_type_annotated_function_highlighting=warning resharper_empty_statement_highlighting=warning resharper_empty_title_tag_highlighting=hint resharper_enc0001_highlighting=info resharper_enc0002_highlighting=info resharper_enc0003_highlighting=info resharper_enc0004_highlighting=info resharper_enc0005_highlighting=info resharper_enc0006_highlighting=info resharper_enc0007_highlighting=info resharper_enc0008_highlighting=info resharper_enc0009_highlighting=info resharper_enc0010_highlighting=info resharper_enc0011_highlighting=info resharper_enc0012_highlighting=info resharper_enc0013_highlighting=info resharper_enc0014_highlighting=info resharper_enc0015_highlighting=info resharper_enc0016_highlighting=info resharper_enc0017_highlighting=info resharper_enc0018_highlighting=info resharper_enc0019_highlighting=info resharper_enc0020_highlighting=info resharper_enc0021_highlighting=info resharper_enc0023_highlighting=info resharper_enc0024_highlighting=info resharper_enc0025_highlighting=info resharper_enc0026_highlighting=info resharper_enc0028_highlighting=info resharper_enc0029_highlighting=info resharper_enc0030_highlighting=info resharper_enc0031_highlighting=info resharper_enc0032_highlighting=info resharper_enc0033_highlighting=info resharper_enc0034_highlighting=info resharper_enc0035_highlighting=info resharper_enc0036_highlighting=info resharper_enc0037_highlighting=info resharper_enc0038_highlighting=info resharper_enc0039_highlighting=info resharper_enc0040_highlighting=info resharper_enc0041_highlighting=info resharper_enc0044_highlighting=info resharper_enc0045_highlighting=info resharper_enc0046_highlighting=info resharper_enc0047_highlighting=info resharper_enc0048_highlighting=info resharper_enc0049_highlighting=info resharper_enc0050_highlighting=info resharper_enc0051_highlighting=info resharper_enc0052_highlighting=info resharper_enc0053_highlighting=info resharper_enc0054_highlighting=info resharper_enc0055_highlighting=info resharper_enc0056_highlighting=info resharper_enc0057_highlighting=info resharper_enc0058_highlighting=info resharper_enc0059_highlighting=info resharper_enc0060_highlighting=info resharper_enc0061_highlighting=info resharper_enc0062_highlighting=info resharper_enc0063_highlighting=info resharper_enc0064_highlighting=info resharper_enc0065_highlighting=info resharper_enc0066_highlighting=info resharper_enc0067_highlighting=info resharper_enc0068_highlighting=info resharper_enc0069_highlighting=info resharper_enc0070_highlighting=info resharper_enc0071_highlighting=info resharper_enc0072_highlighting=info resharper_enc0073_highlighting=info resharper_enc0074_highlighting=info resharper_enc0075_highlighting=info resharper_enc0076_highlighting=info resharper_enc0080_highlighting=info resharper_enc0081_highlighting=info resharper_enc0082_highlighting=info resharper_enc0083_highlighting=info resharper_enc0084_highlighting=info resharper_enc0085_highlighting=info resharper_enc0086_highlighting=info resharper_enc1001_highlighting=info resharper_enc1002_highlighting=info resharper_enc1003_highlighting=info resharper_enc1004_highlighting=info resharper_enforce_do_while_statement_braces_highlighting=none resharper_enforce_fixed_statement_braces_highlighting=none resharper_enforce_foreach_statement_braces_highlighting=none resharper_enforce_for_statement_braces_highlighting=none resharper_enforce_if_statement_braces_highlighting=none resharper_enforce_lock_statement_braces_highlighting=none resharper_enforce_using_statement_braces_highlighting=none resharper_enforce_while_statement_braces_highlighting=none resharper_enumerable_sum_in_explicit_unchecked_context_highlighting=warning resharper_enum_underlying_type_is_int_highlighting=warning resharper_equal_expression_comparison_highlighting=warning resharper_error_in_xml_doc_reference_highlighting=error resharper_es6_feature_highlighting=error resharper_es7_feature_highlighting=error resharper_escaped_keyword_highlighting=warning resharper_eval_arguments_name_error_highlighting=error resharper_event_never_invoked_global_highlighting=suggestion resharper_event_never_invoked_highlighting=warning resharper_event_never_subscribed_to_global_highlighting=suggestion resharper_event_never_subscribed_to_local_highlighting=suggestion resharper_event_unsubscription_via_anonymous_delegate_highlighting=warning resharper_experimental_feature_highlighting=error resharper_explicit_caller_info_argument_highlighting=warning resharper_expression_is_always_const_highlighting=warning resharper_expression_is_always_null_highlighting=warning resharper_field_can_be_made_read_only_global_highlighting=suggestion resharper_field_can_be_made_read_only_local_highlighting=suggestion resharper_foreach_can_be_converted_to_query_using_another_get_enumerator_highlighting=hint resharper_foreach_can_be_partly_converted_to_query_using_another_get_enumerator_highlighting=hint resharper_format_string_placeholders_mismatch_highlighting=warning resharper_format_string_problem_highlighting=warning resharper_for_can_be_converted_to_foreach_highlighting=suggestion resharper_for_statement_condition_is_true_highlighting=warning resharper_functions_used_before_declared_highlighting=none resharper_function_complexity_overflow_highlighting=none resharper_function_never_returns_highlighting=warning resharper_function_parameter_named_arguments_highlighting=warning resharper_function_recursive_on_all_paths_highlighting=warning resharper_function_used_out_of_scope_highlighting=warning resharper_gc_suppress_finalize_for_type_without_destructor_highlighting=warning resharper_generic_enumerator_not_disposed_highlighting=warning resharper_heuristically_unreachable_code_highlighting=warning resharper_heuristic_unreachable_code_highlighting=warning resharper_hex_color_value_with_alpha_highlighting=error resharper_html_attributes_quotes_highlighting=hint resharper_html_attribute_not_resolved_highlighting=warning resharper_html_attribute_value_not_resolved_highlighting=warning resharper_html_dead_code_highlighting=warning resharper_html_event_not_resolved_highlighting=warning resharper_html_id_duplication_highlighting=warning resharper_html_id_not_resolved_highlighting=warning resharper_html_obsolete_highlighting=warning resharper_html_path_error_highlighting=warning resharper_html_tag_not_closed_highlighting=error resharper_html_tag_not_resolved_highlighting=warning resharper_html_tag_should_be_self_closed_highlighting=warning resharper_html_tag_should_not_be_self_closed_highlighting=warning resharper_html_warning_highlighting=warning resharper_identifier_typo_highlighting=suggestion resharper_ignored_directive_highlighting=warning resharper_implicit_any_error_highlighting=error resharper_implicit_any_type_warning_highlighting=warning resharper_import_keyword_not_with_invocation_highlighting=error resharper_inactive_preprocessor_branch_highlighting=warning resharper_inconsistently_synchronized_field_highlighting=warning resharper_inconsistent_function_returns_highlighting=warning resharper_inconsistent_naming_highlighting=warning resharper_incorrect_blank_lines_near_braces_highlighting=none resharper_incorrect_operand_in_type_of_comparison_highlighting=warning resharper_incorrect_triple_slash_location_highlighting=warning resharper_indexing_by_invalid_range_highlighting=warning resharper_inheritdoc_consider_usage_highlighting=none resharper_inheritdoc_invalid_usage_highlighting=warning resharper_inline_out_variable_declaration_highlighting=suggestion resharper_internal_or_private_member_not_documented_highlighting=none resharper_interpolated_string_expression_is_not_i_formattable_highlighting=warning resharper_introduce_optional_parameters_global_highlighting=suggestion resharper_introduce_optional_parameters_local_highlighting=suggestion resharper_introduce_variable_to_apply_guard_highlighting=hint resharper_int_division_by_zero_highlighting=warning resharper_int_relational_or_equality_expression_always_same_value_highlighting=warning resharper_int_variable_overflow_highlighting=warning resharper_int_variable_overflow_in_checked_context_highlighting=warning resharper_int_variable_overflow_in_unchecked_context_highlighting=warning resharper_invalid_attribute_value_highlighting=warning resharper_invalid_json_syntax_highlighting=error resharper_invalid_task_element_highlighting=none resharper_invalid_value_highlighting=error resharper_invalid_value_type_highlighting=warning resharper_invalid_xml_doc_comment_highlighting=warning resharper_invert_condition_1_highlighting=hint resharper_invert_if_highlighting=hint resharper_invocation_is_skipped_highlighting=hint resharper_invocation_of_non_function_highlighting=warning resharper_invoked_expression_maybe_non_function_highlighting=warning resharper_invoke_as_extension_method_highlighting=suggestion resharper_is_expression_always_false_highlighting=warning resharper_is_expression_always_of_type_highlighting=warning resharper_is_expression_always_true_highlighting=warning resharper_iterator_method_result_is_ignored_highlighting=warning resharper_iterator_never_returns_highlighting=warning resharper_join_declaration_and_initializer_highlighting=suggestion resharper_join_declaration_and_initializer_js_highlighting=suggestion resharper_join_null_check_with_usage_highlighting=suggestion resharper_join_null_check_with_usage_when_possible_highlighting=none resharper_json_validation_failed_highlighting=error resharper_js_path_not_found_highlighting=error resharper_js_unreachable_code_highlighting=warning resharper_jump_must_be_in_loop_highlighting=warning resharper_label_or_semicolon_expected_highlighting=error resharper_less_specific_overload_than_main_signature_highlighting=warning resharper_lexical_declaration_needs_block_highlighting=error resharper_localizable_element_highlighting=warning resharper_local_function_can_be_made_static_highlighting=hint resharper_local_function_redefined_later_highlighting=warning resharper_local_name_captured_only_highlighting=warning resharper_local_variable_hides_member_highlighting=warning resharper_long_literal_ending_lower_l_highlighting=warning resharper_loop_can_be_converted_to_query_highlighting=hint resharper_loop_can_be_partly_converted_to_query_highlighting=none resharper_loop_variable_is_never_changed_inside_loop_highlighting=warning resharper_l_value_is_expected_highlighting=error resharper_markup_attribute_typo_highlighting=suggestion resharper_markup_text_typo_highlighting=suggestion resharper_meaningless_default_parameter_value_highlighting=warning resharper_member_can_be_internal_highlighting=none resharper_member_can_be_made_static_global_highlighting=hint resharper_member_can_be_made_static_local_highlighting=hint resharper_member_can_be_private_global_highlighting=suggestion resharper_member_can_be_private_local_highlighting=suggestion resharper_member_can_be_protected_global_highlighting=suggestion resharper_member_can_be_protected_local_highlighting=suggestion resharper_member_hides_static_from_outer_class_highlighting=warning resharper_member_initializer_value_ignored_highlighting=warning resharper_merge_cast_with_type_check_highlighting=suggestion resharper_merge_conditional_expression_highlighting=suggestion resharper_merge_conditional_expression_when_possible_highlighting=none resharper_merge_sequential_checks_highlighting=suggestion resharper_merge_sequential_checks_when_possible_highlighting=none resharper_method_has_async_overload_highlighting=suggestion resharper_method_has_async_overload_with_cancellation_highlighting=suggestion resharper_method_overload_with_optional_parameter_highlighting=warning resharper_method_supports_cancellation_highlighting=suggestion resharper_missing_alt_attribute_in_img_tag_highlighting=hint resharper_missing_attribute_highlighting=warning resharper_missing_blank_lines_highlighting=none resharper_missing_body_tag_highlighting=warning resharper_missing_has_own_property_in_foreach_highlighting=warning resharper_missing_head_and_body_tags_highlighting=warning resharper_missing_head_tag_highlighting=warning resharper_missing_indent_highlighting=none resharper_missing_linebreak_highlighting=none resharper_missing_space_highlighting=none resharper_missing_title_tag_highlighting=hint resharper_misuse_of_owner_function_this_highlighting=warning resharper_more_specific_foreach_variable_type_available_highlighting=suggestion resharper_more_specific_signature_after_less_specific_highlighting=warning resharper_multiple_declarations_in_foreach_highlighting=error resharper_multiple_nullable_attributes_usage_highlighting=warning resharper_multiple_order_by_highlighting=warning resharper_multiple_output_tags_highlighting=warning resharper_multiple_resolve_candidates_in_text_highlighting=warning resharper_multiple_spaces_highlighting=none resharper_multiple_statements_on_one_line_highlighting=none resharper_multiple_type_members_on_one_line_highlighting=none resharper_must_use_return_value_highlighting=warning resharper_mvc1000_highlighting=warning resharper_mvc1001_highlighting=warning resharper_mvc1002_highlighting=warning resharper_mvc1003_highlighting=warning resharper_mvc1004_highlighting=warning resharper_mvc1005_highlighting=warning resharper_mvc1006_highlighting=error resharper_mvc_action_not_resolved_highlighting=error resharper_mvc_area_not_resolved_highlighting=error resharper_mvc_controller_not_resolved_highlighting=error resharper_mvc_invalid_model_type_highlighting=error resharper_mvc_masterpage_not_resolved_highlighting=error resharper_mvc_partial_view_not_resolved_highlighting=error resharper_mvc_template_not_resolved_highlighting=error resharper_mvc_view_component_not_resolved_highlighting=error resharper_mvc_view_component_view_not_resolved_highlighting=error resharper_mvc_view_not_resolved_highlighting=error resharper_native_type_prototype_extending_highlighting=warning resharper_native_type_prototype_overwriting_highlighting=warning resharper_negative_equality_expression_highlighting=suggestion resharper_negative_index_highlighting=warning resharper_nested_string_interpolation_highlighting=suggestion resharper_non_assigned_constant_highlighting=error resharper_non_constant_equality_expression_has_constant_result_highlighting=warning resharper_non_readonly_member_in_get_hash_code_highlighting=warning resharper_non_volatile_field_in_double_check_locking_highlighting=warning resharper_not_accessed_field_compiler_highlighting=warning resharper_not_accessed_field_global_highlighting=suggestion resharper_not_accessed_field_local_highlighting=warning resharper_not_accessed_variable_compiler_highlighting=warning resharper_not_accessed_variable_highlighting=warning resharper_not_all_paths_return_value_highlighting=warning resharper_not_assigned_out_parameter_highlighting=warning resharper_not_declared_in_parent_culture_highlighting=warning resharper_not_null_member_is_not_initialized_highlighting=warning resharper_not_observable_annotation_redundancy_highlighting=warning resharper_not_overridden_in_specific_culture_highlighting=warning resharper_not_resolved_highlighting=warning resharper_not_resolved_in_text_highlighting=warning resharper_no_support_for_vb_highlighting=warning resharper_n_unit_async_method_must_be_task_highlighting=warning resharper_n_unit_incorrect_argument_type_highlighting=warning resharper_n_unit_incorrect_expected_result_type_highlighting=warning resharper_n_unit_method_with_parameters_and_test_attribute_highlighting=warning resharper_n_unit_missing_arguments_in_test_case_attribute_highlighting=warning resharper_n_unit_non_public_method_with_test_attribute_highlighting=warning resharper_n_unit_redundant_argument_instead_of_expected_result_highlighting=warning resharper_n_unit_redundant_argument_in_test_case_attribute_highlighting=warning resharper_n_unit_redundant_expected_result_in_test_case_attribute_highlighting=warning resharper_n_unit_test_case_attribute_requires_expected_result_highlighting=warning resharper_n_unit_test_case_result_property_duplicates_expected_result_highlighting=warning resharper_n_unit_test_case_result_property_is_obsolete_highlighting=warning resharper_n_unit_test_case_source_cannot_be_resolved_highlighting=warning resharper_n_unit_test_case_source_must_be_field_property_method_highlighting=warning resharper_n_unit_test_case_source_must_be_static_highlighting=warning resharper_n_unit_test_case_source_should_implement_i_enumerable_highlighting=warning resharper_object_creation_as_statement_highlighting=warning resharper_object_destructuring_without_parentheses_highlighting=error resharper_object_literals_are_not_comma_free_highlighting=error resharper_obsolete_element_error_highlighting=error resharper_obsolete_element_highlighting=warning resharper_octal_literals_not_allowed_error_highlighting=error resharper_ol_tag_contains_non_li_elements_highlighting=hint resharper_one_way_operation_contract_with_return_type_highlighting=warning resharper_operation_contract_without_service_contract_highlighting=warning resharper_operator_is_can_be_used_highlighting=warning resharper_optional_parameter_hierarchy_mismatch_highlighting=warning resharper_optional_parameter_ref_out_highlighting=warning resharper_other_tags_inside_script1_highlighting=error resharper_other_tags_inside_script2_highlighting=error resharper_other_tags_inside_unclosed_script_highlighting=error resharper_outdent_is_off_prev_level_highlighting=none resharper_output_tag_required_highlighting=warning resharper_overridden_with_empty_value_highlighting=warning resharper_overridden_with_same_value_highlighting=suggestion resharper_parameter_doesnt_make_any_sense_highlighting=warning resharper_parameter_hides_member_highlighting=warning resharper_parameter_only_used_for_precondition_check_global_highlighting=suggestion resharper_parameter_only_used_for_precondition_check_local_highlighting=warning resharper_parameter_type_can_be_enumerable_global_highlighting=hint resharper_parameter_type_can_be_enumerable_local_highlighting=hint resharper_parameter_value_is_not_used_highlighting=warning resharper_partial_method_parameter_name_mismatch_highlighting=warning resharper_partial_method_with_single_part_highlighting=warning resharper_partial_type_with_single_part_highlighting=warning resharper_path_not_resolved_highlighting=error resharper_pattern_always_matches_highlighting=warning resharper_pattern_always_of_type_highlighting=warning resharper_pattern_never_matches_highlighting=warning resharper_polymorphic_field_like_event_invocation_highlighting=warning resharper_possible_infinite_inheritance_highlighting=warning resharper_possible_intended_rethrow_highlighting=warning resharper_possible_interface_member_ambiguity_highlighting=warning resharper_possible_invalid_cast_exception_highlighting=warning resharper_possible_invalid_cast_exception_in_foreach_loop_highlighting=warning resharper_possible_invalid_operation_exception_highlighting=warning resharper_possible_loss_of_fraction_highlighting=warning resharper_possible_mistaken_argument_highlighting=warning resharper_possible_mistaken_call_to_get_type_1_highlighting=warning resharper_possible_mistaken_call_to_get_type_2_highlighting=warning resharper_possible_multiple_enumeration_highlighting=warning resharper_possible_multiple_write_access_in_double_check_locking_highlighting=warning resharper_possible_null_reference_exception_highlighting=warning resharper_possible_struct_member_modification_of_non_variable_struct_highlighting=warning resharper_possible_unintended_linear_search_in_set_highlighting=warning resharper_possible_unintended_queryable_as_enumerable_highlighting=suggestion resharper_possible_unintended_reference_comparison_highlighting=warning resharper_possible_write_to_me_highlighting=warning resharper_possibly_impure_method_call_on_readonly_variable_highlighting=warning resharper_possibly_incorrectly_broken_statement_highlighting=warning resharper_possibly_missing_indexer_initializer_comma_highlighting=warning resharper_possibly_mistaken_use_of_interpolated_string_insert_highlighting=warning resharper_possibly_mistaken_use_of_params_method_highlighting=warning resharper_possibly_unassigned_property_highlighting=hint resharper_private_field_can_be_converted_to_local_variable_highlighting=warning resharper_private_variable_can_be_made_readonly_highlighting=hint resharper_property_getter_cannot_have_parameters_highlighting=error resharper_property_not_resolved_highlighting=error resharper_property_setter_must_have_single_parameter_highlighting=error resharper_public_constructor_in_abstract_class_highlighting=suggestion resharper_pure_attribute_on_void_method_highlighting=warning resharper_qualified_expression_is_null_highlighting=warning resharper_qualified_expression_maybe_null_highlighting=warning resharper_razor_layout_not_resolved_highlighting=error resharper_razor_section_not_resolved_highlighting=error resharper_read_access_in_double_check_locking_highlighting=warning resharper_redundant_abstract_modifier_highlighting=warning resharper_redundant_anonymous_type_property_name_highlighting=warning resharper_redundant_argument_default_value_highlighting=warning resharper_redundant_array_creation_expression_highlighting=hint resharper_redundant_array_lower_bound_specification_highlighting=warning resharper_redundant_assignment_highlighting=warning resharper_redundant_attribute_parentheses_highlighting=hint resharper_redundant_attribute_usage_property_highlighting=suggestion resharper_redundant_base_constructor_call_highlighting=warning resharper_redundant_base_qualifier_highlighting=warning resharper_redundant_blank_lines_highlighting=none resharper_redundant_block_highlighting=warning resharper_redundant_bool_compare_highlighting=warning resharper_redundant_case_label_highlighting=warning resharper_redundant_cast_0_highlighting=warning resharper_redundant_cast_highlighting=warning resharper_redundant_catch_clause_highlighting=warning resharper_redundant_check_before_assignment_highlighting=warning resharper_redundant_collection_initializer_element_braces_highlighting=hint resharper_redundant_comparison_with_boolean_highlighting=warning resharper_redundant_css_hack_highlighting=warning resharper_redundant_declaration_semicolon_highlighting=hint resharper_redundant_default_member_initializer_highlighting=warning resharper_redundant_delegate_creation_highlighting=warning resharper_redundant_disable_warning_comment_highlighting=warning resharper_redundant_discarded_pattern_highlighting=suggestion resharper_redundant_discard_designation_highlighting=suggestion resharper_redundant_else_block_highlighting=warning resharper_redundant_empty_case_else_highlighting=warning resharper_redundant_empty_constructor_highlighting=warning resharper_redundant_empty_finally_block_highlighting=warning resharper_redundant_empty_object_creation_argument_list_highlighting=hint resharper_redundant_empty_object_or_collection_initializer_highlighting=warning resharper_redundant_empty_switch_section_highlighting=warning resharper_redundant_enumerable_cast_call_highlighting=warning resharper_redundant_explicit_array_creation_highlighting=warning resharper_redundant_explicit_array_size_highlighting=warning resharper_redundant_explicit_nullable_creation_highlighting=warning resharper_redundant_explicit_params_array_creation_highlighting=suggestion resharper_redundant_explicit_tuple_component_name_highlighting=warning resharper_redundant_extends_list_entry_highlighting=warning resharper_redundant_fixed_pointer_declaration_highlighting=suggestion resharper_redundant_highlighting=warning resharper_redundant_if_else_block_highlighting=hint resharper_redundant_if_statement_then_keyword_highlighting=none resharper_redundant_immediate_delegate_invocation_highlighting=suggestion resharper_redundant_include_highlighting=warning resharper_redundant_intermediate_variable_highlighting=hint resharper_redundant_iterator_keyword_highlighting=warning resharper_redundant_jump_statement_highlighting=warning resharper_redundant_lambda_parameter_type_highlighting=warning resharper_redundant_lambda_signature_parentheses_highlighting=hint resharper_redundant_linebreak_highlighting=none resharper_redundant_local_class_name_highlighting=hint resharper_redundant_local_function_name_highlighting=hint resharper_redundant_logical_conditional_expression_operand_highlighting=warning resharper_redundant_me_qualifier_highlighting=warning resharper_redundant_my_base_qualifier_highlighting=warning resharper_redundant_my_class_qualifier_highlighting=warning resharper_redundant_name_qualifier_highlighting=warning resharper_redundant_not_null_constraint_highlighting=warning resharper_redundant_nullable_annotation_on_reference_type_constraint_highlighting=warning resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_base_type_highlighting=warning resharper_redundant_nullable_annotation_on_type_constraint_has_non_nullable_type_kind_highlighting=warning resharper_redundant_nullable_type_mark_highlighting=warning resharper_redundant_overflow_checking_context_highlighting=warning resharper_redundant_overload_global_highlighting=suggestion resharper_redundant_overload_local_highlighting=suggestion resharper_redundant_overridden_member_highlighting=warning resharper_redundant_params_highlighting=warning resharper_redundant_parentheses_highlighting=none resharper_redundant_parent_type_declaration_highlighting=warning resharper_redundant_property_parentheses_highlighting=hint resharper_redundant_property_pattern_clause_highlighting=suggestion resharper_redundant_qualifier_highlighting=warning resharper_redundant_query_order_by_ascending_keyword_highlighting=hint resharper_redundant_range_bound_highlighting=suggestion resharper_redundant_readonly_modifier_highlighting=suggestion resharper_redundant_setter_value_parameter_declaration_highlighting=hint resharper_redundant_space_highlighting=none resharper_redundant_string_format_call_highlighting=warning resharper_redundant_string_interpolation_highlighting=suggestion resharper_redundant_string_to_char_array_call_highlighting=warning resharper_redundant_string_type_highlighting=suggestion resharper_redundant_ternary_expression_highlighting=warning resharper_redundant_to_string_call_for_value_type_highlighting=hint resharper_redundant_to_string_call_highlighting=warning resharper_redundant_type_arguments_of_method_highlighting=warning resharper_redundant_type_cast_highlighting=warning resharper_redundant_type_cast_structural_highlighting=warning resharper_redundant_type_specification_in_default_expression_highlighting=suggestion resharper_redundant_units_highlighting=warning resharper_redundant_unsafe_context_highlighting=warning resharper_redundant_using_directive_highlighting=warning resharper_redundant_variable_type_specification_highlighting=hint resharper_redundant_verbatim_prefix_highlighting=suggestion resharper_redundant_verbatim_string_prefix_highlighting=suggestion resharper_reference_equals_with_value_type_highlighting=warning resharper_reg_exp_inspections_highlighting=warning resharper_remove_constructor_invocation_highlighting=none resharper_remove_redundant_braces_highlighting=none resharper_remove_redundant_or_statement_false_highlighting=suggestion resharper_remove_redundant_or_statement_true_highlighting=suggestion resharper_remove_to_list_1_highlighting=suggestion resharper_remove_to_list_2_highlighting=suggestion resharper_replace_indicing_with_array_destructuring_highlighting=hint resharper_replace_indicing_with_short_hand_properties_after_destructuring_highlighting=hint resharper_replace_undefined_checking_series_with_object_destructuring_highlighting=hint resharper_replace_with_destructuring_swap_highlighting=hint resharper_replace_with_first_or_default_1_highlighting=suggestion resharper_replace_with_first_or_default_2_highlighting=suggestion resharper_replace_with_first_or_default_3_highlighting=suggestion resharper_replace_with_first_or_default_4_highlighting=suggestion resharper_replace_with_last_or_default_1_highlighting=suggestion resharper_replace_with_last_or_default_2_highlighting=suggestion resharper_replace_with_last_or_default_3_highlighting=suggestion resharper_replace_with_last_or_default_4_highlighting=suggestion resharper_replace_with_of_type_1_highlighting=suggestion resharper_replace_with_of_type_2_highlighting=suggestion resharper_replace_with_of_type_3_highlighting=suggestion resharper_replace_with_of_type_any_1_highlighting=suggestion resharper_replace_with_of_type_any_2_highlighting=suggestion resharper_replace_with_of_type_count_1_highlighting=suggestion resharper_replace_with_of_type_count_2_highlighting=suggestion resharper_replace_with_of_type_first_1_highlighting=suggestion resharper_replace_with_of_type_first_2_highlighting=suggestion resharper_replace_with_of_type_first_or_default_1_highlighting=suggestion resharper_replace_with_of_type_first_or_default_2_highlighting=suggestion resharper_replace_with_of_type_last_1_highlighting=suggestion resharper_replace_with_of_type_last_2_highlighting=suggestion resharper_replace_with_of_type_last_or_default_1_highlighting=suggestion resharper_replace_with_of_type_last_or_default_2_highlighting=suggestion resharper_replace_with_of_type_long_count_highlighting=suggestion resharper_replace_with_of_type_single_1_highlighting=suggestion resharper_replace_with_of_type_single_2_highlighting=suggestion resharper_replace_with_of_type_single_or_default_1_highlighting=suggestion resharper_replace_with_of_type_single_or_default_2_highlighting=suggestion resharper_replace_with_of_type_where_highlighting=suggestion resharper_replace_with_simple_assignment_false_highlighting=suggestion resharper_replace_with_simple_assignment_true_highlighting=suggestion resharper_replace_with_single_assignment_false_highlighting=suggestion resharper_replace_with_single_assignment_true_highlighting=suggestion resharper_replace_with_single_call_to_any_highlighting=suggestion resharper_replace_with_single_call_to_count_highlighting=suggestion resharper_replace_with_single_call_to_first_highlighting=suggestion resharper_replace_with_single_call_to_first_or_default_highlighting=suggestion resharper_replace_with_single_call_to_last_highlighting=suggestion resharper_replace_with_single_call_to_last_or_default_highlighting=suggestion resharper_replace_with_single_call_to_single_highlighting=suggestion resharper_replace_with_single_call_to_single_or_default_highlighting=suggestion resharper_replace_with_single_or_default_1_highlighting=suggestion resharper_replace_with_single_or_default_2_highlighting=suggestion resharper_replace_with_single_or_default_3_highlighting=suggestion resharper_replace_with_single_or_default_4_highlighting=suggestion resharper_replace_with_string_is_null_or_empty_highlighting=suggestion resharper_required_base_types_conflict_highlighting=warning resharper_required_base_types_direct_conflict_highlighting=warning resharper_required_base_types_is_not_inherited_highlighting=warning resharper_requires_fallback_color_highlighting=warning resharper_resource_item_not_resolved_highlighting=error resharper_resource_not_resolved_highlighting=error resharper_resx_not_resolved_highlighting=warning resharper_return_from_global_scopet_with_value_highlighting=warning resharper_return_type_can_be_enumerable_global_highlighting=hint resharper_return_type_can_be_enumerable_local_highlighting=hint resharper_return_value_of_pure_method_is_not_used_highlighting=warning resharper_safe_cast_is_used_as_type_check_highlighting=suggestion resharper_same_imports_with_different_name_highlighting=warning resharper_same_variable_assignment_highlighting=warning resharper_script_tag_has_both_src_and_content_attributes_highlighting=error resharper_script_tag_with_content_before_includes_highlighting=hint resharper_sealed_member_in_sealed_class_highlighting=warning resharper_sensitive_data_api_usage_tag_highlighting=warning resharper_separate_control_transfer_statement_highlighting=none resharper_service_contract_without_operations_highlighting=warning resharper_shift_expression_real_shift_count_is_zero_highlighting=warning resharper_shift_expression_result_equals_zero_highlighting=warning resharper_shift_expression_right_operand_not_equal_real_count_highlighting=warning resharper_shift_expression_zero_left_operand_highlighting=warning resharper_similar_anonymous_type_nearby_highlighting=hint resharper_similar_expressions_comparison_highlighting=warning resharper_simplify_conditional_operator_highlighting=suggestion resharper_simplify_conditional_ternary_expression_highlighting=suggestion resharper_simplify_i_if_highlighting=suggestion resharper_simplify_linq_expression_highlighting=suggestion resharper_specify_a_culture_in_string_conversion_explicitly_highlighting=warning resharper_specify_string_comparison_highlighting=hint resharper_specify_variable_type_explicitly_highlighting=hint resharper_stack_alloc_inside_loop_highlighting=warning resharper_statement_termination_highlighting=warning resharper_static_member_initializer_referes_to_member_below_highlighting=warning resharper_static_member_in_generic_type_highlighting=warning resharper_static_problem_in_text_highlighting=warning resharper_string_compare_is_culture_specific_1_highlighting=warning resharper_string_compare_is_culture_specific_2_highlighting=warning resharper_string_compare_is_culture_specific_3_highlighting=warning resharper_string_compare_is_culture_specific_4_highlighting=warning resharper_string_compare_is_culture_specific_5_highlighting=warning resharper_string_compare_is_culture_specific_6_highlighting=warning resharper_string_compare_to_is_culture_specific_highlighting=warning resharper_string_concatenation_to_template_string_highlighting=hint resharper_string_ends_with_is_culture_specific_highlighting=none resharper_string_index_of_is_culture_specific_1_highlighting=warning resharper_string_index_of_is_culture_specific_2_highlighting=warning resharper_string_index_of_is_culture_specific_3_highlighting=warning resharper_string_last_index_of_is_culture_specific_1_highlighting=warning resharper_string_last_index_of_is_culture_specific_2_highlighting=warning resharper_string_last_index_of_is_culture_specific_3_highlighting=warning resharper_string_literal_as_interpolation_argument_highlighting=suggestion resharper_string_literal_typo_highlighting=suggestion resharper_string_literal_wrong_quotes_highlighting=hint resharper_string_starts_with_is_culture_specific_highlighting=none resharper_struct_can_be_made_read_only_highlighting=suggestion resharper_struct_member_can_be_made_read_only_highlighting=none resharper_suggest_base_type_for_parameter_highlighting=hint resharper_suggest_discard_declaration_var_style_highlighting=hint resharper_suggest_var_or_type_built_in_types_highlighting=hint resharper_suggest_var_or_type_deconstruction_declarations_highlighting=hint resharper_suggest_var_or_type_elsewhere_highlighting=hint resharper_suggest_var_or_type_simple_types_highlighting=hint resharper_super_call_prohibits_this_highlighting=error resharper_suspicious_instanceof_check_highlighting=warning resharper_suspicious_lambda_block_highlighting=warning resharper_suspicious_this_usage_highlighting=warning resharper_suspicious_typeof_check_highlighting=warning resharper_suspicious_type_conversion_global_highlighting=warning resharper_switch_expression_handles_some_known_enum_values_with_exception_in_default_highlighting=hint resharper_switch_statement_for_enum_misses_default_section_highlighting=hint resharper_switch_statement_handles_some_known_enum_values_with_default_highlighting=hint resharper_switch_statement_missing_some_enum_cases_no_default_highlighting=hint resharper_symbol_from_not_copied_locally_reference_used_warning_highlighting=warning resharper_syntax_is_not_allowed_highlighting=warning resharper_tabs_and_spaces_mismatch_highlighting=none resharper_tabs_are_disallowed_highlighting=none resharper_tabs_outside_indent_highlighting=none resharper_tail_recursive_call_highlighting=hint resharper_tasks_not_loaded_highlighting=warning resharper_ternary_can_be_replaced_by_its_condition_highlighting=warning resharper_this_in_global_context_highlighting=warning resharper_thread_static_at_instance_field_highlighting=warning resharper_thread_static_field_has_initializer_highlighting=warning resharper_throw_must_be_followed_by_expression_highlighting=error resharper_too_wide_local_variable_scope_highlighting=suggestion resharper_tree_node_enumerable_can_be_used_tag_highlighting=none resharper_try_cast_always_succeeds_highlighting=suggestion resharper_try_statements_can_be_merged_highlighting=hint resharper_ts_not_resolved_highlighting=error resharper_ts_resolved_from_inaccessible_module_highlighting=error resharper_type_guard_doesnt_affect_anything_highlighting=warning resharper_type_guard_produces_never_type_highlighting=warning resharper_type_parameter_can_be_variant_highlighting=suggestion resharper_type_parameter_hides_type_param_from_outer_scope_highlighting=warning resharper_ul_tag_contains_non_li_elements_highlighting=hint resharper_unassigned_field_compiler_highlighting=warning resharper_unassigned_field_global_highlighting=suggestion resharper_unassigned_field_local_highlighting=warning resharper_unassigned_get_only_auto_property_highlighting=warning resharper_unassigned_readonly_field_compiler_highlighting=warning resharper_unassigned_readonly_field_highlighting=warning resharper_unclosed_script_highlighting=error resharper_undeclared_global_variable_using_highlighting=warning resharper_unexpected_attribute_highlighting=warning resharper_unexpected_directive_highlighting=warning resharper_unexpected_value_highlighting=error resharper_unknown_css_class_highlighting=warning resharper_unknown_css_variable_highlighting=warning resharper_unknown_css_vendor_extension_highlighting=hint resharper_unknown_item_group_highlighting=warning resharper_unknown_metadata_highlighting=warning resharper_unknown_output_parameter_highlighting=warning resharper_unknown_property_highlighting=warning resharper_unknown_target_highlighting=warning resharper_unknown_task_attribute_highlighting=warning resharper_unknown_task_highlighting=warning resharper_unnecessary_whitespace_highlighting=none resharper_unreachable_code_highlighting=warning resharper_unreachable_switch_arm_due_to_integer_analysis_highlighting=warning resharper_unreachable_switch_case_due_to_integer_analysis_highlighting=warning resharper_unresolved_assembly_highlighting=warning resharper_unresolved_include_highlighting=warning resharper_unsafe_comma_in_object_properties_list_highlighting=warning resharper_unsupported_required_base_type_highlighting=warning resharper_unused_anonymous_method_signature_highlighting=warning resharper_unused_auto_property_accessor_global_highlighting=warning resharper_unused_auto_property_accessor_local_highlighting=warning resharper_unused_field_compiler_highlighting=warning resharper_unused_import_clause_highlighting=warning resharper_unused_inherited_parameter_highlighting=hint resharper_unused_label_highlighting=warning resharper_unused_locals_highlighting=warning resharper_unused_local_function_compiler_highlighting=warning resharper_unused_local_function_highlighting=warning resharper_unused_local_function_parameter_highlighting=warning resharper_unused_local_function_return_value_highlighting=warning resharper_unused_local_import_highlighting=warning resharper_unused_member_global_highlighting=suggestion resharper_unused_member_hierarchy_global_highlighting=suggestion resharper_unused_member_hierarchy_local_highlighting=warning resharper_unused_member_in_super_global_highlighting=suggestion resharper_unused_member_in_super_local_highlighting=warning resharper_unused_member_local_highlighting=warning resharper_unused_method_return_value_global_highlighting=suggestion resharper_unused_method_return_value_local_highlighting=warning resharper_unused_parameter_global_highlighting=suggestion resharper_unused_parameter_highlighting=warning resharper_unused_parameter_in_partial_method_highlighting=warning resharper_unused_parameter_local_highlighting=warning resharper_unused_property_highlighting=warning resharper_unused_tuple_component_in_return_value_highlighting=warning resharper_unused_type_global_highlighting=suggestion resharper_unused_type_local_highlighting=warning resharper_unused_type_parameter_highlighting=warning resharper_unused_variable_compiler_highlighting=warning resharper_unused_variable_highlighting=warning resharper_usage_of_definitely_unassigned_value_highlighting=warning resharper_usage_of_possibly_unassigned_value_highlighting=warning resharper_useless_binary_operation_highlighting=warning resharper_use_array_creation_expression_1_highlighting=suggestion resharper_use_array_creation_expression_2_highlighting=suggestion resharper_use_as_instead_of_type_cast_highlighting=hint resharper_use_await_using_highlighting=suggestion resharper_use_cancellation_token_for_i_async_enumerable_highlighting=suggestion resharper_use_collection_count_property_highlighting=suggestion resharper_use_deconstruction_highlighting=hint resharper_use_deconstruction_on_parameter_highlighting=hint resharper_use_format_specifier_in_format_string_highlighting=suggestion resharper_use_format_specifier_in_interpolation_highlighting=suggestion resharper_use_implicitly_typed_variable_evident_highlighting=hint resharper_use_implicitly_typed_variable_highlighting=none resharper_use_implicit_by_val_modifier_highlighting=hint resharper_use_indexed_property_highlighting=suggestion resharper_use_index_from_end_expression_highlighting=suggestion resharper_use_is_operator_1_highlighting=suggestion resharper_use_is_operator_2_highlighting=suggestion resharper_use_method_any_0_highlighting=suggestion resharper_use_method_any_1_highlighting=suggestion resharper_use_method_any_2_highlighting=suggestion resharper_use_method_any_3_highlighting=suggestion resharper_use_method_any_4_highlighting=suggestion resharper_use_method_is_instance_of_type_highlighting=suggestion resharper_use_nameof_expression_highlighting=suggestion resharper_use_name_of_instead_of_type_of_highlighting=suggestion resharper_use_negated_pattern_matching_highlighting=hint resharper_use_null_propagation_highlighting=suggestion resharper_use_null_propagation_when_possible_highlighting=none resharper_use_object_or_collection_initializer_highlighting=suggestion resharper_use_of_implicit_global_in_function_scope_highlighting=warning resharper_use_of_possibly_unassigned_property_highlighting=warning resharper_use_pattern_matching_highlighting=suggestion resharper_use_string_interpolation_highlighting=suggestion resharper_use_switch_case_pattern_variable_highlighting=suggestion resharper_use_verbatim_string_highlighting=hint resharper_using_of_reserved_word_error_highlighting=error resharper_using_of_reserved_word_highlighting=warning resharper_value_parameter_not_used_highlighting=warning resharper_value_should_have_units_highlighting=error resharper_variable_can_be_made_const_highlighting=hint resharper_variable_can_be_made_let_highlighting=hint resharper_variable_can_be_moved_to_inner_block_highlighting=hint resharper_variable_hides_outer_variable_highlighting=warning resharper_variable_used_before_declared_highlighting=warning resharper_variable_used_in_inner_scope_before_declared_highlighting=warning resharper_variable_used_out_of_scope_highlighting=warning resharper_vb_check_for_reference_equality_instead_1_highlighting=suggestion resharper_vb_check_for_reference_equality_instead_2_highlighting=suggestion resharper_vb_possible_mistaken_argument_highlighting=warning resharper_vb_possible_mistaken_call_to_get_type_1_highlighting=warning resharper_vb_possible_mistaken_call_to_get_type_2_highlighting=warning resharper_vb_remove_to_list_1_highlighting=suggestion resharper_vb_remove_to_list_2_highlighting=suggestion resharper_vb_replace_with_first_or_default_highlighting=suggestion resharper_vb_replace_with_last_or_default_highlighting=suggestion resharper_vb_replace_with_of_type_1_highlighting=suggestion resharper_vb_replace_with_of_type_2_highlighting=suggestion resharper_vb_replace_with_of_type_any_1_highlighting=suggestion resharper_vb_replace_with_of_type_any_2_highlighting=suggestion resharper_vb_replace_with_of_type_count_1_highlighting=suggestion resharper_vb_replace_with_of_type_count_2_highlighting=suggestion resharper_vb_replace_with_of_type_first_1_highlighting=suggestion resharper_vb_replace_with_of_type_first_2_highlighting=suggestion resharper_vb_replace_with_of_type_first_or_default_1_highlighting=suggestion resharper_vb_replace_with_of_type_first_or_default_2_highlighting=suggestion resharper_vb_replace_with_of_type_last_1_highlighting=suggestion resharper_vb_replace_with_of_type_last_2_highlighting=suggestion resharper_vb_replace_with_of_type_last_or_default_1_highlighting=suggestion resharper_vb_replace_with_of_type_last_or_default_2_highlighting=suggestion resharper_vb_replace_with_of_type_single_1_highlighting=suggestion resharper_vb_replace_with_of_type_single_2_highlighting=suggestion resharper_vb_replace_with_of_type_single_or_default_1_highlighting=suggestion resharper_vb_replace_with_of_type_single_or_default_2_highlighting=suggestion resharper_vb_replace_with_of_type_where_highlighting=suggestion resharper_vb_replace_with_single_assignment_1_highlighting=suggestion resharper_vb_replace_with_single_assignment_2_highlighting=suggestion resharper_vb_replace_with_single_call_to_any_highlighting=suggestion resharper_vb_replace_with_single_call_to_count_highlighting=suggestion resharper_vb_replace_with_single_call_to_first_highlighting=suggestion resharper_vb_replace_with_single_call_to_first_or_default_highlighting=suggestion resharper_vb_replace_with_single_call_to_last_highlighting=suggestion resharper_vb_replace_with_single_call_to_last_or_default_highlighting=suggestion resharper_vb_replace_with_single_call_to_single_highlighting=suggestion resharper_vb_replace_with_single_call_to_single_or_default_highlighting=suggestion resharper_vb_replace_with_single_or_default_highlighting=suggestion resharper_vb_simplify_linq_expression_10_highlighting=hint resharper_vb_simplify_linq_expression_1_highlighting=suggestion resharper_vb_simplify_linq_expression_2_highlighting=suggestion resharper_vb_simplify_linq_expression_3_highlighting=suggestion resharper_vb_simplify_linq_expression_4_highlighting=suggestion resharper_vb_simplify_linq_expression_5_highlighting=suggestion resharper_vb_simplify_linq_expression_6_highlighting=suggestion resharper_vb_simplify_linq_expression_7_highlighting=hint resharper_vb_simplify_linq_expression_8_highlighting=hint resharper_vb_simplify_linq_expression_9_highlighting=hint resharper_vb_string_compare_is_culture_specific_1_highlighting=warning resharper_vb_string_compare_is_culture_specific_2_highlighting=warning resharper_vb_string_compare_is_culture_specific_3_highlighting=warning resharper_vb_string_compare_is_culture_specific_4_highlighting=warning resharper_vb_string_compare_is_culture_specific_5_highlighting=warning resharper_vb_string_compare_is_culture_specific_6_highlighting=warning resharper_vb_string_compare_to_is_culture_specific_highlighting=warning resharper_vb_string_ends_with_is_culture_specific_highlighting=none resharper_vb_string_index_of_is_culture_specific_1_highlighting=warning resharper_vb_string_index_of_is_culture_specific_2_highlighting=warning resharper_vb_string_index_of_is_culture_specific_3_highlighting=warning resharper_vb_string_last_index_of_is_culture_specific_1_highlighting=warning resharper_vb_string_last_index_of_is_culture_specific_2_highlighting=warning resharper_vb_string_last_index_of_is_culture_specific_3_highlighting=warning resharper_vb_string_starts_with_is_culture_specific_highlighting=none resharper_vb_unreachable_code_highlighting=warning resharper_vb_use_array_creation_expression_1_highlighting=suggestion resharper_vb_use_array_creation_expression_2_highlighting=suggestion resharper_vb_use_first_instead_highlighting=warning resharper_vb_use_method_any_1_highlighting=suggestion resharper_vb_use_method_any_2_highlighting=suggestion resharper_vb_use_method_any_3_highlighting=suggestion resharper_vb_use_method_any_4_highlighting=suggestion resharper_vb_use_method_any_5_highlighting=suggestion resharper_vb_use_method_is_instance_of_type_highlighting=suggestion resharper_vb_use_type_of_is_operator_1_highlighting=suggestion resharper_vb_use_type_of_is_operator_2_highlighting=suggestion resharper_vb_warnings_bc400005_highlighting=warning resharper_vb_warnings_bc40000_highlighting=warning resharper_vb_warnings_bc40008_highlighting=warning resharper_vb_warnings_bc40056_highlighting=warning resharper_vb_warnings_bc42016_highlighting=warning resharper_vb_warnings_bc42025_highlighting=warning resharper_vb_warnings_bc42104_highlighting=warning resharper_vb_warnings_bc42105_bc42106_bc42107_highlighting=warning resharper_vb_warnings_bc42304_highlighting=warning resharper_vb_warnings_bc42309_highlighting=warning resharper_vb_warnings_bc42322_highlighting=warning resharper_vb_warnings_bc42349_highlighting=warning resharper_vb_warnings_bc42353_bc42354_bc42355_highlighting=warning resharper_vb_warnings_bc42356_highlighting=warning resharper_vb_warnings_bc42358_highlighting=warning resharper_vb_warnings_wme006_highlighting=warning resharper_virtual_member_call_in_constructor_highlighting=warning resharper_virtual_member_never_overridden_global_highlighting=suggestion resharper_virtual_member_never_overridden_local_highlighting=suggestion resharper_void_method_with_must_use_return_value_attribute_highlighting=warning resharper_web_config_module_not_resolved_highlighting=warning resharper_web_config_module_qualification_resolve_highlighting=warning resharper_web_config_redundant_add_namespace_tag_highlighting=warning resharper_web_config_redundant_location_tag_highlighting=warning resharper_web_config_tag_prefix_redundand_highlighting=warning resharper_web_config_type_not_resolved_highlighting=warning resharper_web_config_unused_add_tag_highlighting=warning resharper_web_config_unused_element_due_to_config_source_attribute_highlighting=warning resharper_web_config_unused_remove_or_clear_tag_highlighting=warning resharper_web_config_web_config_path_warning_highlighting=warning resharper_web_config_wrong_module_highlighting=warning resharper_web_ignored_path_highlighting=none resharper_web_mapped_path_highlighting=hint resharper_with_statement_using_error_highlighting=error resharper_wrong_expression_statement_highlighting=warning resharper_wrong_indent_size_highlighting=none resharper_wrong_metadata_use_highlighting=none resharper_wrong_public_modifier_specification_highlighting=hint resharper_wrong_require_relative_path_highlighting=hint resharper_xaml_binding_without_context_not_resolved_highlighting=hint resharper_xaml_binding_with_context_not_resolved_highlighting=warning resharper_xaml_constructor_warning_highlighting=warning resharper_xaml_dependency_property_resolve_error_highlighting=warning resharper_xaml_duplicate_style_setter_highlighting=warning resharper_xaml_dynamic_resource_error_highlighting=error resharper_xaml_element_name_reference_not_resolved_highlighting=error resharper_xaml_ignored_path_highlighting_highlighting=none resharper_xaml_index_out_of_grid_definition_highlighting=warning resharper_xaml_invalid_member_type_highlighting=error resharper_xaml_invalid_resource_target_type_highlighting=error resharper_xaml_invalid_resource_type_highlighting=error resharper_xaml_invalid_type_highlighting=error resharper_xaml_language_level_highlighting=error resharper_xaml_mapped_path_highlighting_highlighting=hint resharper_xaml_missing_grid_index_highlighting=warning resharper_xaml_path_error_highlighting=warning resharper_xaml_redundant_attached_property_highlighting=warning resharper_xaml_redundant_collection_property_highlighting=warning resharper_xaml_redundant_freeze_attribute_highlighting=warning resharper_xaml_redundant_grid_definitions_highlighting=warning resharper_xaml_redundant_grid_span_highlighting=warning resharper_xaml_redundant_modifiers_attribute_highlighting=warning resharper_xaml_redundant_namespace_alias_highlighting=warning resharper_xaml_redundant_name_attribute_highlighting=warning resharper_xaml_redundant_property_type_qualifier_highlighting=warning resharper_xaml_redundant_resource_highlighting=warning resharper_xaml_redundant_styled_value_highlighting=warning resharper_xaml_redundant_xamarin_forms_class_declaration_highlighting=warning resharper_xaml_routed_event_resolve_error_highlighting=warning resharper_xaml_static_resource_not_resolved_highlighting=warning resharper_xaml_style_invalid_target_type_highlighting=error resharper_xaml_unexpected_text_token_highlighting=error resharper_xaml_xaml_duplicate_device_family_type_view_highlighting_highlighting=error resharper_xaml_xaml_mismatched_device_family_view_clr_name_highlighting_highlighting=warning resharper_xaml_xaml_relative_source_default_mode_warning_highlighting_highlighting=warning resharper_xaml_xaml_unknown_device_family_type_highlighting_highlighting=warning resharper_xaml_xaml_xamarin_forms_data_type_and_binding_context_type_mismatched_highlighting_highlighting=warning resharper_xaml_x_key_attribute_disallowed_highlighting=error resharper_xml_doc_comment_syntax_problem_highlighting=warning resharper_xunit_xunit_test_with_console_output_highlighting=warning resharper_x_unit1000_highlighting=error resharper_x_unit1001_highlighting=error resharper_x_unit1002_highlighting=error resharper_x_unit1003_highlighting=error resharper_x_unit1004_highlighting=hint resharper_x_unit1005_highlighting=warning resharper_x_unit1006_highlighting=warning resharper_x_unit1007_highlighting=error resharper_x_unit1008_highlighting=warning resharper_x_unit1009_highlighting=error resharper_x_unit1010_highlighting=error resharper_x_unit1011_highlighting=error resharper_x_unit1012_highlighting=warning resharper_x_unit1013_highlighting=warning resharper_x_unit1014_highlighting=warning resharper_x_unit1015_highlighting=error resharper_x_unit1016_highlighting=error resharper_x_unit1017_highlighting=error resharper_x_unit1018_highlighting=error resharper_x_unit1019_highlighting=error resharper_x_unit1020_highlighting=error resharper_x_unit1021_highlighting=warning resharper_x_unit1022_highlighting=error resharper_x_unit1023_highlighting=error resharper_x_unit1024_highlighting=error resharper_x_unit1025_highlighting=warning resharper_x_unit1026_highlighting=warning resharper_x_unit2000_highlighting=warning resharper_x_unit2001_highlighting=none resharper_x_unit2002_highlighting=warning resharper_x_unit2003_highlighting=warning resharper_x_unit2004_highlighting=warning resharper_x_unit2005_highlighting=warning resharper_x_unit2006_highlighting=warning resharper_x_unit2007_highlighting=warning resharper_x_unit2008_highlighting=warning resharper_x_unit2009_highlighting=warning resharper_x_unit2010_highlighting=warning resharper_x_unit2011_highlighting=warning resharper_x_unit2012_highlighting=warning resharper_x_unit2013_highlighting=warning resharper_x_unit2014_highlighting=error resharper_x_unit2015_highlighting=warning resharper_x_unit2016_highlighting=error resharper_x_unit2017_highlighting=warning resharper_x_unit2018_highlighting=warning resharper_x_unit2019_highlighting=none resharper_x_unit3000_highlighting=error resharper_x_unit3001_highlighting=error [{*.har,*.jsb2,*.jsb3,*.json,.babelrc,.eslintrc,.stylelintrc,bowerrc,jest.config}] indent_style=space indent_size=2 [*.scss] indent_style=space indent_size=2 [*.js.map] indent_style=space indent_size=2 [*.{appxmanifest,asax,ascx,aspx,build,cs,cshtml,dtd,master,nuspec,razor,resw,resx,skin,vb,xaml,xamlx,xoml,xsd}] indent_style=space indent_size=4 tab_width=4 ================================================ FILE: .gitattributes ================================================ ############################################################################### # Set default behavior to automatically normalize line endings. ############################################################################### * text=auto ############################################################################### # Set default behavior for command prompt diff. # # This is need for earlier builds of msysgit that does not have it on by # default for csharp files. # Note: This is only used by command line ############################################################################### #*.cs diff=csharp ############################################################################### # Set the merge driver for project and solution files # # Merging from the command prompt will add diff markers to the files if there # are conflicts (Merging from VS is not affected by the settings below, in VS # the diff markers are never inserted). Diff markers may cause the following # file extensions to fail to load in VS. An alternative would be to treat # these files as binary and thus will always conflict and require user # intervention with every merge. To do so, just uncomment the entries below ############################################################################### #*.sln merge=binary #*.csproj merge=binary #*.vbproj merge=binary #*.vcxproj merge=binary #*.vcproj merge=binary #*.dbproj merge=binary #*.fsproj merge=binary #*.lsproj merge=binary #*.wixproj merge=binary #*.modelproj merge=binary #*.sqlproj merge=binary #*.wwaproj merge=binary ############################################################################### # behavior for image files # # image files are treated as binary by default. ############################################################################### #*.jpg binary #*.png binary #*.gif binary ############################################################################### # diff behavior for common document formats # # Convert binary document formats to text before diffing them. This feature # is only available from the command line. Turn it on by uncommenting the # entries below. ############################################################################### #*.doc diff=astextplain #*.DOC diff=astextplain #*.docx diff=astextplain #*.DOCX diff=astextplain #*.dot diff=astextplain #*.DOT diff=astextplain #*.pdf diff=astextplain #*.PDF diff=astextplain #*.rtf diff=astextplain #*.RTF diff=astextplain ================================================ FILE: .github/CONTRIBUTING.md ================================================ # How to contribute The easiest way to contribute is to open an issue and start a discussion. Then we can decide if and how a feature or a change could be implemented and if you should submit a pull requests with code changes. Also read this first: [Being a good open source citizen](https://hackernoon.com/being-a-good-open-source-citizen-9060d0ab9732#.x3hocgw85) ## Found an issue or a bug? Please start a discussion on the [core repo issue tracker](https://github.com/alexhiggins732/IdentityServer4/issues). ## Filing issues The best way to get your bug fixed is to be as detailed as you can be about the problem. Providing a minimal project with steps to reproduce the problem is ideal. Here are questions you can answer before you file a bug to make sure you're not missing any important information. 1. Did you read the [documentation](https://identityserver8.readthedocs.io/en/latest/)? 2. Did you include the snippet of broken code in the issue? 3. What are the *EXACT* steps to reproduce this problem? 4. Did you enable [logging](https://identityserver8.readthedocs.io/en/latest/topics/logging.html)? GitHub supports [markdown](http://github.github.com/github-flavored-markdown/), so when filing bugs make sure you check the formatting before clicking submit. ## Contributing code and content You will need to sign a contributor license agreement (CLA) before submitting your pull request. The first time you submit a PR, a bot will take you through that process. Please make sure to include tests, that cover the changes/additions you made to the code base. Make sure you can build the code. Familiarize yourself with the project workflow and our coding conventions. If you don't know what a pull request is read this article: https://help.github.com/articles/using-pull-requests. Before submitting a feature or substantial code contribution please discuss it with the team and ensure it follows the product roadmap. Here's a list of blog posts that are worth reading before doing a pull request: * [Open Source Contribution Etiquette](http://tirania.org/blog/archive/2010/Dec-31.html) by Miguel de Icaza * [Don't "Push" Your Pull Requests](http://www.igvita.com/2011/12/19/dont-push-your-pull-requests/) by Ilya Grigorik. * [10 tips for better Pull Requests](http://blog.ploeh.dk/2015/01/15/10-tips-for-better-pull-requests/) by Mark Seemann * [How to write the perfect pull request](https://github.com/blog/1943-how-to-write-the-perfect-pull-request) by GitHub ================================================ FILE: .github/FUNDING.yml ================================================ # These are supported funding model platforms github: alexhiggins732 patreon: alexhiggins732 open_collective: # Replace with a single Open Collective username ko_fi: # Replace with a single Ko-fi username tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry liberapay: # Replace with a single Liberapay username issuehunt: # Replace with a single IssueHunt username otechie: # Replace with a single Otechie username custom: https://www.paypal.me/alexhiggins732 ================================================ FILE: .github/ISSUE_TEMPLATE/Question.md ================================================ --- name: Question about: Ask a question. title: '' labels: question assignees: skoruba --- ### Question ### Minimal working example ```csharp // ``` ### Relevant parts of the log file ``` ``` ================================================ FILE: .github/ISSUE_TEMPLATE/bug_report.md ================================================ --- name: Bug report about: Create a report to help us improve title: '' labels: bug report --- ### Describe the bug A clear and concise description of what the bug is. ### To Reproduce Steps to reproduce the behavior: ### Relevant parts of the log file ``` ``` ================================================ FILE: .github/ISSUE_TEMPLATE/feature_request.md ================================================ --- name: Feature request about: Suggest an idea for this project title: '' labels: enhancement --- **Is your feature request related to a problem? Please describe.** A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] **Describe the solution you'd like** A clear and concise description of what you want to happen. **Describe alternatives you've considered** A clear and concise description of any alternative solutions or features you've considered. **Additional context** Add any other context or screenshots about the feature request here. ================================================ FILE: .github/PULL_REQUEST_TEMPLATE.md ================================================ --- name: Bug report about: Create a report to help us improve labels: bug report --- **We can only help you if you are on the latest version.** Please only use the issue tracker for bug reports and/or feature requests. For general security questions, or free or commercial support options do __not__ use the issue tracker and instead see [here](http://identityserver8.readthedocs.io/en/latest/intro/support.html) for more details. For bug reports, include the relevant log files related to your issue. See here how to enable [logging](https://identityserver8.readthedocs.io/en/latest/topics/logging.html). Delete this line once you have. Finally, please keep the issue concise and to the point. If you paste in more code than the text for the issue you are reporting then we will most likely not read it. ### Issue / Steps to reproduce the problem ### Relevant parts of the log file ``` ``` ================================================ FILE: .github/dependabot.yml ================================================ # To get started with Dependabot version updates, you'll need to specify which # package ecosystems to update and where the package manifests are located. # Please see the documentation for all configuration options: # https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file version: 2 updates: - package-ecosystem: "nuget" # See documentation for possible values directory: "/" # Location of package manifests schedule: interval: "daily" open-pull-requests-limit: 25 ================================================ FILE: .github/workflows/codeql.yml ================================================ # For most projects, this workflow file will not need changing; you simply need # to commit it to your repository. # # You may wish to alter this file to override the set of languages analyzed, # or to provide custom queries or build logic. # # ******** NOTE ******** # We have attempted to detect the languages in your repository. Please check # the `language` matrix defined below to confirm you have the correct set of # supported CodeQL languages. # name: "CodeQL" on: push: branches: [ "master", "develop", "release/*" ] paths-ignore: - '**/README.md' - '**/docs' - '.github/**' - "docs/**" - ".git/*" - ".vs/*" - ".config/*" - ".github/*" - "Directory.Build.props" - "Directory.Build.targets" - "Directory.Build.props" - "docker-compose.yml" - "docker-compose.override.yml" - "docker-compose.vs.debug.yml" - "docker-compose.vs.release.yml" - "docker-compose.dcrpoj" - "**/*.sln" - "global.json" - "IdentityServer8.DotNet.ruleset" - "LICENSCE" - "version.json" - "Nuget.config" - "SECURITY.md" - "SPONSORS.md" - "README.md" - "samples" - "nuget" pull_request: branches: [ "master", "develop", "release/*" ] schedule: - cron: '23 4 * * 1' jobs: analyze: name: Analyze # Runner size impacts CodeQL analysis time. To learn more, please see: # - https://gh.io/recommended-hardware-resources-for-running-codeql # - https://gh.io/supported-runners-and-hardware-resources # - https://gh.io/using-larger-runners # Consider using larger runners for possible analysis time improvements. runs-on: ${{ (matrix.language == 'swift' && 'macos-latest') || 'ubuntu-latest' }} timeout-minutes: ${{ (matrix.language == 'swift' && 120) || 360 }} permissions: # required for all workflows security-events: write # only required for workflows in private repositories actions: read contents: read strategy: fail-fast: false matrix: language: [ 'csharp', 'javascript-typescript' ] # CodeQL supports [ 'c-cpp', 'csharp', 'go', 'java-kotlin', 'javascript-typescript', 'python', 'ruby', 'swift' ] # Use only 'java-kotlin' to analyze code written in Java, Kotlin or both # Use only 'javascript-typescript' to analyze code written in JavaScript, TypeScript or both # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support steps: - name: Checkout repository uses: actions/checkout@v4 # Initializes the CodeQL tools for scanning. - name: Initialize CodeQL uses: github/codeql-action/init@v3 with: languages: ${{ matrix.language }} # If you wish to specify custom queries, you can do so here or in a config file. # By default, queries listed here will override any specified in a config file. # Prefix the list here with "+" to use these queries and those in the config file. # For more details on CodeQL's query packs, refer to: https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs # queries: security-extended,security-and-quality # Autobuild attempts to build any compiled languages (C/C++, C#, Go, Java, or Swift). # If this step fails, then you should remove it and run the build manually (see below) #- name: Autobuild # uses: github/codeql-action/autobuild@v3 # ℹ️ Command-line programs to run using the OS shell. # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun # If the Autobuild fails above, remove it and uncomment the following three lines. # modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance. - name: Restore dependencies if: ${{ (matrix.language == 'csharp') }} run: dotnet restore src/IdentityServer8.sln - name: Build if: ${{ (matrix.language == 'csharp') }} run: dotnet build src/IdentityServer8.sln --configuration Release --no-restore - name: Perform CodeQL Analysis uses: github/codeql-action/analyze@v3 with: category: "/language:${{matrix.language}}" ================================================ FILE: .github/workflows/develop.yml ================================================ # This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: Develop on: push: branches: - develop paths-ignore: - '**/README.md' - '**/docs' - '.github/**' - "docs/**" - ".git/*" - ".vs/*" - ".config/*" - ".github/*" - "Directory.Build.props" - "Directory.Build.targets" - "Directory.Build.props" - "docker-compose.yml" - "docker-compose.override.yml" - "docker-compose.vs.debug.yml" - "docker-compose.vs.release.yml" - "docker-compose.dcrpoj" - "**/*.sln" - "global.json" - "IdentityServer8.DotNet.ruleset" - "LICENSCE" - "Nuget.config" - "SECURITY.md" - "SPONSORS.md" - "README.md" - "samples" - "nuget" jobs: build: strategy: fail-fast: false matrix: runs-on: [macOS-latest, ubuntu-latest, windows-latest] name: ${{ matrix.runs-on }} runs-on: ${{ matrix.runs-on }} steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 with: dotnet-version: 8.0.x - uses: dotnet/nbgv@master id: nbgv - name: Display Package Version run: echo "PackageVersion=${{ steps.nbgv.outputs.SemVer2 }}" - name: Restore dependencies run: dotnet restore src/IdentityServer8.sln - name: Build run: dotnet build src/IdentityServer8.sln --configuration Release --no-restore -p:Version=${{ steps.nbgv.outputs.SemVer2 }} - name: Test run: dotnet test src/IdentityServer8.sln --configuration Release --no-build --verbosity normal /p:CollectCoverage=true --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura - name: Upload coverage reports to Codecov uses: codecov/codecov-action@v4.0.1 env: token: ${{ secrets.CODECOV_TOKEN }} slug: alexhiggins732/IdentityServer8 CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - name: Push if: ${{ (github.event_name == 'push') && (runner.os == 'Windows') }} run: dotnet nuget push .\nuget\*.nupkg --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} ================================================ FILE: .github/workflows/master.yml ================================================ # This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: Master on: push: branches: - master paths-ignore: - '**/README.md' - '**/docs' - '.github/**' - "docs/**" - ".git/*" - ".vs/*" - ".config/*" - ".github/*" - "Directory.Build.props" - "Directory.Build.targets" - "Directory.Build.props" - "docker-compose.yml" - "docker-compose.override.yml" - "docker-compose.vs.debug.yml" - "docker-compose.vs.release.yml" - "docker-compose.dcrpoj" - "**/*.sln" - "global.json" - "IdentityServer8.DotNet.ruleset" - "LICENSCE" - "Nuget.config" - "SECURITY.md" - "SPONSORS.md" - "README.md" - "samples" - "nuget" jobs: build: strategy: fail-fast: false matrix: runs-on: [macOS-latest, ubuntu-latest, windows-latest] name: ${{ matrix.runs-on }} runs-on: ${{ matrix.runs-on }} steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 with: dotnet-version: 8.0.x - uses: dotnet/nbgv@master id: nbgv - name: Display Package Version run: echo "PackageVersion=${{ steps.nbgv.outputs.SimpleVersion }}" - name: Restore dependencies run: dotnet restore src/IdentityServer8.sln - name: Build run: dotnet build src/IdentityServer8.sln --configuration Release --no-restore -p:Version=${{ steps.nbgv.outputs.SimpleVersion }} - name: Test run: dotnet test src/IdentityServer8.sln --configuration Release --no-build --verbosity normal /p:CollectCoverage=true --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura - name: Upload coverage reports to Codecov uses: codecov/codecov-action@v4.0.1 env: token: ${{ secrets.CODECOV_TOKEN }} slug: alexhiggins732/IdentityServer8 CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - name: Push if: ${{ (github.event_name == 'push') && (runner.os == 'Windows') }} run: dotnet nuget push .\nuget\*.nupkg --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} ================================================ FILE: .github/workflows/pre-release.yml ================================================ # This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: CI on: push: branches-ignore: - develop - release/* - master paths-ignore: - '**/README.md' - '**/docs' - '.github/**' - "docs/**" - ".git/*" - ".vs/*" - ".config/*" - ".github/*" - "Directory.Build.props" - "Directory.Build.targets" - "Directory.Build.props" - "docker-compose.yml" - "docker-compose.override.yml" - "docker-compose.vs.debug.yml" - "docker-compose.vs.release.yml" - "docker-compose.dcrpoj" - "**/*.sln" - "global.json" - "IdentityServer8.DotNet.ruleset" - "LICENSCE" - "Nuget.config" - "SECURITY.md" - "SPONSORS.md" - "README.md" - "samples" - "nuget" jobs: build: strategy: fail-fast: false matrix: runs-on: [macOS-latest, ubuntu-latest, windows-latest] name: ${{ matrix.runs-on }} runs-on: ${{ matrix.runs-on }} steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 with: dotnet-version: 8.0.x - uses: dotnet/nbgv@master id: nbgv - name: Display Package Version run: echo "PackageVersion=${{ steps.nbgv.outputs.SimpleVersion }}-ci.${{ steps.nbgv.outputs.VersionRevision }}" - name: Restore dependencies run: dotnet restore src/IdentityServer8.sln - name: Build run: dotnet build src/IdentityServer8.sln --configuration Release --no-restore -p:Version=${{ steps.nbgv.outputs.SimpleVersion }}-ci.${{ steps.nbgv.outputs.VersionRevision }} - name: Test run: dotnet test src/IdentityServer8.sln --configuration Release --no-build --verbosity normal /p:CollectCoverage=true --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura - name: Upload coverage reports to Codecov uses: codecov/codecov-action@v4.0.1 env: token: ${{ secrets.CODECOV_TOKEN }} slug: alexhiggins732/IdentityServer8 CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} ================================================ FILE: .github/workflows/release.yml ================================================ # This workflow will build a .NET project # For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-net name: Release on: push: branches: - release/* paths-ignore: - '**/README.md' - '**/docs' - '.github/**' - "docs/**" - ".git/*" - ".vs/*" - ".config/*" - ".github/*" - "Directory.Build.props" - "Directory.Build.targets" - "Directory.Build.props" - "docker-compose.yml" - "docker-compose.override.yml" - "docker-compose.vs.debug.yml" - "docker-compose.vs.release.yml" - "docker-compose.dcrpoj" - "**/*.sln" - "global.json" - "IdentityServer8.DotNet.ruleset" - "LICENSCE" - "Nuget.config" - "SECURITY.md" - "SPONSORS.md" - "README.md" - "samples" - "nuget" jobs: build: strategy: fail-fast: false matrix: runs-on: [macOS-latest, ubuntu-latest, windows-latest] name: ${{ matrix.runs-on }} runs-on: ${{ matrix.runs-on }} steps: - uses: actions/checkout@v3 with: fetch-depth: 0 - name: Setup .NET uses: actions/setup-dotnet@v3 with: dotnet-version: 8.0.x - uses: dotnet/nbgv@master id: nbgv - name: Display Package Version run: echo "PackageVersion=${{ steps.nbgv.outputs.SemVer2 }}" - name: Restore dependencies run: dotnet restore src/IdentityServer8.sln - name: Build run: dotnet build src/IdentityServer8.sln --configuration Release --no-restore -p:Version=${{ steps.nbgv.outputs.SemVer2 }} - name: Test run: dotnet test src/IdentityServer8.sln --configuration Release --no-build --verbosity normal /p:CollectCoverage=true --collect:"XPlat Code Coverage" -- DataCollectionRunSettings.DataCollectors.DataCollector.Configuration.Format=cobertura - name: Upload coverage reports to Codecov uses: codecov/codecov-action@v4.0.1 env: token: ${{ secrets.CODECOV_TOKEN }} slug: alexhiggins732/IdentityServer8 CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} - name: Push if: ${{ (github.event_name == 'push') && (runner.os == 'Windows') }} run: dotnet nuget push .\nuget\*.nupkg --skip-duplicate --source https://api.nuget.org/v3/index.json --api-key ${{ secrets.NUGET_API_KEY }} ================================================ FILE: .gitignore ================================================ ## Ignore Visual Studio temporary files, build results, and ## files generated by popular Visual Studio add-ons. # Rider .idea # User-specific files *.suo *.user *.userosscache *.sln.docstates # User-specific files (MonoDevelop/Xamarin Studio) *.userprefs # Build results [Dd]ebug/ [Dd]ebugPublic/ [Rr]elease/ [Rr]eleases/ x64/ x86/ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ # Visual Studio cache/options directory .vs/ project.lock.json # Uncomment if you have tasks that create the project's static files in wwwroot #wwwroot/ # MSTest test Results [Tt]est[Rr]esult*/ [Bb]uild[Ll]og.* # NUNIT *.VisualState.xml TestResult.xml # Build Results of an ATL Project [Dd]ebugPS/ [Rr]eleasePS/ dlldata.c # DNX project.lock.json project.fragment.lock.json artifacts/ Properties/launchSettings.json *_i.c *_p.c *_i.h *.ilk *.meta *.obj *.pch *.pdb *.pgc *.pgd *.rsp *.sbr *.tlb *.tli *.tlh *.tmp *.tmp_proj *.log *.vspscc *.vssscc .builds *.pidb *.svclog *.scc # Chutzpah Test files _Chutzpah* # Visual C++ cache files ipch/ *.aps *.ncb *.opendb *.opensdf *.sdf *.cachefile *.VC.db *.VC.VC.opendb # Visual Studio profiler *.psess *.vsp *.vspx *.sap # TFS 2012 Local Workspace $tf/ # Guidance Automation Toolkit *.gpState # ReSharper is a .NET coding add-in _ReSharper*/ *.[Rr]e[Ss]harper *.DotSettings.user # JustCode is a .NET coding add-in .JustCode # TeamCity is a build add-in _TeamCity* # DotCover is a Code Coverage Tool *.dotCover # Visual Studio code coverage results *.coverage *.coveragexml # NCrunch _NCrunch_* .*crunch*.local.xml nCrunchTemp_* # MightyMoose *.mm.* AutoTest.Net/ # Web workbench (sass) .sass-cache/ # Installshield output folder [Ee]xpress/ # DocProject is a documentation generator add-in DocProject/buildhelp/ DocProject/Help/*.HxT DocProject/Help/*.HxC DocProject/Help/*.hhc DocProject/Help/*.hhk DocProject/Help/*.hhp DocProject/Help/Html2 DocProject/Help/html # Click-Once directory publish/ # Publish Web Output *.[Pp]ublish.xml *.azurePubxml # TODO: Comment the next line if you want to checkin your web deploy settings # but database connection strings (with potential passwords) will be unencrypted *.pubxml *.publishproj # Microsoft Azure Web App publish settings. Comment the next line if you want to # checkin your Azure Web App publish settings, but sensitive information contained # in these scripts will be unencrypted PublishScripts/ # NuGet Packages *.nupkg # The packages folder can be ignored because of Package Restore **/packages/* # except build/, which is used as an MSBuild target. !**/packages/build/ # Uncomment if necessary however generally it will be regenerated when needed #!**/packages/repositories.config # NuGet v3's project.json files produces more ignoreable files *.nuget.props *.nuget.targets # Microsoft Azure Build Output csx/ *.build.csdef # Microsoft Azure Emulator ecf/ rcf/ # Windows Store app package directories and files AppPackages/ BundleArtifacts/ Package.StoreAssociation.xml _pkginfo.txt # Visual Studio cache files # files ending in .cache can be ignored *.[Cc]ache # but keep track of directories ending in .cache !*.[Cc]ache/ # Others ClientBin/ ~$* *~ *.dbmdl *.dbproj.schemaview *.jfm *.pfx *.publishsettings node_modules/ bower_components/ orleans.codegen.cs # RIA/Silverlight projects Generated_Code/ # Backup & report files from converting an old project file # to a newer Visual Studio version. Backup files are not needed, # because we have git ;-) _UpgradeReport_Files/ Backup*/ UpgradeLog*.XML UpgradeLog*.htm # SQL Server files *.mdf *.ldf # Business Intelligence projects *.rdl.data *.bim.layout *.bim_*.settings # Microsoft Fakes FakesAssemblies/ # GhostDoc plugin setting file *.GhostDoc.xml # Node.js Tools for Visual Studio .ntvs_analysis.dat # Visual Studio 6 build log *.plg # Visual Studio 6 workspace options file *.opt docs/_build/ # Local .NET CLI tools tools/ # Visual Studio Code workspace options .vscode # IdentityServer temp files IdentityServer8_log.txt tempkey.rsa samples/KeyManagement/FileSystem/dataprotectionkeys/ samples/KeyManagement/FileSystem/signingkeys/ workspace.xml src/IdentityServer8/host/identityserver.db tempkey.jwk /nuget # Paket dependency manager .paket/paket.exe paket-files/ # FAKE - F# Make .fake/ # JetBrains Rider .idea/ *.sln.iml # CodeRush .cr/ # Python Tools for Visual Studio (PTVS) __pycache__/ *.pyc # Cake - Uncomment if you are using it # tools/ /src/IdentityServer8.Admin/appsettings.production.json /src/IdentityServer8.Admin/Scripts/Libs/ /src/IdentityServer8.Admin/Data/Migrations/ # Don't ignore these log folders !/src/IdentityServer8.Admin.UI/Resources/Views/Log/ !/src/IdentityServer8.Admin.BusinessLogic/Dtos/Log/ !**/Views/Log/ !/src/IdentityServer8.Admin.BusinessLogic/Events/Log/ /src/IdentityServer8.Admin.Api/appsettings.Production.json /shared/nginx/certs/ lib/ ================================================ FILE: .readthedocs.yaml ================================================ # .readthedocs.yaml # Read the Docs configuration file # See https://docs.readthedocs.io/en/stable/config-file/v2.html for details # Required version: 2 # Set the OS, Python version and other tools you might need build: os: ubuntu-22.04 tools: python: "3.12" # You can also specify other tool versions: # nodejs: "19" # rust: "1.64" # golang: "1.19" # Build documentation in the "docs/" directory with Sphinx sphinx: configuration: docs/conf.py # Optionally build your docs in additional formats such as PDF and ePub # formats: # - pdf # - epub # Optional but recommended, declare the Python requirements required # to build your documentation # See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html python: install: - requirements: docs/requirements.txt ================================================ FILE: Directory.Build.props ================================================ net8.0 8.0.4 8.0.4 HigginsSoft.$(MSBuildProjectName) $(MSBuildProjectName) enable LICENSE false $(NoWarn);CS0618;SYSLIB0023;SYSLIB0020;EF1001 true $(SolutionDir)../key.snk OpenID Connect and OAuth 2.0 Framework for ASP.NET Core Copyright 2024 HigginsSoft. Alexander Higgins HigginsSoft, Alexander Higgins, Brock Allen, Dominick Baier OAuth2 OAuth 2.0 OpenID Connect Security Identity IdentityServer Admin IdentityServer8 OpenIDConnect https://github.com/alexhiggins732/IdentityServer8 git https://github.com/alexhiggins732/IdentityServer8/releases true $(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb icon.jpg true false false true true Enable latest false false $(SolutionDir)../nuget false false README.md true portable true snupkg true True \ True \ True \ ================================================ FILE: Directory.Build.targets ================================================ ================================================ FILE: Directory.Packages.props ================================================ true true 8.0.0 8.0.1 8.0.0 8.0.0 8.0.0 8.0.0-preview.2.23619.3 2.59.0 8.0.0 $(NoWarn);AD0001;ASP0003;ASP0004;ASP0005;ASP0007;ASP0020;ASP0021;ASP0022;ASP0024 true runtime; build; native; contentfiles; analyzers; buildtransitive all all runtime; build; native; contentfiles; analyzers; buildtransitive all runtime; build; native; contentfiles; analyzers; buildtransitive runtime; build; native; contentfiles; analyzers; buildtransitive all ================================================ FILE: GitReleaseManager.yaml ================================================ create: include-footer: false footer-heading: footer-content: footer-includes-milestone: false milestone-replace-text: export: include-created-date-in-title: false created-date-string-format: perform-regex-removal: false regex-text: multiline-regex: false issue-labels-include: - bug - new feature - enhancement - breaking change issue-labels-exclude: - Internal Refactoring ================================================ FILE: IdentityServer8.DotNet.ruleset ================================================  ================================================ FILE: LICENSE ================================================ Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2018, Brock Allen, Dominick Baier Copyright 2024, HigginsSoft, Alexander Higgins Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ================================================ FILE: LicenseHeader.txt ================================================ /* Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved. Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. Source code and license this software can be found The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. */ ================================================ FILE: NuGet.config ================================================ ================================================ FILE: README.md ================================================ # Identity Server 8 update This project is a DotNet 8 revival of the Identity Server 4 and Identity Server 4 Admin UI, for Open ID Connect (OIDC) and OAuth, which was archived when .NET Core 3.1 reached end of support. The latest verion, 8.0.4, is now available on NuGet. It contains [hundreds of security and bug fixes](https://github.com/alexhiggins732/IdentityServer8/blob/master/docs/CHANGELOG.md) from the original Identity Server 4 project. It is recommend you update all previous version, 4 or 8, to the latest version to ensure you have the latest security updates. - [Documentation](http://identityserver8.readthedocs.io/) - [Support](https://identityserver8.readthedocs.io/en/latest/into/support.html) - [Gitter Chat](https://app.gitter.im/#/room/#identityserver8:gitter.im) [HigginsSoft.IdentityServer8 and Admin UI Nuget Packages](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8) are available here for use in DotNet 8. All new development in the archived repository has moved to a paid commercial version in the [Duende Software](https://github.com/duendesoftware) organization. See [here](https://duendesoftware.com/products/identityserver) for more details on the commerica version. This repository will be maintained for bug fixes and security updates for the .NET 8 version of Identity Server 4. The source code and unit tests will be updated to use the latest .NET 8 features and best practices. Once the source code and unit tests are stabilized, the documentation will be updated to reflect the changes. General speaking, the existing documentation for Identity Server 4 will be valid for this repository, but the new features and changes will be documented in the new documentation. In the meantime, NuGet packages will be published to the [IdentityServer8 NuGet feed](https://www.nuget.org/profiles/IdentityServer8) and the [IdentityServer8 MyGet feed](https://www.myget.org/F/identityserver8/api/v3/index.json). ## Build Status And Stats [![Master | Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/master.yml/badge.svg)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/master.yml) [![Release|Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/release.yml/badge.svg)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/release.yml) [![Develop|Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/develop.yml/badge.svg)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/develop.yml) [![CI/CD|Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/pre-release.yml/badge.svg)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/pre-release.yml) ## Code Coverage [![Master | Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/master.yml/badge.svg)](https://img.shields.io/codecov/c/github/alexhiggins732/identityserver8) [![Master|CodeQL](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/codeql.yml/badge.svg)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/codeql.yml) [![Develop|Build](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/develop.yml/badge.svg)](https://img.shields.io/codecov/c/github/alexhiggins732/identityserver8/tree/develop) [![Master|CodeQL](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/codeql.yml/badge.svg?branch=develop)](https://github.com/alexhiggins732/IdentityServer8/actions/workflows/codeql.yml?branch=develop) ## Documentation [![Documentation Status](https://readthedocs.org/projects/identityserver8/badge/?version=latest)](https://identityserver8.readthedocs.io/en/latest/?badge=latest) [Read the docs - identityserver8.readthedocs.io ](http://identityserver8.readthedocs.io/) ## Nuget Packages ### Identity Server 8 |Package|| | ------------- | ------------- | |[HigginsSoft.IdentityServer8](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8)| |[HigginsSoft.IdentityServer8.Storage](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Storage)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Storage)| |[HigginsSoft.IdentityServer8.EntityFramework](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.EntityFramework)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.EntityFramework)| |[HigginsSoft.IdentityServer8.EntityFramework.Storage](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.EntityFramework.Storage)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.EntityFramework.Storage)| |[HigginsSoft.IdentityServer8.AspNetIdentity](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.AspNetIdentity)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.AspNetIdentity)| | | | ### Identity Server 8 Administration UI |Package|| | ------------- | ------------- | |[HigginsSoft.IdentityServer8.Shared](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Shared)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Shared)| |[HigginsSoft.IdentityServer8.Admin.UI](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.UI)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.UI)| |[HigginsSoft.IdentityServer8.Shared.Configuration](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Shared.Configuration)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Shared.Configuration)| |[HigginsSoft.IdentityServer8.Admin.Api](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.Api)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.Api)| |[HigginsSoft.IdentityServer8.Admin](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin)| |[HigginsSoft.IdentityServer8.Admin.BusinessLogic.Identity](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.BusinessLogic.Identity)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.BusinessLogic.Identity)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.Identity](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.Identity)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.Identity)| |[HigginsSoft.IdentityServer8.Admin.BusinessLogic.Shared](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.BusinessLogic.Shared)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.BusinessLogic.Shared)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.Extensions](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.Extensions)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.Extensions)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.PostgreSQL](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.PostgreSQL)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.PostgreSQL)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.MySql](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.MySql)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.MySql)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.SqlServer](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.SqlServer)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.SqlServer)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.Shared](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.Shared)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.Shared)| |[HigginsSoft.IdentityServer8.Admin.BusinessLogic](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.BusinessLogic)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.BusinessLogic)| |[HigginsSoft.IdentityServer8.Admin.EntityFramework.Configuration](https://www.nuget.org/packages?q=HigginsSoft.IdentityServer8.Admin.EntityFramework.Configuration)|![NuGet Downloads](https://img.shields.io/nuget/dt/HigginsSoft.IdentityServer8.Admin.EntityFramework.Configuration)| | | | ## What's New View the [CHANGELOG](docs/CHANGELOG.md) for the latest changes. ## About IdentityServer8 [](https://dotnetfoundation.org/projects?searchquery=IdentityServer&type=project) IdentityServer is a free, open source [OpenID Connect](http://openid.net/connect/) and [OAuth 2.0](https://tools.ietf.org/html/rfc6749) framework for ASP.NET Core. Founded and maintained by [Dominick Baier](https://twitter.com/leastprivilege) and [Brock Allen](https://twitter.com/brocklallen), IdentityServer8 incorporates all the protocol implementations and extensibility points needed to integrate token-based authentication, single-sign-on and API access control in your applications. IdentityServer8 is officially [certified](https://openid.net/certification/) by the [OpenID Foundation](https://openid.net) and thus spec-compliant and interoperable. It is part of the [.NET Foundation](https://www.dotnetfoundation.org/), and operates under their [code of conduct](https://www.dotnetfoundation.org/code-of-conduct). It is licensed under [Apache 2](https://opensource.org/licenses/Apache-2.0) (an OSI approved license). For project documentation, please visit [readthedocs](https://IdentityServer8.readthedocs.io). ## Branch structure Active development happens on the main branch. This always contains the latest version. Each (pre-) release is tagged with the corresponding version. The [aspnetcore1](https://github.com/alexhiggins732/IdentityServer8/tree/aspnetcore1) and [aspnetcore2](https://github.com/alexhiggins732/IdentityServer8/tree/aspnetcore2) branches contain the latest versions of the older ASP.NET Core based versions. ## How to build * [Install]([https://www.microsoft.com/net/download/core#/current](https://dotnet.microsoft.com/en-us/download#/current) the latest .NET 8 SDK * Install Git * Clone this repo * Run `dotnet build src/identityserver8.slm` or `build.sh` in the root of the cloned repo. ## Documentation For project documentation, please visit [readthedocs](https://IdentityServer8.readthedocs.io). See [here](http://docs.identityserver8.io/en/aspnetcore1/) for the 1.x docs, and [here](http://docs.identityserver8.io/en/aspnetcore2/) for the 2.x docs. ## Bug reports and feature requests Please use the [issue tracker](https://github.com/alexhiggins732/IdentityServer8/issues) for that. We only support the latest version for free. For older versions, you can get a commercial support agreement with us. ## Commercial and Community Support If you need help with implementing IdentityServer8 or your security architecture in general, there are both free and commercial support options. See [here](https://IdentityServer8.readthedocs.io/en/latest/intro/support.html) for more details. ## Sponsorship If you are a fan of the project or a company that relies on IdentityServer, you might want to consider sponsoring. This will help us devote more time to answering questions and doing feature development. If you are interested please head to our [Patreon](https://www.patreon.com/identityserver) page which has further details. ### Platinum Sponsors [](https://udelt.no) [](https://github.com/dotnet-at-microsoft) ### Corporate Sponsors [Ritter Insurance Marketing](https://www.ritterim.com) [ExtraNetUserManager](https://www.extranetusermanager.com/) [Knab](https://www.knab.nl/) You can see a list of our current sponsors [here](https://github.com/alexhiggins732/IdentityServer8/blob/main/SPONSORS.md) - and for companies we have some nice advertisement options as well. ## Acknowledgements IdentityServer8 is built using the following great open source projects and free services: * [ASP.NET Core](https://github.com/dotnet/aspnetcore) * [Bullseye](https://github.com/adamralph/bullseye) * [SimpleExec](https://github.com/adamralph/simple-exec) * [MinVer](https://github.com/adamralph/minver) * [Json.Net](http://www.newtonsoft.com/json) * [XUnit](https://xunit.github.io/) * [Fluent Assertions](http://www.fluentassertions.com/) * [GitReleaseManager](https://github.com/GitTools/GitReleaseManager) ..and last but not least a big thanks to all our [contributors](https://github.com/alexhiggins732/IdentityServer8/graphs/contributors)! ================================================ FILE: SECURITY.MD ================================================ # Reporting Security Issues If you discover a security issue in IdentityServer, please report it by sending an email to contact@identityserver8.io This will allow us to assess the risk, and make a fix available before we add a bug report to the GitHub repository. Thanks! ================================================ FILE: SPONSORS.md ================================================ # Sponsors We thank those who [support](https://www.patreon.com/identityserver) IdentityServer! ## Corporate ### Platinum [Udelt](https://udelt.no/) [Microsoft .NET](https://github.com/dotnet-at-microsoft) ### Gold [Ritter Insurance Marketing](https://www.ritterim.com) ([@RitterIM](https://twitter.com/ritterim)) [ExtranetUserManager](https://www.extranetusermanager.com) ([@eumgr](https://twitter.com/eumgr)) [Knab](https://www.knab.nl/) ([@knab_nl](https://twitter.com/knab_nl)) ### Silver Jacobus Roos Soluto ([@SolutoEng](https://twitter.com/SolutoEng)) Steinar Noem Effectory ([@effectory](https://twitter.com/effectory)) Real Page ([@RealPage](https://twitter.com/RealPage)) Justify ([@justify_legal](https://twitter.com/justify_legal)) ## Individuals Khalid Abuhakmeh ([@buhakmeh](https://twitter.com/buhakmeh)) Rasika Weliwita ([@rasikaweliwita](https://twitter.com/rasikaweliwita)) Arun David Shelly Tobias Höft ([@tobiashoeft](https://twitter.com/tobiashoeft)) William Grow James Roberts Chris Simmons ([@netchrisdotcom](https://twitter.com/netchrisdotcom)) Shawn Wildermuth Johan Boström ([@zarx](https://twitter.com/zarx)) Albert ([@DerAlbert](https://twitter.com/DerAlbert)) Hugo Biarge ([@hbiarge](https://twitter.com/hbiarge)) Ibrahim Šuta ([@ibrahimsuta](https://twitter.com/ibrahimsuta)) VIJAYA PAL NALLALA Martijn Boland Giuseppe Turitto Mauricio Schneider Norman L Covington Ryan Mendoza ([@elryry](https://twitter.com/elryry)) Colin Blair Erik Gulbrandsen Olga Klimova Alexandru Puiu Michael Calasanz Fredrik Karlsson ([@fredrik_zenit](https://twitter.com/fredrik_zenit)) Jeremy Sinclair ([@sinclairinator](https://twitter.com/sinclairinator)) Bruno Brito James Hough vanbukin ================================================ FILE: docker-compose.dcproj ================================================ 2.1 Linux f817047f-018d-4f93-bda5-58602073b634 None {Scheme}://localhost:{ServicePort} IdentityServer8.Admin docker-compose.yml docker-compose.yml docker-compose.yml ================================================ FILE: docker-compose.override.yml ================================================ version: '3.4' services: IdentityServer8.Admin: environment: - ASPNETCORE_ENVIRONMENT=Development volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro IdentityServer8.Admin.api: environment: - ASPNETCORE_ENVIRONMENT=Development volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro higginssoft.identityserver4.sts.identity: environment: - ASPNETCORE_ENVIRONMENT=Development volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro ================================================ FILE: docker-compose.vs.debug.yml ================================================ version: '3.4' services: IdentityServer8.Admin: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro labels: com.microsoft.visualstudio.debuggee.arguments: ' --additionalProbingPath /root/.nuget/packages --additionalProbingPath /root/.nuget/fallbackpackages "bin/Debug/net6.0/IdentityServer8.Admin.dll" /seed' IdentityServer8.Admin.api: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro higginssoft.identityserver4.sts.identity: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro ================================================ FILE: docker-compose.vs.release.yml ================================================ version: '3.4' services: IdentityServer8.Admin: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro labels: com.microsoft.visualstudio.debuggee.arguments: ' --additionalProbingPath /root/.nuget/packages --additionalProbingPath /root/.nuget/fallbackpackages "bin/Debug/net6.0/IdentityServer8.Admin.dll" /seed' IdentityServer8.Admin.api: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro higginssoft.identityserver4.sts.identity: volumes: - ${APPDATA}/Microsoft/UserSecrets:/root/.microsoft/usersecrets:ro ================================================ FILE: docker-compose.yml ================================================ version: '3.4' services: nginx-proxy: image: jwilder/nginx-proxy container_name: nginx ports: - '80:80' - '443:443' volumes: - '/var/run/docker.sock:/tmp/docker.sock:ro' - './shared/nginx/vhost.d:/etc/nginx/vhost.d' - './shared/nginx/certs:/etc/nginx/certs:ro' networks: proxy: null identityserverui: aliases: - sts.higginssoft.local - admin.higginssoft.local - admin-api.higginssoft.local restart: always IdentityServer8.Admin: image: '${DOCKER_REGISTRY-}higginssoft-identityserver4-admin' build: context: . dockerfile: src/IdentityServer8.Admin/Dockerfile container_name: higginssoft-identityserver4-admin environment: - VIRTUAL_HOST=admin.higginssoft.local - 'ConnectionStrings__ConfigurationDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__PersistedGrantDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__IdentityDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__AdminLogDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__AdminAuditLogDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__DataProtectionDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'AdminConfiguration__IdentityAdminBaseUrl=https://admin.higginssoft.local' - 'AdminConfiguration__IdentityAdminRedirectUri=https://admin.higginssoft.local/signin-oidc' - 'AdminConfiguration__IdentityServerBaseUrl=https://sts.higginssoft.local' - AdminConfiguration__RequireHttpsMetadata=false - 'IdentityServerData__Clients__0__ClientUri=https://admin.higginssoft.local' - 'IdentityServerData__Clients__0__RedirectUris__0=https://admin.higginssoft.local/signin-oidc' - 'IdentityServerData__Clients__0__FrontChannelLogoutUri=https://admin.higginssoft.local/signin-oidc' - 'IdentityServerData__Clients__0__PostLogoutRedirectUris__0=https://admin.higginssoft.local/signout-callback-oidc' - 'IdentityServerData__Clients__0__AllowedCorsOrigins__0=https://admin.higginssoft.local' - 'IdentityServerData__Clients__1__RedirectUris__0=https://admin-api.higginssoft.local/swagger/oauth2-redirect.html' - 'Serilog__WriteTo__1__Args__connectionString=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - DockerConfiguration__UpdateCaCertificate=true - ASPNETCORE_ENVIRONMENT=Development command: dotnet IdentityServer8.Admin.dll /seed depends_on: - db - higginssoft.identityserver4.sts.identity volumes: - './shared/serilog.json:/app/serilog.json' - './shared/identitydata.json:/app/identitydata.json' - './shared/identityserverdata.json:/app/identityserverdata.json' - './shared/nginx/certs/cacerts.crt:/usr/local/share/ca-certificates/cacerts.crt' networks: identityserverui: null IdentityServer8.Admin.api: image: '${DOCKER_REGISTRY-}higginssoft-identityserver4-admin-api' build: context: . dockerfile: src/IdentityServer8.Admin.Api/Dockerfile container_name: higginssoft-identityserver4-admin-api environment: - VIRTUAL_HOST=admin-api.higginssoft.local - AdminApiConfiguration__RequireHttpsMetadata=false - 'AdminApiConfiguration__ApiBaseUrl=https://admin-api.higginssoft.local' - 'AdminApiConfiguration__IdentityServerBaseUrl=https://sts.higginssoft.local' - 'ConnectionStrings__ConfigurationDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__PersistedGrantDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__IdentityDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__AdminLogDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__AdminAuditLogDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__DataProtectionDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - DockerConfiguration__UpdateCaCertificate=true - ASPNETCORE_ENVIRONMENT=Development volumes: - './shared/serilog.json:/app/serilog.json' - './shared/nginx/certs/cacerts.crt:/usr/local/share/ca-certificates/cacerts.crt' networks: identityserverui: null higginssoft.identityserver4.sts.identity: image: '${DOCKER_REGISTRY-}higginssoft-identityserver4-sts-identity' build: context: . dockerfile: src/IdentityServer8.STS.Identity/Dockerfile container_name: higginssoft-identityserver4-sts-identity environment: - VIRTUAL_HOST=sts.higginssoft.local - 'ConnectionStrings__ConfigurationDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__PersistedGrantDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__IdentityDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'ConnectionStrings__DataProtectionDbConnection=Server=db;Database=IdentityServer8Admin;User Id=sa;Password=${DB_PASSWORD:-Password_123};MultipleActiveResultSets=true' - 'AdminConfiguration__IdentityAdminBaseUrl=https://admin.higginssoft.local' - 'IdentityServerOptions__IssuerUri=https://sts.higginssoft.local' - IdentityServerOptions__Events__RaiseErrorEvents=true - IdentityServerOptions__Events__RaiseInformationEvents=true - IdentityServerOptions__Events__RaiseFailureEvents=true - IdentityServerOptions__Events__RaiseSuccessEvents=true - DockerConfiguration__UpdateCaCertificate=true - ASPNETCORE_ENVIRONMENT=Development depends_on: - db volumes: - './shared/serilog.json:/app/serilog.json' - './shared/nginx/certs/cacerts.crt:/usr/local/share/ca-certificates/cacerts.crt' networks: identityserverui: aliases: - sts.higginssoft.local db: image: 'mcr.microsoft.com/mssql/server:2017-CU20-ubuntu-16.04' ports: - '7900:1433' container_name: higginssoft-identityserver4-db environment: SA_PASSWORD: '${DB_PASSWORD:-Password_123}' ACCEPT_EULA: 'Y' volumes: - 'dbdata:/var/opt/mssql' networks: identityserverui: null volumes: dbdata: driver: local networks: proxy: driver: bridge identityserverui: driver: bridge ================================================ FILE: docs/CHANGELOG.md ================================================ # Change Log All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning 2](http://semver.org/). ## [Unreleased] - 2024-02-17 - Current templates and quickstarts being added to seperate template and quickstart repositories to continue previous version functionality. - DotNet tool to install template currently under development. - ## [8.0.4] - 2024-02-17 Identity Server 8.0.4 is a security release that addresses hundreds of security vulnerabilities in the IdentityServer8 code base. We recommend that you update to this version. - Fix over 100+ security vulnerabilities in the IdentityServer8 code base: - #17 Unsafe expansion of self-closing HTML tag - #18 URL redirection from remote source - #19 DOM text reinterpreted as HTML - #20 Incomplete string escaping or encoding - #21 Inefficient regular expression bug dependencies - #22 Bad HTML filtering regexp bug dependencies - #23 User-controlled bypass of sensitive method bug - #24 Unsafe jQuery plugins bug dependencies Additional the codebase has been refactored to use the latest DotNet 8 features and best practices. This includes refactroing in #25 and consolidation of reused code that remove some nearly 1 million lines of code from the base.: - Convert Top Level usings - Convert Implicit usings. - Samples use shared API and MVC projects to reduce code duplication and need to maintain dozens of copies of the same code. ## [8.0.3] - 2024-02-12 - Security Updates: Addtional priority critical security patches addressing issues outline in #9 and #10. - [Security: User-controlled bypass of sensitive method] - Login Controller and view have have explicit methods to handle login and cancel to address User-controlled bypass of sensitive method - [Security: Logging of user-controlled data] - Unsanitized user input could be used to forge logs and inject arbitrary commands, including server side includes, xss and sql injection into log files. - [Maitenance]: Removed over half a million lines of code from the orginal Identity Server 4 code base using packages and libaries. - This will allow for easier maintenance and updates to the code base. - Developrs can now focus on the core functionality of Identity Server 8 and use LibMan to manage client side packages and keep packages up to date. - Documentation Website: identityserver8.readthedocs.io has been created and is now the official documentation website for IdentityServer8 - Gitter: A Gitter chat room has been created for IdentityServer8. You can join the chat at https://app.gitter.im/#/room/#identityserver8:gitter.im - Framework Upgrade: Upgrade Samples, including Clients, Quickstarts, and Key Management, to use DotNet 8 sdk style. - [Quickstarts] (https://github.com/alexhiggins732/IdentityServer8/tree/master/samples/Quickstarts) - Updated Quickstart samples to use Dotnet 8 startup with implicit usings and minimal Api. - [Clients] (https://github.com/alexhiggins732/IdentityServer8/tree/master/samples/Clients) - Updated client samples to use Dotnet 8 startup with implicit usings and minimal Api. - [Key Management] (https://github.com/alexhiggins732/IdentityServer8/tree/master/samples/KeyManagement) - Updated Key management samples to use Dotnet 8 startup with implicit usings and minimal Api. Changed default Entity Framework storage to file system storage as original Key Management is a paid solution. Roadmap: Add DbContext implementation fof key management. - Client Side Packages: Client Side packages have now been ignored in source and are now installed using LibMan during the build process. This will allow for easier updates and management of client side packages. ## [8.0.2] - 2024-02-12 - Security Updates: Addtional priority critical security patches addressing issues outline in #9 and #10. ## [8.0.1] - 2024-02-10 - Security Update: High priority critical security patches addressing issues outline in #9 and #10. ### Added - `IdentityServer8.Security` nuget packages with services to sanitize user input including html, json, xml, javascript, scripts, urls, logs, css, and style sheets. ### Changed - [Account Login Controller] (https://github.com/alexhiggins732/IdentityServer8/issues/9) - [Account Login View] (https://github.com/alexhiggins732/IdentityServer8/issues/9) ### Fixed - [Security: User-controlled bypass of sensitive method] Login Controller and view have have explicit methods to handle login and cancel to address User-controlled bypass of sensitive method - [Security: Logging of user-controlled data] Unsanitized user input could be used to forge logs and inject arbitrary commands, including server side includes, xss and sql injection into log files. ## [8.0.1] - 2024-02-10 Updated build scripts to use Git Flow branching for SemVer2 compatible nuget packages. ### Added - CodeQl Security scanning - Dependabot Package scanning. ### Changed - [IdentityServer8 8.0.1 changes]https://github.com/alexhiggins732/IdentityServer8/pull/7) ### Fixed - Nuget Package version conflicts. ## [8.0.0] - 2024-02-09 ### Added Build scripts and readme documentation for initial port from Identity Server 4 and Identity Server 4 Admin ### Changed Upgraded Main Identity Server projects and Nuget packages to DotNet 8 ### Fixed - Changed mixed dependencies on `System.Text.Json` and `Newtonsoft.Json` to use `System.Text.Json` which resolved several bugs. - Change package dependencies and version requirements to run on the latest DotNet 8 packages, resolving many security vulnerablities. ================================================ FILE: docs/Makefile ================================================ # Makefile for Sphinx documentation # # You can set these variables from the command line. SPHINXOPTS = SPHINXBUILD = sphinx-build PAPER = BUILDDIR = _build # Internal variables. PAPEROPT_a4 = -D latex_paper_size=a4 PAPEROPT_letter = -D latex_paper_size=letter ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . # the i18n builder cannot share the environment and doctrees with the others I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . .PHONY: help help: @echo "Please use \`make ' where is one of" @echo " html to make standalone HTML files" @echo " dirhtml to make HTML files named index.html in directories" @echo " singlehtml to make a single large HTML file" @echo " pickle to make pickle files" @echo " json to make JSON files" @echo " htmlhelp to make HTML files and a HTML help project" @echo " qthelp to make HTML files and a qthelp project" @echo " applehelp to make an Apple Help Book" @echo " devhelp to make HTML files and a Devhelp project" @echo " epub to make an epub" @echo " epub3 to make an epub3" @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" @echo " latexpdf to make LaTeX files and run them through pdflatex" @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" @echo " text to make text files" @echo " man to make manual pages" @echo " texinfo to make Texinfo files" @echo " info to make Texinfo files and run them through makeinfo" @echo " gettext to make PO message catalogs" @echo " changes to make an overview of all changed/added/deprecated items" @echo " xml to make Docutils-native XML files" @echo " pseudoxml to make pseudoxml-XML files for display purposes" @echo " linkcheck to check all external links for integrity" @echo " doctest to run all doctests embedded in the documentation (if enabled)" @echo " coverage to run coverage check of the documentation (if enabled)" @echo " dummy to check syntax errors of document sources" .PHONY: clean clean: rm -rf $(BUILDDIR)/* .PHONY: html html: $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." .PHONY: dirhtml dirhtml: $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml @echo @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." .PHONY: singlehtml singlehtml: $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml @echo @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." .PHONY: pickle pickle: $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle @echo @echo "Build finished; now you can process the pickle files." .PHONY: json json: $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json @echo @echo "Build finished; now you can process the JSON files." .PHONY: htmlhelp htmlhelp: $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp @echo @echo "Build finished; now you can run HTML Help Workshop with the" \ ".hhp project file in $(BUILDDIR)/htmlhelp." .PHONY: qthelp qthelp: $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp @echo @echo "Build finished; now you can run "qcollectiongenerator" with the" \ ".qhcp project file in $(BUILDDIR)/qthelp, like this:" @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/IdentityServer8.qhcp" @echo "To view the help file:" @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/IdentityServer8.qhc" .PHONY: applehelp applehelp: $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp @echo @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." @echo "N.B. You won't be able to view it unless you put it in" \ "~/Library/Documentation/Help or install it in your application" \ "bundle." .PHONY: devhelp devhelp: $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp @echo @echo "Build finished." @echo "To view the help file:" @echo "# mkdir -p $$HOME/.local/share/devhelp/IdentityServer8" @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/IdentityServer8" @echo "# devhelp" .PHONY: epub epub: $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub @echo @echo "Build finished. The epub file is in $(BUILDDIR)/epub." .PHONY: epub3 epub3: $(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3 @echo @echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3." .PHONY: latex latex: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." @echo "Run \`make' in that directory to run these through (pdf)latex" \ "(use \`make latexpdf' here to do that automatically)." .PHONY: latexpdf latexpdf: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through pdflatex..." $(MAKE) -C $(BUILDDIR)/latex all-pdf @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: latexpdfja latexpdfja: $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex @echo "Running LaTeX files through platex and dvipdfmx..." $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." .PHONY: text text: $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text @echo @echo "Build finished. The text files are in $(BUILDDIR)/text." .PHONY: man man: $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man @echo @echo "Build finished. The manual pages are in $(BUILDDIR)/man." .PHONY: texinfo texinfo: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." @echo "Run \`make' in that directory to run these through makeinfo" \ "(use \`make info' here to do that automatically)." .PHONY: info info: $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo @echo "Running Texinfo files through makeinfo..." make -C $(BUILDDIR)/texinfo info @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." .PHONY: gettext gettext: $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale @echo @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." .PHONY: changes changes: $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes @echo @echo "The overview file is in $(BUILDDIR)/changes." .PHONY: linkcheck linkcheck: $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck @echo @echo "Link check complete; look for any errors in the above output " \ "or in $(BUILDDIR)/linkcheck/output.txt." .PHONY: doctest doctest: $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest @echo "Testing of doctests in the sources finished, look at the " \ "results in $(BUILDDIR)/doctest/output.txt." .PHONY: coverage coverage: $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage @echo "Testing of coverage in the sources finished, look at the " \ "results in $(BUILDDIR)/coverage/python.txt." .PHONY: xml xml: $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml @echo @echo "Build finished. The XML files are in $(BUILDDIR)/xml." .PHONY: pseudoxml pseudoxml: $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml @echo @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." .PHONY: dummy dummy: $(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy @echo @echo "Build finished. Dummy builder generates no files." ================================================ FILE: docs/autobuild.bat ================================================ sphinx-autobuild.exe . .\_build\html\ ================================================ FILE: docs/build-documentation.ps1 ================================================ .\docker-build.ps1 docker run --rm -v .:/docs sphinx-doc/sphinx_rtd_theme make html ================================================ FILE: docs/conf.py ================================================ #!/usr/bin/env python3 # -*- coding: utf-8 -*- # # IdentityServer8 documentation build configuration file, created by # sphinx-quickstart on Wed Jul 20 08:57:27 2016. # # This file is execfile()d with the current directory set to its # containing dir. # # Note that not all possible configuration values are present in this # autogenerated file. # # All configuration values have a default; values that are commented out # serve to show the default. # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # # import os # import sys # sys.path.insert(0, os.path.abspath('.')) # -- General configuration ------------------------------------------------ # If your documentation needs a minimal Sphinx version, state it here. # # needs_sphinx = '1.0' # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ 'sphinx_rtd_theme', ] # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] # markdown support #from recommonmark.parser import CommonMarkParser #source_parsers = { # '.md': CommonMarkParser, #} source_suffix = ['.rst'] # The encoding of source files. # # source_encoding = 'utf-8-sig' # The master toctree document. master_doc = 'index' # General information about the project. project = 'IdentityServer8' copyright = '2024 HigginsSoft, Alexander Higgins' author = 'Alexander Higgins' # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. # # The short X.Y version. version = '8.0.0' # The full version, including alpha/beta/rc tags. release = '8.0.4' # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. # # This is also used if you do content translation via gettext catalogs. # Usually you set "language" from the command line for these cases. language = None # There are two options for replacing |today|: either, you set today to some # non-false value, then it is used: # # today = '' # # Else, today_fmt is used as the format for a strftime call. # # today_fmt = '%B %d, %Y' # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store'] # The reST default role (used for this markup: `text`) to use for all # documents. # # default_role = None # If true, '()' will be appended to :func: etc. cross-reference text. # # add_function_parentheses = True # If true, the current module name will be prepended to all description # unit titles (such as .. function::). # # add_module_names = True # If true, sectionauthor and moduleauthor directives will be shown in the # output. They are ignored by default. # # show_authors = False # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'default' highlight_language = 'csharp' # A list of ignored prefixes for module index sorting. # modindex_common_prefix = [] # If true, keep warnings as "system message" paragraphs in the built documents. # keep_warnings = False # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False # -- Options for HTML output ---------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = 'sphinx_rtd_theme' # on_rtd is whether we are on readthedocs.org, this line of code grabbed from docs.readthedocs.org import os on_rtd = os.environ.get('READTHEDOCS', None) == 'True' if not on_rtd: # only import and set the theme if we're building docs locally # import sphinx_rtd_theme html_theme = 'sphinx_rtd_theme' # html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # otherwise, readthedocs.org uses their theme by default, so no need to specify it # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the # documentation. # # html_theme_options = {} # Add any paths that contain custom themes here, relative to this directory. # html_theme_path = [] # The name for this set of Sphinx documents. # " v documentation" by default. # # html_title = 'IdentityServer8 v1.0.0' # A shorter title for the navigation bar. Default is the same as html_title. # # html_short_title = None # The name of an image file (relative to this directory) to place at the top # of the sidebar. # # html_logo = None # The name of an image file (relative to this directory) to use as a favicon of # the docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 # pixels large. # html_favicon = 'favicon.ico' # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ['_static'] # Add any extra paths that contain custom files (such as robots.txt or # .htaccess) here, relative to this directory. These files are copied # directly to the root of the documentation. # # html_extra_path = [] # If not None, a 'Last updated on:' timestamp is inserted at every page # bottom, using the given strftime format. # The empty string is equivalent to '%b %d, %Y'. # # html_last_updated_fmt = None # If true, SmartyPants will be used to convert quotes and dashes to # typographically correct entities. # # html_use_smartypants = True # Custom sidebar templates, maps document names to template names. # # html_sidebars = {} # Additional templates that should be rendered to pages, maps page names to # template names. # # html_additional_pages = {} # If false, no module index is generated. # # html_domain_indices = True # If false, no index is generated. # # html_use_index = True # If true, the index is split into individual pages for each letter. # # html_split_index = False # If true, links to the reST sources are added to the pages. # # html_show_sourcelink = True # If true, "Created using Sphinx" is shown in the HTML footer. Default is True. # # html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. # # html_show_copyright = True # If true, an OpenSearch description file will be output, and all pages will # contain a tag referring to it. The value of this option must be the # base URL from which the finished HTML is served. # # html_use_opensearch = '' # This is the file name suffix for HTML files (e.g. ".xhtml"). # html_file_suffix = None # Language to be used for generating the HTML full-text search index. # Sphinx supports the following languages: # 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja' # 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr', 'zh' # # html_search_language = 'en' # A dictionary with options for the search language support, empty by default. # 'ja' uses this config value. # 'zh' user can custom change `jieba` dictionary path. # # html_search_options = {'type': 'default'} # The name of a javascript file (relative to the configuration directory) that # implements a search results scorer. If empty, the default will be used. # # html_search_scorer = 'scorer.js' # Output file base name for HTML help builder. htmlhelp_basename = 'IdentityServer8doc' # -- Options for LaTeX output --------------------------------------------- latex_elements = { # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', # Additional stuff for the LaTeX preamble. # # 'preamble': '', # Latex figure (float) alignment # # 'figure_align': 'htbp', } # Grouping the document tree into LaTeX files. List of tuples # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ (master_doc, 'IdentityServer8.tex', 'IdentityServer8 Documentation', 'HigginsSoft, Alexander Higgins', 'manual'), ] # The name of an image file (relative to this directory) to place at the top of # the title page. # # latex_logo = None # For "manual" documents, if this is true, then toplevel headings are parts, # not chapters. # # latex_use_parts = False # If true, show page references after internal links. # # latex_show_pagerefs = False # If true, show URL addresses after external links. # # latex_show_urls = False # Documents to append as an appendix to all manuals. # # latex_appendices = [] # It false, will not define \strong, \code, itleref, \crossref ... but only # \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added # packages. # # latex_keep_old_macro_names = True # If false, no module index is generated. # # latex_domain_indices = True # -- Options for manual page output --------------------------------------- # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ (master_doc, 'IdentityServer8', 'IdentityServer8 Documentation', [author], 1) ] # If true, show URL addresses after external links. # # man_show_urls = False # -- Options for Texinfo output ------------------------------------------- # Grouping the document tree into Texinfo files. List of tuples # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ (master_doc, 'IdentityServer8', 'IdentityServer8 Documentation', author, 'IdentityServer8', 'One line description of project.', 'Miscellaneous'), ] # Documents to append as an appendix to all manuals. # # texinfo_appendices = [] # If false, no module index is generated. # # texinfo_domain_indices = True # How to display URL addresses: 'footnote', 'no', or 'inline'. # # texinfo_show_urls = 'footnote' # If true, do not generate a @detailmenu in the "Top" node's menu. # # texinfo_no_detailmenu = False ================================================ FILE: docs/docker-build.ps1 ================================================ docker build -t sphinx-doc/sphinx_rtd_theme . ================================================ FILE: docs/dockerfile ================================================ FROM sphinxdoc/sphinx RUN pip install sphinx_rtd_theme ================================================ FILE: docs/endpoints/authorize.rst ================================================ Authorize Endpoint ================== The authorize endpoint can be used to request tokens or authorization codes via the browser. This process typically involves authentication of the end-user and optionally consent. .. Note:: IdentityServer supports a subset of the OpenID Connect and OAuth 2.0 authorize request parameters. For a full list, see `here `_. ``client_id`` identifier of the client (required). ``request`` instead of providing all parameters as individual query string parameters, you can provide a subset or all of them as a JWT ``request_uri`` URL of a pre-packaged JWT containing request parameters ``scope`` one or more registered scopes (required) ``redirect_uri`` must exactly match one of the allowed redirect URIs for that client (required) ``response_type`` ``id_token`` requests an identity token (only identity scopes are allowed) ``token`` requests an access token (only resource scopes are allowed) ``id_token token`` requests an identity token and an access token ``code`` requests an authorization code ``code id_token`` requests an authorization code and identity token ``code id_token token`` requests an authorization code, identity token and access token ``response_mode`` ``form_post`` sends the token response as a form post instead of a fragment encoded redirect (optional) ``state`` identityserver will echo back the state value on the token response, this is for round tripping state between client and provider, correlating request and response and CSRF/replay protection. (recommended) ``nonce`` identityserver will echo back the nonce value in the identity token, this is for replay protection) *Required for identity tokens via implicit grant.* ``prompt`` ``none`` no UI will be shown during the request. If this is not possible (e.g. because the user has to sign in or consent) an error is returned ``login`` the login UI will be shown, even if the user is already signed-in and has a valid session ``code_challenge`` sends the code challenge for PKCE ``code_challenge_method`` ``plain`` indicates that the challenge is using plain text (not recommended) ``S256`` indicates the challenge is hashed with SHA256 ``login_hint`` can be used to pre-fill the username field on the login page ``ui_locales`` gives a hint about the desired display language of the login UI ``max_age`` if the user's logon session exceeds the max age (in seconds), the login UI will be shown ``acr_values`` allows passing in additional authentication related information - identityserver special cases the following proprietary acr_values: ``idp:name_of_idp`` bypasses the login/home realm screen and forwards the user directly to the selected identity provider (if allowed per client configuration) ``tenant:name_of_tenant`` can be used to pass a tenant name to the login UI **Example** :: GET /connect/authorize? client_id=client1& scope=openid email api1& response_type=id_token token& redirect_uri=https://myapp/callback& state=abc& nonce=xyz (URL encoding removed, and line breaks added for readability) .. Note:: You can use the `IdentityModel `_ client library to programmatically create authorize requests .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/device_authorization.rst ================================================ Device Authorization Endpoint ============================= The device authorization endpoint can be used to request device and user codes. This endpoint is used to start the device flow authorization process. .. Note:: The URL for the end session endpoint is available via the :ref:`discovery endpoint `. ``client_id`` client identifier (required) ``client_secret`` client secret either in the post body, or as a basic authentication header. Optional. ``scope`` one or more registered scopes. If not specified, a token for all explicitly allowed scopes will be issued. Example ^^^^^^^ :: POST /connect/deviceauthorization client_id=client1& client_secret=secret& scope=openid api1 (Form-encoding removed and line breaks added for readability) .. Note:: You can use the `IdentityModel `_ client library to programmatically access the device authorization endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/discovery.rst ================================================ .. _refDiscovery: Discovery Endpoint ================== The discovery endpoint can be used to retrieve metadata about your IdentityServer - it returns information like the issuer name, key material, supported scopes etc. See the `spec `_ for more details. The discovery endpoint is available via `/.well-known/openid-configuration` relative to the base address, e.g.:: https://demo.identityserver8.io/.well-known/openid-configuration .. Note:: You can use the `IdentityModel `_ client library to programmatically access the discovery endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/endsession.rst ================================================ .. _refEndSession: End Session Endpoint ==================== The end session endpoint can be used to trigger single sign-out (see `spec `_). To use the end session endpoint a client application will redirect the user's browser to the end session URL. All applications that the user has logged into via the browser during the user's session can participate in the sign-out. .. Note:: The URL for the end session endpoint is available via the :ref:`discovery endpoint `. Parameters ^^^^^^^^^^ **id_token_hint** When the user is redirected to the endpoint, they will be prompted if they really want to sign-out. This prompt can be bypassed by a client sending the original *id_token* received from authentication. This is passed as a query string parameter called ``id_token_hint``. **post_logout_redirect_uri** If a valid ``id_token_hint`` is passed, then the client may also send a ``post_logout_redirect_uri`` parameter. This can be used to allow the user to redirect back to the client after sign-out. The value must match one of the client's pre-configured `PostLogoutRedirectUris` (:ref:`client docs `). **state** If a valid ``post_logout_redirect_uri`` is passed, then the client may also send a ``state`` parameter. This will be returned back to the client as a query string parameter after the user redirects back to the client. This is typically used by clients to round-trip state across the redirect. Example ^^^^^^^ :: GET /connect/endsession?id_token_hint=eyJhbGciOiJSUzI1NiIsImtpZCI6IjdlOGFkZmMzMjU1OTEyNzI0ZDY4NWZmYmIwOThjNDEyIiwidHlwIjoiSldUIn0.eyJuYmYiOjE0OTE3NjUzMjEsImV4cCI6MTQ5MTc2NTYyMSwiaXNzIjoiaHR0cDovL2xvY2FsaG9zdDo1MDAwIiwiYXVkIjoianNfb2lkYyIsIm5vbmNlIjoiYTQwNGFjN2NjYWEwNGFmNzkzNmJjYTkyNTJkYTRhODUiLCJpYXQiOjE0OTE3NjUzMjEsInNpZCI6IjI2YTYzNWVmOTQ2ZjRiZGU3ZWUzMzQ2ZjFmMWY1NTZjIiwic3ViIjoiODg0MjExMTMiLCJhdXRoX3RpbWUiOjE0OTE3NjUzMTksImlkcCI6ImxvY2FsIiwiYW1yIjpbInB3ZCJdfQ.STzOWoeVYMtZdRAeRT95cMYEmClixWkmGwVH2Yyiks9BETotbSZiSfgE5kRh72kghN78N3-RgCTUmM2edB3bZx4H5ut3wWsBnZtQ2JLfhTwJAjaLE9Ykt68ovNJySbm8hjZhHzPWKh55jzshivQvTX0GdtlbcDoEA1oNONxHkpDIcr3pRoGi6YveEAFsGOeSQwzT76aId-rAALhFPkyKnVc-uB8IHtGNSyRWLFhwVqAdS3fRNO7iIs5hYRxeFSU7a5ZuUqZ6RRi-bcDhI-djKO5uAwiyhfpbpYcaY_TxXWoCmq8N8uAw9zqFsQUwcXymfOAi2UF3eFZt02hBu-shKA&post_logout_redirect_uri=http%3A%2F%2Flocalhost%3A7017%2Findex.html .. Note:: You can use the `IdentityModel `_ client library to programmatically create end_session requests .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/introspection.rst ================================================ Introspection Endpoint ====================== The introspection endpoint is an implementation of `RFC 7662 `_. It can be used to validate reference tokens (or JWTs if the consumer does not have support for appropriate JWT or cryptographic libraries). The introspection endpoint requires authentication - since the client of an introspection endpoint is an API, you configure the secret on the ``ApiResource``. Example ^^^^^^^ :: POST /connect/introspect Authorization: Basic xxxyyy token= A successful response will return a status code of 200 and either an active or inactive token:: { "active": true, "sub": "123" } Unknown or expired tokens will be marked as inactive:: { "active": false, } An invalid request will return a 400, an unauthorized request 401. .. Note:: You can use the `IdentityModel `_ client library to programmatically access the introspection endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/revocation.rst ================================================ Revocation Endpoint =================== This endpoint allows revoking access tokens (reference tokens only) and refresh token. It implements the token revocation specification `(RFC 7009) `_. ``token`` the token to revoke (required) ``token_type_hint`` either ``access_token`` or ``refresh_token`` (optional) Example ^^^^^^^ :: POST /connect/revocation HTTP/1.1 Host: server.example.com Content-Type: application/x-www-form-urlencoded Authorization: Basic czZCaGRSa3F0MzpnWDFmQmF0M2JW token=45ghiukldjahdnhzdauz&token_type_hint=refresh_token .. Note:: You can use the `IdentityModel `_ client library to programmatically access the revocation endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/token.rst ================================================ Token Endpoint ============== The token endpoint can be used to programmatically request tokens. It supports the ``password``, ``authorization_code``, ``client_credentials``, ``refresh_token`` and ``urn:ietf:params:oauth:grant-type:device_code`` grant types. Furthermore the token endpoint can be extended to support extension grant types. .. Note:: IdentityServer supports a subset of the OpenID Connect and OAuth 2.0 token request parameters. For a full list, see `here `_. ``client_id`` client identifier (required – Either in the body or as part of the authorization header.) ``client_secret`` client secret either in the post body, or as a basic authentication header. Optional. ``grant_type`` ``authorization_code``, ``client_credentials``, ``password``, ``refresh_token``, ``urn:ietf:params:oauth:grant-type:device_code`` or custom ``scope`` one or more registered scopes. If not specified, a token for all explicitly allowed scopes will be issued. ``redirect_uri`` required for the ``authorization_code`` grant type ``code`` the authorization code (required for ``authorization_code`` grant type) ``code_verifier`` PKCE proof key ``username`` resource owner username (required for ``password`` grant type) ``password`` resource owner password (required for ``password`` grant type) ``acr_values`` allows passing in additional authentication related information for the ``password`` grant type - identityserver special cases the following proprietary acr_values: ``idp:name_of_idp`` bypasses the login/home realm screen and forwards the user directly to the selected identity provider (if allowed per client configuration) ``tenant:name_of_tenant`` can be used to pass a tenant name to the token endpoint ``refresh_token`` the refresh token (required for ``refresh_token`` grant type) ``device_code`` the device code (required for ``urn:ietf:params:oauth:grant-type:device_code`` grant type) Example ^^^^^^^ :: POST /connect/token CONTENT-TYPE application/x-www-form-urlencoded client_id=client1& client_secret=secret& grant_type=authorization_code& code=hdh922& redirect_uri=https://myapp.com/callback (Form-encoding removed and line breaks added for readability) .. Note:: You can use the `IdentityModel `_ client library to programmatically access the token endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/endpoints/userinfo.rst ================================================ UserInfo Endpoint ================= The UserInfo endpoint can be used to retrieve identity information about a user (see `spec `_). The caller needs to send a valid access token representing the user. Depending on the granted scopes, the UserInfo endpoint will return the mapped claims (at least the `openid` scope is required). Example ^^^^^^^ :: GET /connect/userinfo Authorization: Bearer :: HTTP/1.1 200 OK Content-Type: application/json { "sub": "248289761001", "name": "Bob Smith", "given_name": "Bob", "family_name": "Smith", "role": [ "user", "admin" ] } .. Note:: You can use the `IdentityModel `_ client library to programmatically access the userinfo endpoint from .NET code. For more information check the IdentityModel `docs `_. ================================================ FILE: docs/identityserver docs figures.pptx ================================================ [File too large to display: 22.5 MB] ================================================ FILE: docs/index.rst ================================================ Welcome to IdentityServer8 (latest) ============================================= .. image:: images/logo.png :align: center IdentityServer8 is an OpenID Connect and OAuth 2.0 framework for ASP.NET DotNet 8. Browse the latest `IdentityServer8 source code onGitHub `_ or download the `latest IdentyServer8 packages `_ on NuGet. .. warning:: This is a revival of the archived IdentityServer4 project which started a new `company `_ as of Oct, 1st 2020. The new Duende IdentityServer is not longer free open source, but now has various commercial licenses and paid upgrade package. IdentityServer8 and dependenices have been upgraded to DotNet 8 and will be maintained by HigginsSoft, Alexander Higgins and the community as an Open Source project. .. note:: This docs cover the latest version on main branch. This might not be released yet. Use the version picker in the lower left corner to select docs for a specific version. It enables the following features in your applications: | **Authentication as a Service** | Centralized login logic and workflow for all of your applications (web, native, mobile, services). IdentityServer is an officially `certified `_ implementation of OpenID Connect. | **Single Sign-on / Sign-out** | Single sign-on (and out) over multiple application types. | **Access Control for APIs** | Issue access tokens for APIs for various types of clients, e.g. server to server, web applications, SPAs and native/mobile apps. | **Federation Gateway** | Support for external identity providers like Azure Active Directory, Google, Facebook etc. This shields your applications from the details of how to connect to these external providers. | **Focus on Customization** | The most important part - many aspects of IdentityServer can be customized to fit **your** needs. Since IdentityServer is a framework and not a boxed product or a SaaS, you can write code to adapt the system the way it makes sense for your scenarios. | **Mature Open Source** | IdentityServer uses the permissive `Apache 2 `_ license that allows building commercial products on top of it. It is also part of the `.NET Foundation `_ which provides governance and legal backing. | **Free and Commercial Support** | If you need help building or running your identity platform, :ref:`let us know `. There are several ways we can help you out. .. toctree:: :maxdepth: 3 :hidden: :caption: Introduction intro/big_picture intro/architecture intro/terminology intro/specs intro/packaging intro/support intro/test intro/contributing .. toctree:: :maxdepth: 3 :hidden: :caption: Quickstarts quickstarts/0_overview quickstarts/1_client_credentials quickstarts/2_interactive_aspnetcore quickstarts/3_aspnetcore_and_apis quickstarts/4_javascript_client quickstarts/5_entityframework quickstarts/6_aspnet_identity .. toctree:: :maxdepth: 3 :hidden: :caption: Configuration configuration/startup configuration/resources configuration/clients configuration/mvc configuration/apis .. toctree:: :maxdepth: 3 :hidden: :caption: Topics topics/startup topics/resources topics/clients topics/signin topics/signin_external_providers topics/windows topics/signout topics/signout_external_providers topics/signout_federated topics/federation_gateway topics/consent topics/apis topics/deployment topics/logging topics/events topics/crypto topics/grant_types topics/client_authentication topics/extension_grants topics/resource_owner topics/refresh_tokens topics/reference_tokens topics/persisted_grants topics/pop topics/mtls topics/request_object topics/custom_token_request_validation topics/cors topics/discovery topics/add_apis topics/add_protocols topics/tools .. toctree:: :maxdepth: 3 :hidden: :caption: Endpoints endpoints/discovery endpoints/authorize endpoints/token endpoints/userinfo endpoints/device_authorization endpoints/introspection endpoints/revocation endpoints/endsession .. toctree:: :maxdepth: 3 :hidden: :caption: Reference reference/options reference/identity_resource reference/api_scope reference/api_resource reference/client reference/grant_validation_result reference/profileservice reference/interactionservice reference/deviceflow_interactionservice reference/ef reference/aspnet_identity .. toctree:: :maxdepth: 3 :hidden: :caption: Misc misc/training misc/blogs misc/videos ================================================ FILE: docs/intro/big_picture.rst ================================================ The Big Picture =============== Most modern applications look more or less like this: .. image:: images/appArch.png The most common interactions are: * Browsers communicate with web applications * Web applications communicate with web APIs (sometimes on their own, sometimes on behalf of a user) * Browser-based applications communicate with web APIs * Native applications communicate with web APIs * Server-based applications communicate with web APIs * Web APIs communicate with web APIs (sometimes on their own, sometimes on behalf of a user) Typically each and every layer (front-end, middle-tier and back-end) has to protect resources and implement authentication and/or authorization – often against the same user store. Outsourcing these fundamental security functions to a security token service prevents duplicating that functionality across those applications and endpoints. Restructuring the application to support a security token service leads to the following architecture and protocols: .. image:: images/protocols.png Such a design divides security concerns into two parts: Authentication ^^^^^^^^^^^^^^ Authentication is needed when an application needs to know the identity of the current user. Typically these applications manage data on behalf of that user and need to make sure that this user can only access the data for which he is allowed. The most common example for that is (classic) web applications – but native and JS-based applications also have a need for authentication. The most common authentication protocols are SAML2p, WS-Federation and OpenID Connect – SAML2p being the most popular and the most widely deployed. OpenID Connect is the newest of the three, but is considered to be the future because it has the most potential for modern applications. It was built for mobile application scenarios right from the start and is designed to be API friendly. API Access ^^^^^^^^^^ Applications have two fundamental ways with which they communicate with APIs – using the application identity, or delegating the user’s identity. Sometimes both methods need to be combined. OAuth2 is a protocol that allows applications to request access tokens from a security token service and use them to communicate with APIs. This delegation reduces complexity in both the client applications as well as the APIs since authentication and authorization can be centralized. OpenID Connect and OAuth 2.0 – better together ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ OpenID Connect and OAuth 2.0 are very similar – in fact OpenID Connect is an extension on top of OAuth 2.0. The two fundamental security concerns, authentication and API access, are combined into a single protocol - often with a single round trip to the security token service. We believe that the combination of OpenID Connect and OAuth 2.0 is the best approach to secure modern applications for the foreseeable future. IdentityServer8 is an implementation of these two protocols and is highly optimized to solve the typical security problems of today’s mobile, native and web applications. How IdentityServer8 can help ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ IdentityServer is middleware that adds the spec compliant OpenID Connect and OAuth 2.0 endpoints to an arbitrary ASP.NET Core application. Typically, you build (or re-use) an application that contains a login and logout page (and maybe consent - depending on your needs), and the IdentityServer middleware adds the necessary protocol heads to it, so that client applications can talk to it using those standard protocols. .. image:: images/middleware.png The hosting application can be as complex as you want, but we typically recommend to keep the attack surface as small as possible by including authentication related UI only. ================================================ FILE: docs/intro/contributing.rst ================================================ Contributing ============ We are very open to community contributions, but there are a couple of guidelines you should follow so we can handle this without too much effort. How to contribute? ^^^^^^^^^^^^^^^^^^ The easiest way to contribute is to open an issue and start a discussion. Then we can decide if and how a feature or a change could be implemented. If you should submit a pull request with code changes, start with a description, only make the minimal changes to start with and provide tests that cover those changes. Also read this first: `Being a good open source citizen `_ General feedback and discussions? ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Please start a discussion on the `core repo issue tracker `_. Bugs and feature requests? ^^^^^^^^^^^^^^^^^^^^^^^^^^ Please log a new issue in the appropriate GitHub repo: * `Core `_ * `AccessTokenValidation `_ Contributing code and content ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ You will need to sign a Contributor License Agreement before you can contribute any code or content. This is an automated process that will start after you opened a pull request. Contribution projects ^^^^^^^^^^^^^^^^^^^^^ We very much appreciate if you start a contribution project (e.g. support for Database X or Configuration Store Y). Tell us about it so we can tweet and link it in our docs. We generally don't want to take ownership of those contribution libraries, we are already really busy supporting the core projects. **Naming conventions** As of October 2017, the IdentityServer8.* nuget namespace is reserved for our packages. Please use the following naming conventions: ``YourProjectName.IdentityServer8`` or ``IdentityServer8.Contrib.YourProjectName`` ================================================ FILE: docs/intro/packaging.rst ================================================ Packaging and Builds ==================== IdentityServer consists of a number of nuget packages. IdentityServer8 main repo ^^^^^^^^^^^^^^^ `github `_ Contains the core IdentityServer object model, services and middleware as well as the EntityFramework and ASP.NET Identity integration. nugets: * `HigginsSoft.IdentityServer8 `_ * `HigginsSoft.IdentityServer8.EntityFramework `_ * `HigginsSoft.IdentityServer8.AspNetIdentity `_ Quickstart UI ^^^^^^^^^^^^^ `github `_ Contains a simple starter UI including login, logout and consent pages. Access token validation handler ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `nuget `_ | `github `_ ASP.NET Core authentication handler for validating tokens in APIs. The handler allows supporting both JWT and reference tokens in the same API. Templates ^^^^^^^^^ `nuget `_ | `github `_ Contains templates for the dotnet CLI. Dev builds ^^^^^^^^^^ In addition we publish CI builds to our package repository. Add the following ``nuget.config`` to your project:: ================================================ FILE: docs/intro/specs.rst ================================================ Supported Specifications ======================== IdentityServer implements the following specifications: OpenID Connect ^^^^^^^^^^^^^^ * OpenID Connect Core 1.0 (`spec `_) * OpenID Connect Discovery 1.0 (`spec `_) * OpenID Connect RP-Initiated Logout 1.0 - draft 01 (`spec `_) * OpenID Connect Session Management 1.0 - draft 30 (`spec `_) * OpenID Connect Front-Channel Logout 1.0 - draft 04 (`spec `_) * OpenID Connect Back-Channel Logout 1.0 - draft 06 (`spec `_) OAuth 2.0 ^^^^^^^^^ * OAuth 2.0 (`RFC 6749 `_) * OAuth 2.0 Bearer Token Usage (`RFC 6750 `_) * OAuth 2.0 Multiple Response Types (`spec `_) * OAuth 2.0 Form Post Response Mode (`spec `_) * OAuth 2.0 Token Revocation (`RFC 7009 `_) * OAuth 2.0 Token Introspection (`RFC 7662 `_) * Proof Key for Code Exchange (`RFC 7636 `_) * JSON Web Tokens for Client Authentication (`RFC 7523 `_) * OAuth 2.0 Device Authorization Grant (`RFC 8628 `_) * OAuth 2.0 Mutual TLS Client Authentication and Certificate-Bound Access Tokens (`RFC 8705 `_) * JWT Secured Authorization Request (`draft `_) ================================================ FILE: docs/intro/support.rst ================================================ .. _refSupport: Support and Consulting Options ============================== We have several free and commercial support and consulting options for IdentityServer. Free support ^^^^^^^^^^^^ Free support is community-based and uses public forums **StackOverflow** There's an ever growing community of people using IdentityServer that monitor questions on StackOverflow. If time permits, we also try to answer as many questions as possible You can subscribe to all IdentityServer8 related questions using this feed: https://stackoverflow.com/questions/tagged/?tagnames=IdentityServer8&sort=newest Please use the ``IdentityServer8`` tag when asking new questions **Gitter** You can chat with other IdentityServer8 users in our Gitter chat room: https://app.gitter.im/#/room/#identityserver8:gitter.im **Reporting a bug** If you think you have found a bug or unexpected behavior, please open an issue on the Github `issue tracker `_. We try to get back to you ASAP. Please understand that we also have day jobs, and might be too busy to reply immediately. Also check the `contribution `_ guidelines before posting. Commercial support ^^^^^^^^^^^^^^^^^^ We are doing consulting, mentoring and custom software development around identity & access control architecture in general, and IdentityServer in particular. Please `get in touch `_ with us to discuss possible options. **Training** We are regularly doing workshops around identity & access control for modern applications. Check the agenda and upcoming public dates `here `_. We can also perform the training privately at your company. `Contact us `_ to request the training on-site. **AdminUI, WS-Federation, SAML2p, and FIDO2 support** There are commercial add-on products available from our partners, Rock Solid Knowledge, on `identityserver8.com `_. ================================================ FILE: docs/intro/terminology.rst ================================================ Terminology =========== The specs, documentation and object model use a certain terminology that you should be aware of. .. image:: images/terminology.png IdentityServer ^^^^^^^^^^^^^^ IdentityServer is an OpenID Connect provider - it implements the OpenID Connect and OAuth 2.0 protocols. Different literature uses different terms for the same role - you probably also find security token service, identity provider, authorization server, IP-STS and more. But they are in a nutshell all the same: a piece of software that issues security tokens to clients. IdentityServer has a number of jobs and features - including: * protect your resources * authenticate users using a local account store or via an external identity provider * provide session management and single sign-on * manage and authenticate clients * issue identity and access tokens to clients * validate tokens User ^^^^ A user is a human that is using a registered client to access resources. Client ^^^^^^ A client is a piece of software that requests tokens from IdentityServer - either for authenticating a user (requesting an identity token) or for accessing a resource (requesting an access token). A client must be first registered with IdentityServer before it can request tokens. Examples for clients are web applications, native mobile or desktop applications, SPAs, server processes etc. Resources ^^^^^^^^^ Resources are something you want to protect with IdentityServer - either identity data of your users, or APIs. Every resource has a unique name - and clients use this name to specify to which resources they want to get access to. **Identity data** Identity information (aka claims) about a user, e.g. name or email address. **APIs** APIs resources represent functionality a client wants to invoke - typically modelled as Web APIs, but not necessarily. Identity Token ^^^^^^^^^^^^^^ An identity token represents the outcome of an authentication process. It contains at a bare minimum an identifier for the user (called the `sub` aka subject claim) and information about how and when the user authenticated. It can contain additional identity data. Access Token ^^^^^^^^^^^^ An access token allows access to an API resource. Clients request access tokens and forward them to the API. Access tokens contain information about the client and the user (if present). APIs use that information to authorize access to their data. ================================================ FILE: docs/intro/test.rst ================================================ Demo Server =========== You can try IdentityServer8 with your favourite client library. We have a test instance at `demo.identityserver8.io `_. On the main page you can find instructions on how to configure your client and how to call an API. ================================================ FILE: docs/make.bat ================================================ @ECHO OFF REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set BUILDDIR=_build set ALLSPHINXOPTS=-d %BUILDDIR%/doctrees %SPHINXOPTS% . set I18NSPHINXOPTS=%SPHINXOPTS% . if NOT "%PAPER%" == "" ( set ALLSPHINXOPTS=-D latex_paper_size=%PAPER% %ALLSPHINXOPTS% set I18NSPHINXOPTS=-D latex_paper_size=%PAPER% %I18NSPHINXOPTS% ) if "%1" == "" goto help if "%1" == "help" ( :help echo.Please use `make ^` where ^ is one of echo. html to make standalone HTML files echo. dirhtml to make HTML files named index.html in directories echo. singlehtml to make a single large HTML file echo. pickle to make pickle files echo. json to make JSON files echo. htmlhelp to make HTML files and a HTML help project echo. qthelp to make HTML files and a qthelp project echo. devhelp to make HTML files and a Devhelp project echo. epub to make an epub echo. epub3 to make an epub3 echo. latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter echo. text to make text files echo. man to make manual pages echo. texinfo to make Texinfo files echo. gettext to make PO message catalogs echo. changes to make an overview over all changed/added/deprecated items echo. xml to make Docutils-native XML files echo. pseudoxml to make pseudoxml-XML files for display purposes echo. linkcheck to check all external links for integrity echo. doctest to run all doctests embedded in the documentation if enabled echo. coverage to run coverage check of the documentation if enabled echo. dummy to check syntax errors of document sources goto end ) if "%1" == "clean" ( for /d %%i in (%BUILDDIR%\*) do rmdir /q /s %%i del /q /s %BUILDDIR%\* goto end ) REM Check if sphinx-build is available and fallback to Python version if any %SPHINXBUILD% 1>NUL 2>NUL if errorlevel 9009 goto sphinx_python goto sphinx_ok :sphinx_python set SPHINXBUILD=python -m sphinx.__init__ %SPHINXBUILD% 2> nul if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) :sphinx_ok if "%1" == "html" ( %SPHINXBUILD% -b html %ALLSPHINXOPTS% %BUILDDIR%/html if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/html. goto end ) if "%1" == "dirhtml" ( %SPHINXBUILD% -b dirhtml %ALLSPHINXOPTS% %BUILDDIR%/dirhtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/dirhtml. goto end ) if "%1" == "singlehtml" ( %SPHINXBUILD% -b singlehtml %ALLSPHINXOPTS% %BUILDDIR%/singlehtml if errorlevel 1 exit /b 1 echo. echo.Build finished. The HTML pages are in %BUILDDIR%/singlehtml. goto end ) if "%1" == "pickle" ( %SPHINXBUILD% -b pickle %ALLSPHINXOPTS% %BUILDDIR%/pickle if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the pickle files. goto end ) if "%1" == "json" ( %SPHINXBUILD% -b json %ALLSPHINXOPTS% %BUILDDIR%/json if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can process the JSON files. goto end ) if "%1" == "htmlhelp" ( %SPHINXBUILD% -b htmlhelp %ALLSPHINXOPTS% %BUILDDIR%/htmlhelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run HTML Help Workshop with the ^ .hhp project file in %BUILDDIR%/htmlhelp. goto end ) if "%1" == "qthelp" ( %SPHINXBUILD% -b qthelp %ALLSPHINXOPTS% %BUILDDIR%/qthelp if errorlevel 1 exit /b 1 echo. echo.Build finished; now you can run "qcollectiongenerator" with the ^ .qhcp project file in %BUILDDIR%/qthelp, like this: echo.^> qcollectiongenerator %BUILDDIR%\qthelp\IdentityServer8.qhcp echo.To view the help file: echo.^> assistant -collectionFile %BUILDDIR%\qthelp\IdentityServer8.ghc goto end ) if "%1" == "devhelp" ( %SPHINXBUILD% -b devhelp %ALLSPHINXOPTS% %BUILDDIR%/devhelp if errorlevel 1 exit /b 1 echo. echo.Build finished. goto end ) if "%1" == "epub" ( %SPHINXBUILD% -b epub %ALLSPHINXOPTS% %BUILDDIR%/epub if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub file is in %BUILDDIR%/epub. goto end ) if "%1" == "epub3" ( %SPHINXBUILD% -b epub3 %ALLSPHINXOPTS% %BUILDDIR%/epub3 if errorlevel 1 exit /b 1 echo. echo.Build finished. The epub3 file is in %BUILDDIR%/epub3. goto end ) if "%1" == "latex" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex if errorlevel 1 exit /b 1 echo. echo.Build finished; the LaTeX files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdf" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "latexpdfja" ( %SPHINXBUILD% -b latex %ALLSPHINXOPTS% %BUILDDIR%/latex cd %BUILDDIR%/latex make all-pdf-ja cd %~dp0 echo. echo.Build finished; the PDF files are in %BUILDDIR%/latex. goto end ) if "%1" == "text" ( %SPHINXBUILD% -b text %ALLSPHINXOPTS% %BUILDDIR%/text if errorlevel 1 exit /b 1 echo. echo.Build finished. The text files are in %BUILDDIR%/text. goto end ) if "%1" == "man" ( %SPHINXBUILD% -b man %ALLSPHINXOPTS% %BUILDDIR%/man if errorlevel 1 exit /b 1 echo. echo.Build finished. The manual pages are in %BUILDDIR%/man. goto end ) if "%1" == "texinfo" ( %SPHINXBUILD% -b texinfo %ALLSPHINXOPTS% %BUILDDIR%/texinfo if errorlevel 1 exit /b 1 echo. echo.Build finished. The Texinfo files are in %BUILDDIR%/texinfo. goto end ) if "%1" == "gettext" ( %SPHINXBUILD% -b gettext %I18NSPHINXOPTS% %BUILDDIR%/locale if errorlevel 1 exit /b 1 echo. echo.Build finished. The message catalogs are in %BUILDDIR%/locale. goto end ) if "%1" == "changes" ( %SPHINXBUILD% -b changes %ALLSPHINXOPTS% %BUILDDIR%/changes if errorlevel 1 exit /b 1 echo. echo.The overview file is in %BUILDDIR%/changes. goto end ) if "%1" == "linkcheck" ( %SPHINXBUILD% -b linkcheck %ALLSPHINXOPTS% %BUILDDIR%/linkcheck if errorlevel 1 exit /b 1 echo. echo.Link check complete; look for any errors in the above output ^ or in %BUILDDIR%/linkcheck/output.txt. goto end ) if "%1" == "doctest" ( %SPHINXBUILD% -b doctest %ALLSPHINXOPTS% %BUILDDIR%/doctest if errorlevel 1 exit /b 1 echo. echo.Testing of doctests in the sources finished, look at the ^ results in %BUILDDIR%/doctest/output.txt. goto end ) if "%1" == "coverage" ( %SPHINXBUILD% -b coverage %ALLSPHINXOPTS% %BUILDDIR%/coverage if errorlevel 1 exit /b 1 echo. echo.Testing of coverage in the sources finished, look at the ^ results in %BUILDDIR%/coverage/python.txt. goto end ) if "%1" == "xml" ( %SPHINXBUILD% -b xml %ALLSPHINXOPTS% %BUILDDIR%/xml if errorlevel 1 exit /b 1 echo. echo.Build finished. The XML files are in %BUILDDIR%/xml. goto end ) if "%1" == "pseudoxml" ( %SPHINXBUILD% -b pseudoxml %ALLSPHINXOPTS% %BUILDDIR%/pseudoxml if errorlevel 1 exit /b 1 echo. echo.Build finished. The pseudo-XML files are in %BUILDDIR%/pseudoxml. goto end ) if "%1" == "dummy" ( %SPHINXBUILD% -b dummy %ALLSPHINXOPTS% %BUILDDIR%/dummy if errorlevel 1 exit /b 1 echo. echo.Build finished. Dummy builder generates no files. goto end ) :end ================================================ FILE: docs/misc/blogs.rst ================================================ Blog posts ========== Team posts ^^^^^^^^^^ 2020 ---- * `Flexible Access Token Validation in ASP.NET Core `_ * `Resource Access in IdentityServer8 v4 and going forward `_ * `Automatic Token Management for ASP.NET Core and Worker Services 1.0 `_ * `Mutual TLS and Proof-of-Possession Tokens: Summary `_ * `Mutual TLS and Proof-of-Possession Access Tokens – Part 1: Setup `_ * `Hardening OpenID Connect/OAuth Authorize Requests (and Responses) `_ * `Hardening Refresh Tokens `_ * `OAuth 2.0: The long Road to Proof-of-Possession Access Tokens `_ * `Outsourcing IdentityServer8 Token Signing to Azure Key Vault `_ * `Using ECDSA in IdentityServer8 `_ 2019 ---- * `Scope and claims design in IdentityServer `_ * `Try Device Flow with IdentityServer8 `_ * `The State of the Implicit Flow in OAuth2 `_ * `An alternative way to secure SPAs (with ASP.NET Core, OpenID Connect, OAuth 2.0 and ProxyKit) `_ * `Automatic OAuth 2.0 Token Management in ASP.NET Core `_ * `Encrypting Identity Tokens in IdentityServer8 `_ 2018 ---- * `IdentityServer8 Update `_ * `IdentityServer and Swagger `_ * `Removing Shared Secrets for OAuth Client Authentication `_ * `Creating Your Own IdentityServer8 Storage Library `_ 2017 ---- * `Platforms where you can run IdentityServer8 `_ * `Optimizing Tokens for size `_ * `Identity vs Permissions `_ * `Bootstraping OpenID Connect: Discovery `_ * `Extending IdentityServer8 with WS-Federation Support `_ * `Announcing IdentityServer8 RC1 `_ * `Getting Started with IdentityServer 4 `_ * `IdentityServer 4 SharePoint Integration using WS-Federation `_ Community posts ^^^^^^^^^^^^^^^ * `Blazor WebAssembly authentication and authorization with IdentityServer8 `_ * `Additional API Endpoints to IdentityServer 4 `_ * `Securing Hangfire Dashboard using an OpenID Connect server (IdentityServer 4) `_ * `OAuth 2.0 - OpenID Connect & IdentityServer `_ * `Running IdentityServer8 in a Docker Container `_ * `Connecting Zendesk and IdentityServer 4 SAML 2.0 Identity Provider `_ * `IdentityServer localization using ui_locales `_ * `Self-issuing an IdentityServer8 token in an IdentityServer8 service `_ * `IdentityServer8 on the ASP.NET Team Blog `_ * `Angular2 OpenID Connect Implicit Flow with IdentityServer8 `_ * `Full Server Logout with IdentityServer8 and OpenID Connect Implicit Flow `_ * `IdentityServer8, ASP.NET Identity, Web API and Angular in a single Project `_ * `Secure your .NETCore web applications using IdentityServer 4 `_ * `ASP.NET Core IdentityServer8 Resource Owner Password Flow with custom UserRepository `_ * `Secure ASP.NET Core MVC with Angular using IdentityServer8 OpenID Connect Hybrid Flow `_ * `Adding an external Microsoft login to IdentityServer8 `_ * `Implementing Two-factor authentication with IdentityServer8 and Twilio `_ * `Security Experiments with gRPC and ASP.NET Core 3.0 `_ * `ASP.NET Core OAuth Device Flow Client with IdentityServer8 `_ * `Securing a Vue.js app using OpenID Connect Code Flow with PKCE and IdentityServer8 `_ * `Using an OData Client with an ASP.NET Core API `_ * `OpenID Connect back-channel logout using Azure Redis Cache and IdentityServer8 `_ * `Single Sign Out in IdentityServer8 with Back Channel Logout `_ ================================================ FILE: docs/misc/training.rst ================================================ Training ======== Here are some online, remote and classroom training options to learn more about ASP.NET Core identity & IdentityServer8. Identity & Access Control for modern Applications (using ASP.NET Core 2 and IdentityServer8) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ That's our own three day flagship course (including extensive hands-on labs) that we deliver as part of conferences, on-sites and remote. The agenda and dates for public training can be found `here `_, `contact `_ us for private workshops. PluralSight courses ^^^^^^^^^^^^^^^^^^^ There are some good courses on PluralSight around identity, ASP.NET Core and IdentityServer. **new** * `Securing Angular Apps with OpenID and OAuth2 `_ * `ASP.NET Core Identity Management Playbook `_ * `Getting Started with ASP.NET Core and OAuth `_ * `Securing ASP.NET Core with OAuth2 and OpenID Connect `_ * `Understanding ASP.NET Core Security (Centralized Authentication with a Token Service) `_ **older** * `Introduction to OAuth2, OpenID Connect and JSON Web Tokens (JWT) `_ * `Web API v2 Security `_ * `Using OAuth to Secure Your ASP.NET API `_ * `OAuth2 and OpenID Connect Strategies for Angular and ASP.NET `_ ================================================ FILE: docs/misc/videos.rst ================================================ Videos ====== 2020 ^^^^ * `January [NDC London] -- Implementing OpenID Connect and OAuth 2.0 – Tips from the Trenches `_ * `January [NDC London] -- OpenID Connect & OAuth 2.0 – Security Best Practices `_ 2019 ^^^^ * `October [TDC] -- Securing Web Applications and APIs with ASP.NET Core 3.0 `_ * `January [NDC] -- Securing Web Applications and APIs with ASP.NET Core 2.2 and 3.0 `_ * `January [NDC] -- Building Clients for OpenID Connect/OAuth 2-based Systems `_ 2018 ^^^^ * `26/09 [DevConf] -- Authorization for modern Applications `_ * `17/01 [NDC London] -- IdentityServer v2 on ASP.NET Core v2 - an Update `_ * `17/01 [NDC London] -- Implementing authorization for web apps and APIs (aka PolicyServer announcement) `_ * `17/01 [DotNetRocks] -- IdentityServer and PolicyServer on DotNetRocks `_ 2017 ^^^^ * `14/09 [Microsoft Learning] -- Introduction to IdentityServer for ASP.NET Core - Brock Allen `_ * `14/06 [NDC Oslo] -- Implementing Authorization for Web Applications and APIs `_ * `22/02 [NDC Mini Copenhagen] -- IdentityServer8: New & Improved for ASP.NET Core - Dominick Baier `_ * `02/02 [DotNetRocks] -- IdentityServer8 on DotNetRocks `_ * `16/01 [NDC London] -- IdentityServer8: New and Improved for ASP.NET Core `_ * `16/01 [NDC London] -- Building JavaScript and mobile/native Clients for Token-based Architectures `_ 2016 ^^^^ * `The history of .NET identity and IdentityServer Channel9 interview `_ * `Authentication & secure API access for native & mobile Applications - Dominick Baier `_ * `ASP.NET Identity 3 - Brock Allen `_ * `Introduction to IdentityServer3 - Brock Allen `_ 2015 ^^^^ * `Securing Web APIs – Patterns & Anti-Patterns - Dominick Baier `_ * `Authentication and authorization in modern JavaScript web applications – how hard can it be? - Brock Allen `_ 2014 ^^^^ * `Unifying Authentication & Delegated API Access for Mobile, Web and the Desktop with OpenID Connect and OAuth 2 - Dominick Baier `_ ================================================ FILE: docs/quickstarts/0_overview.rst ================================================ .. _refQuickstartOverview: Overview ======== The quickstarts provide step by step instructions for various common IdentityServer scenarios. They start with the absolute basics and become more complex - it is recommended you do them in order. * adding IdentityServer to an ASP.NET Core application * configuring IdentityServer * issuing tokens for various clients * securing web applications and APIs * adding support for EntityFramework based configuration * adding support for ASP.NET Identity Every quickstart has a reference solution - you can find the code in the `samples `_ folder. Preparation ^^^^^^^^^^^ The first thing you should do is install our templates:: dotnet new -i IdentityServer8.Templates They will be used as a starting point for the various tutorials. .. note:: If you are using private NuGet sources do not forget to add the --nuget-source parameter: --nuget-source https://api.nuget.org/v3/index.json OK - let's get started! .. note:: The quickstarts target the IdentityServer 4.x and ASP.NET Core 3.1.x - there are also quickstarts for `ASP.NET Core 2 `_ and `ASP.NET Core 1 `_. ================================================ FILE: docs/quickstarts/1_client_credentials.rst ================================================ .. _refClientCredentialsQuickstart: Protecting an API using Client Credentials ========================================== The following Identity Server 4 quickstart provides step by step instructions for various common IdentityServer scenarios. These start with the absolute basics and become more complex as they progress. We recommend that you follow them in sequence. To see the full list, please go to `IdentityServer8 Quickstarts Overview `_ This first quickstart is the most basic scenario for protecting APIs using IdentityServer. In this quickstart you define an API and a Client with which to access it. The client will request an access token from the Identity Server using its client ID and secret and then use the token to gain access to the API. Source Code ^^^^^^^^^^^ As with all of these quickstarts you can find the source code for it in the `IdentityServer8 `_ repository. The project for this quickstart is `Quickstart #1: Securing an API using Client Credentials `_ Preparation ^^^^^^^^^^^ The IdentityServer templates for the dotnet CLI are a good starting point for the quickstarts. To install the templates open a console window and type the following command:: dotnet new -i IdentityServer8.Templates They will be used as a starting point for the various tutorials. Setting up the ASP.NET Core application ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ First create a directory for the application - then use our template to create an ASP.NET Core application that includes a basic IdentityServer setup, e.g.:: md quickstart cd quickstart md src cd src dotnet new is4empty -n IdentityServer This will create the following files: * ``IdentityServer.csproj`` - the project file and a ``Properties\launchSettings.json`` file * ``Program.cs`` and ``Startup.cs`` - the main application entry point * ``Config.cs`` - IdentityServer resources and clients configuration file You can now use your favorite text editor to edit or view the files. If you want to have Visual Studio support, you can add a solution file like this:: cd .. dotnet new sln -n Quickstart and let it add your IdentityServer project (keep this command in mind as we will create other projects below):: dotnet sln add .\src\IdentityServer\IdentityServer.csproj .. note:: The protocol used in this Template is ``https`` and the port is set to 5001 when running on Kestrel or a random one on IISExpress. You can change that in the ``Properties\launchSettings.json`` file. For production scenarios you should always use ``https``. Defining an API Scope ^^^^^^^^^^^^^^^^^^^^^ An API is a resource in your system that you want to protect. Resource definitions can be loaded in many ways, the template you used to create the project above shows how to use a "code as configuration" approach. The Config.cs is already created for you. Open it, update the code to look like this:: public static class Config { public static IEnumerable ApiScopes => new List { new ApiScope("api1", "My API") }; } (see the full file `here `_). .. note:: If you will be using this in production it is important to give your API a logical name. Developers will be using this to connect to your api though your Identity server. It should describe your api in simple terms to both developers and users. Defining the client ^^^^^^^^^^^^^^^^^^^ The next step is to define a client application that we will use to access our new API. For this scenario, the client will not have an interactive user, and will authenticate using the so called client secret with IdentityServer. For this, add a client definition:: public static IEnumerable Clients => new List { new Client { ClientId = "client", // no interactive user, use the clientid/secret for authentication AllowedGrantTypes = GrantTypes.ClientCredentials, // secret for authentication ClientSecrets = { new Secret("secret".Sha256()) }, // scopes that client has access to AllowedScopes = { "api1" } } }; You can think of the ClientId and the ClientSecret as the login and password for your application itself. It identifies your application to the identity server so that it knows which application is trying to connect to it. Configuring IdentityServer ^^^^^^^^^^^^^^^^^^^^^^^^^^ Loading the resource and client definitions happens in `Startup.cs `_ - update the code to look like this:: public void ConfigureServices(IServiceCollection services) { var builder = services.AddIdentityServer() .AddDeveloperSigningCredential() //This is for dev only scenarios when you don’t have a certificate to use. .AddInMemoryApiScopes(Config.ApiScopes) .AddInMemoryClients(Config.Clients); // omitted for brevity } That's it - your identity server should now be configured. If you run the server and navigate the browser to ``https://localhost:5001/.well-known/openid-configuration``, you should see the so-called discovery document. The discovery document is a standard endpoint in identity servers. The discovery document will be used by your clients and APIs to download the necessary configuration data. .. image:: images/1_discovery.png At first startup, IdentityServer will create a developer signing key for you, it's a file called ``tempkey.jwk``. You don't have to check that file into your source control, it will be re-created if it is not present. Adding an API ^^^^^^^^^^^^^ Next, add an API to your solution. You can either use the ASP.NET Core Web API template from Visual Studio or use the .NET CLI to create the API project as we do here. Run from within the ``src`` folder the following command:: dotnet new webapi -n Api Then add it to the solution by running the following commands:: cd .. dotnet sln add .\src\Api\Api.csproj Configure the API application to run on ``https://localhost:6001`` only. You can do this by editing the `launchSettings.json `_ file inside the Properties folder. Change the application URL setting to be:: "applicationUrl": "https://localhost:6001" The controller -------------- Add a new class called ``IdentityController``:: [Route("identity")] [Authorize] public class IdentityController : ControllerBase { [HttpGet] public IActionResult Get() { return new JsonResult(from c in User.Claims select new { c.Type, c.Value }); } } This controller will be used later to test the authorization requirement, as well as visualize the claims identity through the eyes of the API. Adding a Nuget Dependency ------------------------- In order for the configuration step to work the nuget package dependency has to be added, run this command in the root directory:: dotnet add .\\src\\api\\Api.csproj package Microsoft.AspNetCore.Authentication.JwtBearer Configuration ------------- The last step is to add the authentication services to DI (dependency injection) and the authentication middleware to the pipeline. These will: * validate the incoming token to make sure it is coming from a trusted issuer * validate that the token is valid to be used with this api (aka audience) Update `Startup` to look like this:: public class Startup { public void ConfigureServices(IServiceCollection services) { services.AddControllers(); services.AddAuthentication("Bearer") .AddJwtBearer("Bearer", options => { options.Authority = "https://localhost:5001"; options.TokenValidationParameters = new TokenValidationParameters { ValidateAudience = false }; }); } public void Configure(IApplicationBuilder app) { app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapControllers(); }); } } * ``AddAuthentication`` adds the authentication services to DI and configures ``Bearer`` as the default scheme. * ``UseAuthentication`` adds the authentication middleware to the pipeline so authentication will be performed automatically on every call into the host. * ``UseAuthorization`` adds the authorization middleware to make sure, our API endpoint cannot be accessed by anonymous clients. Navigating to the controller ``https://localhost:6001/identity`` on a browser should return a 401 status code. This means your API requires a credential and is now protected by IdentityServer. .. note:: If you are wondering, why the above code disables audience validation, have a look :ref:`here ` for a more in-depth discussion. Creating the client ^^^^^^^^^^^^^^^^^^^ The last step is to write a client that requests an access token, and then uses this token to access the API. For that, add a console project to your solution, remember to create it in the ``src``:: dotnet new console -n Client Then as before, add it to your solution using:: cd .. dotnet sln add .\src\Client\Client.csproj The token endpoint at IdentityServer implements the OAuth 2.0 protocol, and you could use raw HTTP to access it. However, we have a client library called IdentityModel, that encapsulates the protocol interaction in an easy to use API. Add the ``IdentityModel`` NuGet package to your client. This can be done either via Visual Studio's Nuget Package manager or dotnet CLI:: cd src cd client dotnet add package IdentityModel IdentityModel includes a client library to use with the discovery endpoint. This way you only need to know the base-address of IdentityServer - the actual endpoint addresses can be read from the metadata:: // discover endpoints from metadata var client = new HttpClient(); var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001"); if (disco.IsError) { Console.WriteLine(disco.Error); return; } .. note:: If you get an error connecting it may be that you are running `https` and the development certificate for ``localhost`` is not trusted. You can run ``dotnet dev-certs https --trust`` in order to trust the development certificate. This only needs to be done once. Next you can use the information from the discovery document to request a token to IdentityServer to access ``api1``:: // request token var tokenResponse = await client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest { Address = disco.TokenEndpoint, ClientId = "client", ClientSecret = "secret", Scope = "api1" }); if (tokenResponse.IsError) { Console.WriteLine(tokenResponse.Error); return; } Console.WriteLine(tokenResponse.Json); (full file can be found `here `_) .. note:: Copy and paste the access token from the console to `jwt.ms `_ to inspect the raw token. Calling the API ^^^^^^^^^^^^^^^ To send the access token to the API you typically use the HTTP Authorization header. This is done using the ``SetBearerToken`` extension method:: // call api var apiClient = new HttpClient(); apiClient.SetBearerToken(tokenResponse.AccessToken); var response = await apiClient.GetAsync("https://localhost:6001/identity"); if (!response.IsSuccessStatusCode) { Console.WriteLine(response.StatusCode); } else { var content = await response.Content.ReadAsStringAsync(); Console.WriteLine(JArray.Parse(content)); } (If you are in Visual Studio you can right-click on the solution and select "Multiple Startup Projects", and ensure the Api and IdentityServer will start; then run the solution; then, to step through the Client code, you can right-click on the "Client" project and select Debug... Start New Instance). The output should look like this: .. image:: images/1_client_screenshot.png .. note:: By default an access token will contain claims about the scope, lifetime (nbf and exp), the client ID (client_id) and the issuer name (iss). Authorization at the API ^^^^^^^^^^^^^^^^^^^^^^^^ Right now, the API accepts any access token issued by your identity server. In the following we will add code that allows checking for the presence of the scope in the access token that the client asked for (and got granted). For this we will use the ASP.NET Core authorization policy system. Add the following to the ``ConfigureServices`` method in ``Startup``:: services.AddAuthorization(options => { options.AddPolicy("ApiScope", policy => { policy.RequireAuthenticatedUser(); policy.RequireClaim("scope", "api1"); }); }); You can now enforce this policy at various levels, e.g. * globally * for all API endpoints * for specific controllers/actions Typically you setup the policy for all API endpoints in the routing system:: app.UseEndpoints(endpoints => { endpoints.MapControllers() .RequireAuthorization("ApiScope"); }); Further experiments ^^^^^^^^^^^^^^^^^^^ This walkthrough focused on the success path so far * client was able to request token * client could use the token to access the API You can now try to provoke errors to learn how the system behaves, e.g. * try to connect to IdentityServer when it is not running (unavailable) * try to use an invalid client id or secret to request the token * try to ask for an invalid scope during the token request * try to call the API when it is not running (unavailable) * don't send the token to the API * configure the API to require a different scope than the one in the token ================================================ FILE: docs/quickstarts/2_interactive_aspnetcore.rst ================================================ .. _refInteractiveQuickstart: Interactive Applications with ASP.NET Core ========================================== .. note:: For any pre-requisites (like e.g. templates) have a look at the :ref:`overview ` first. In this quickstart we want to add support for interactive user authentication via the OpenID Connect protocol to our IdentityServer we built in the previous chapter. Once that is in place, we will create an MVC application that will use IdentityServer for authentication. Adding the UI ^^^^^^^^^^^^^ All the protocol support needed for OpenID Connect is already built into IdentityServer. You need to provide the necessary UI parts for login, logout, consent and error. While the look & feel as well as the exact workflows will probably always differ in every IdentityServer implementation, we provide an MVC-based sample UI that you can use as a starting point. This UI can be found in the `Quickstart UI repo `_. You can clone or download this repo and drop the controllers, views, models and CSS into your IdentityServer web application. Alternatively you can use the .NET CLI (run from within the ``src/IdentityServer`` folder):: dotnet new is4ui Once you have added the MVC UI, you will also need to enable MVC, both in the DI system and in the pipeline. When you look at ``Startup.cs`` you will find comments in the ``ConfigureServices`` and ``Configure`` method that tell you how to enable MVC. .. note:: There is also a template called ``is4inmem`` which combines a basic IdentityServer including the standard UI. Run the IdentityServer application, you should now see a home page. Spend some time inspecting the controllers and models - especially the ``AccountController`` which is the main UI entry point. The better you understand them, the easier it will be to make future modifications. Most of the code lives in the "Quickstart" folder using a "feature folder" style. If this style doesn't suit you, feel free to organize the code in any way you want. Creating an MVC client ^^^^^^^^^^^^^^^^^^^^^^ Next you will create an MVC application. Use the ASP.NET Core "Web Application" (i.e. MVC) template for that. run from the src folder:: dotnet new mvc -n MvcClient cd .. dotnet sln add .\src\MvcClient\MvcClient.csproj .. note:: We recommend using the self-host option over IIS Express. The rest of the docs assume you are using self-hosting on port 5002. To add support for OpenID Connect authentication to the MVC application, you first need to add the nuget package containing the OpenID Connect handler to your project, e.g.:: dotnet add package Microsoft.AspNetCore.Authentication.OpenIdConnect ..then add the following to ``ConfigureServices`` in ``Startup``:: using System.IdentityModel.Tokens.Jwt; // ... JwtSecurityTokenHandler.DefaultMapInboundClaims = false; services.AddAuthentication(options => { options.DefaultScheme = "Cookies"; options.DefaultChallengeScheme = "oidc"; }) .AddCookie("Cookies") .AddOpenIdConnect("oidc", options => { options.Authority = "https://localhost:5001"; options.ClientId = "mvc"; options.ClientSecret = "secret"; options.ResponseType = "code"; options.SaveTokens = true; }); ``AddAuthentication`` adds the authentication services to DI. We are using a cookie to locally sign-in the user (via ``"Cookies"`` as the ``DefaultScheme``), and we set the ``DefaultChallengeScheme`` to ``oidc`` because when we need the user to login, we will be using the OpenID Connect protocol. We then use ``AddCookie`` to add the handler that can process cookies. Finally, ``AddOpenIdConnect`` is used to configure the handler that performs the OpenID Connect protocol. The ``Authority`` indicates where the trusted token service is located. We then identify this client via the ``ClientId`` and the ``ClientSecret``. ``SaveTokens`` is used to persist the tokens from IdentityServer in the cookie (as they will be needed later). .. note:: We use the so called ``authorization code`` flow with PKCE to connect to the OpenID Connect provider. See :ref:`here ` for more information on protocol flows. And then to ensure the execution of the authentication services on each request, add ``UseAuthentication`` to ``Configure`` in ``Startup``:: app.UseStaticFiles(); app.UseRouting(); app.UseAuthentication(); app.UseAuthorization(); app.UseEndpoints(endpoints => { endpoints.MapDefaultControllerRoute() .RequireAuthorization(); }); .. note:: The ``RequireAuthorization`` method disables anonymous access for the entire application. You can also use the ``[Authorize]`` attribute, if you want to specify authorization on a per controller or action method basis. Also modify the home view to display the claims of the user as well as the cookie properties:: @using Microsoft.AspNetCore.Authentication

Claims

@foreach (var claim in User.Claims) {
@claim.Type
@claim.Value
}

Properties

@foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items) {
@prop.Key
@prop.Value
}
If you now navigate to the application using the browser, a redirect attempt will be made to IdentityServer - this will result in an error because the MVC client is not registered yet. Adding support for OpenID Connect Identity Scopes ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Similar to OAuth 2.0, OpenID Connect also uses the scopes concept. Again, scopes represent something you want to protect and that clients want to access. In contrast to OAuth, scopes in OIDC don't represent APIs, but identity data like user id, name or email address. Add support for the standard ``openid`` (subject id) and ``profile`` (first name, last name etc..) scopes by amending the ``IdentityResources`` property in ``Config.cs``:: public static IEnumerable IdentityResources => new List { new IdentityResources.OpenId(), new IdentityResources.Profile(), }; Register the identity resources with IdentityServer in ``startup.cs``:: var builder = services.AddIdentityServer() .AddInMemoryIdentityResources(Config.IdentityResources) .AddInMemoryApiScopes(Config.ApiScopes) .AddInMemoryClients(Config.Clients); .. note:: All standard scopes and their corresponding claims can be found in the OpenID Connect `specification `_ Adding Test Users ^^^^^^^^^^^^^^^^^ The sample UI also comes with an in-memory "user database". You can enable this in IdentityServer by adding the ``AddTestUsers`` extension method:: var builder = services.AddIdentityServer() .AddInMemoryIdentityResources(Config.IdentityResources) .AddInMemoryApiScopes(Config.ApiScopes) .AddInMemoryClients(Config.Clients) .AddTestUsers(TestUsers.Users); When you navigate to the ``TestUsers`` class, you can see that two users called ``alice`` and ``bob`` as well as some identity claims are defined. You can use those users to login. Adding the MVC Client to the IdentityServer Configuration ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The last step is to add a new configuration entry for the MVC client to the IdentityServer. OpenID Connect-based clients are very similar to the OAuth 2.0 clients we added so far. But since the flows in OIDC are always interactive, we need to add some redirect URLs to our configuration. The client list should look like this:: public static IEnumerable Clients => new List { // machine to machine client (from quickstart 1) new Client { ClientId = "client", ClientSecrets = { new Secret("secret".Sha256()) }, AllowedGrantTypes = GrantTypes.ClientCredentials, // scopes that client has access to AllowedScopes = { "api1" } }, // interactive ASP.NET Core MVC client new Client { ClientId = "mvc", ClientSecrets = { new Secret("secret".Sha256()) }, AllowedGrantTypes = GrantTypes.Code, // where to redirect to after login RedirectUris = { "https://localhost:5002/signin-oidc" }, // where to redirect to after logout PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" }, AllowedScopes = new List { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile } } }; Testing the client ^^^^^^^^^^^^^^^^^^ Now finally everything should be in place for the new MVC client. Trigger the authentication handshake by navigating to the protected controller action. You should see a redirect to the login page of the IdentityServer. .. image:: images/3_login.png After that, the IdentityServer will redirect back to the MVC client, where the OpenID Connect authentication handler processes the response and signs-in the user locally by setting a cookie. Finally the MVC view will show the contents of the cookie. .. image:: images/3_claims.png As you can see, the cookie has two parts, the claims of the user, and some metadata. This metadata also contains the original token that was issued by the IdentityServer. Feel free to copy this token to `jwt.ms `_ to inspect its content. Adding sign-out ^^^^^^^^^^^^^^^ The very last step is to add sign-out to the MVC client. With an authentication service like IdentityServer, it is not enough to clear the local application cookies. In addition you also need to make a roundtrip to the IdentityServer to clear the central single sign-on session. The exact protocol steps are implemented inside the OpenID Connect handler, simply add the following code to some controller to trigger the sign-out:: public IActionResult Logout() { return SignOut("Cookies", "oidc"); } This will clear the local cookie and then redirect to the IdentityServer. The IdentityServer will clear its cookies and then give the user a link to return back to the MVC application. Getting claims from the UserInfo endpoint ^^^^^^^^^^^^^^^ You might have noticed that even though we've configured the client to be allowed to retrieve the ``profile`` identity scope, the claims associated with that scope (such as ``name``, ``family_name``, ``website`` etc.) don't appear in the returned token. We need to tell the client to pull remaining claims from the `UserInfo `_ endpoint by specifying scopes that the client application needs to access and setting the ``GetClaimsFromUserInfoEndpoint`` option. In the following example we're requesting the ``profile`` scope, but it could be any scope (or scopes) that the client is authorized to access:: .AddOpenIdConnect("oidc", options => { // ... options.Scope.Add("profile"); options.GetClaimsFromUserInfoEndpoint = true; // ... }); After restarting the client app, logging out, and logging back in you should see additional user claims associated with the ``profile`` identity scope displayed on the page. .. image:: images/3_additional_claims.png Further Experiments ^^^^^^^^^^^^^^^^^^^ Feel free to add more claims to the test users - and also more identity resources. The process for defining an identity resource is as follows: * add a new identity resource to the list - give it a name and specify which claims should be returned when this resource is requested * give the client access to the resource via the ``AllowedScopes`` property on the client configuration * request the resource by adding it to the ``Scopes`` collection on the OpenID Connect handler configuration in the client * (optional) if the identity resource is associated with a non-standard claim (e.g. ``myclaim1``), on the client side add the `ClaimAction `_ mapping between the claim appearing in JSON (returned from the UserInfo endpoint) and the User `Claim `_ :: using Microsoft.AspNetCore.Authentication // ... .AddOpenIdConnect("oidc", options => { // ... options.ClaimActions.MapUniqueJsonKey("myclaim1", "myclaim1"); // ... }); It is also noteworthy, that the retrieval of claims for tokens is an extensibility point - ``IProfileService``. Since we are using ``AddTestUsers``, the ``TestUserProfileService`` is used by default. You can inspect the source code `here `_ to see how it works. .. _refExternalAuthenticationQuickstart: Adding Support for External Authentication ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Next we will add support for external authentication. This is really easy, because all you really need is an ASP.NET Core compatible authentication handler. ASP.NET Core itself ships with support for Google, Facebook, Twitter, Microsoft Account and OpenID Connect. In addition you can find implementations for many other authentication providers `here `_. Adding Google support ^^^^^^^^^^^^^^^^^^^^^ To be able to use Google for authentication, you first need to register with them. This is done at their developer `console `_. Create a new project, enable the Google+ API and configure the callback address of your local IdentityServer by adding the */signin-google* path to your base-address (e.g. https://localhost:5001/signin-google). The developer console will show you a client ID and secret issued by Google - you will need that in the next step. Add the Google authentication handler to the DI of the IdentityServer host. This is done by first adding the ``Microsoft.AspNetCore.Authentication.Google`` nuget package and then adding this snippet to ``ConfigureServices`` in ``Startup``:: services.AddAuthentication() .AddGoogle("Google", options => { options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme; options.ClientId = ""; options.ClientSecret = ""; }); By default, IdentityServer configures a cookie handler specifically for the results of external authentication (with the scheme based on the constant ``IdentityServerConstants.ExternalCookieAuthenticationScheme``). The configuration for the Google handler is then using that cookie handler. Now run the MVC client and try to authenticate - you will see a Google button on the login page: .. image:: images/4_login_page.png After authentication with the MVC client, you can see that the claims are now being sourced from Google data. .. note:: If you are interested in the magic that automatically renders the Google button on the login page, inspect the ``BuildLoginViewModel`` method on the ``AccountController``. Further experiments ^^^^^^^^^^^^^^^^^^^ You can add an additional external provider. We have a `cloud-hosted demo `_ version of IdentityServer8 which you can integrate using OpenID Connect. Add the OpenId Connect handler to DI:: services.AddAuthentication() .AddGoogle("Google", options => { options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme; options.ClientId = ""; options.ClientSecret = ""; }) .AddOpenIdConnect("oidc", "Demo IdentityServer", options => { options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme; options.SignOutScheme = IdentityServerConstants.SignoutScheme; options.SaveTokens = true; options.Authority = "https://demo.identityserver8.io/"; options.ClientId = "interactive.confidential"; options.ClientSecret = "secret"; options.ResponseType = "code"; options.TokenValidationParameters = new TokenValidationParameters { NameClaimType = "name", RoleClaimType = "role" }; }); And now a user should be able to use the cloud-hosted demo identity provider. .. note:: The quickstart UI auto-provisions external users. As an external user logs in for the first time, a new local user is created, and all the external claims are copied over and associated with the new user. The way you deal with such a situation is completely up to you though. Maybe you want to show some sort of registration UI first. The source code for the default quickstart can be found `here `_. The controller where auto-provisioning is executed can be found `here `_. ================================================ FILE: docs/quickstarts/3_aspnetcore_and_apis.rst ================================================ .. _refAspNetCoreAndApis: ASP.NET Core and API access =========================== In the previous quickstarts we explored both API access and user authentication. Now we want to bring the two parts together. The beauty of the OpenID Connect & OAuth 2.0 combination is, that you can achieve both with a single protocol and a single exchange with the token service. So far we only asked for identity resources during the token request, once we start also including API resources, IdentityServer will return two tokens: the identity token containing the information about the authentication and session, and the access token to access APIs on behalf of the logged on user. Modifying the client configuration ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Updating the client configuration in IdentityServer is straightforward - we simply need to add the ``api1`` resource to the allowed scopes list. In addition we enable support for refresh tokens via the ``AllowOfflineAccess`` property:: new Client { ClientId = "mvc", ClientSecrets = { new Secret("secret".Sha256()) }, AllowedGrantTypes = GrantTypes.Code, // where to redirect to after login RedirectUris = { "https://localhost:5002/signin-oidc" }, // where to redirect to after logout PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" }, AllowOfflineAccess = true, AllowedScopes = new List { IdentityServerConstants.StandardScopes.OpenId, IdentityServerConstants.StandardScopes.Profile, "api1" } } Modifying the MVC client ^^^^^^^^^^^^^^^^^^^^^^^^ All that's left to do now in the client is to ask for the additional resources via the scope parameter. This is done in the OpenID Connect handler configuration:: services.AddAuthentication(options => { options.DefaultScheme = "Cookies"; options.DefaultChallengeScheme = "oidc"; }) .AddCookie("Cookies") .AddOpenIdConnect("oidc", options => { options.Authority = "https://localhost:5001"; options.ClientId = "mvc"; options.ClientSecret = "secret"; options.ResponseType = "code"; options.SaveTokens = true; options.Scope.Add("api1"); options.Scope.Add("offline_access"); }); Since ``SaveTokens`` is enabled, ASP.NET Core will automatically store the resulting access and refresh token in the authentication session. You should be able to inspect the data on the page that prints out the contents of the session that you created earlier. Using the access token ^^^^^^^^^^^^^^^^^^^^^^ You can access the tokens in the session using the standard ASP.NET Core extension methods that you can find in the ``Microsoft.AspNetCore.Authentication`` namespace:: var accessToken = await HttpContext.GetTokenAsync("access_token"); For accessing the API using the access token, all you need to do is retrieve the token, and set it on your HttpClient:: public async Task CallApi() { var accessToken = await HttpContext.GetTokenAsync("access_token"); var client = new HttpClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); var content = await client.GetStringAsync("https://localhost:6001/identity"); ViewBag.Json = JArray.Parse(content).ToString(); return View("json"); } Create a view called json.cshtml that outputs the json like this:: 
@ViewBag.Json
Make sure the API is running, start the MVC client and call ``/home/CallApi`` after authentication. Managing the access token ^^^^^^^^^^^^^^^^^^^^^^^^^ By far the most complex task for a typical client is to manage the access token. You typically want to * request the access and refresh token at login time * cache those tokens * use the access token to call APIs until it expires * use the refresh token to get a new access token * start over ASP.NET Core has many built-in facility that can help you with those tasks (like caching or sessions), but there is still quite some work left to do. Feel free to have a look at `this `_ library, which can automate many of the boilerplate tasks. ================================================ FILE: docs/quickstarts/4_javascript_client.rst ================================================ .. _refJavaScriptQuickstart: Adding a JavaScript client ========================== .. note:: For any pre-requisites (like e.g. templates) have a look at the :ref:`overview ` first. This quickstart will show how to build a browser-based JavaScript client application (sometimes referred to as a "Single Page Application" or "`SPA`"). The user will login to IdentityServer, invoke the web API with an access token issued by IdentityServer, and logout of IdentityServer. All of this will be driven from the JavaScript running in the browser. New Project for the JavaScript client ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Create a new project for the JavaScript application. It can simply be an empty web project, an empty ASP.NET Core application, or something else like a Node.js application. This quickstart will use an ASP.NET Core application. Create a new "Empty" ASP.NET Core web application in the `~/src` directory. You can use Visual Studio or do this from the command line:: md JavaScriptClient cd JavaScriptClient dotnet new web As we have done before, with other client projects, add this project also to your solution. Run this from the root folder which has the sln file:: dotnet sln add .\src\JavaScriptClient\JavaScriptClient.csproj Modify hosting ^^^^^^^^^^^^^^^ Modify the `JavaScriptClient` project to run on https://localhost:5003. Add the static file middleware ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Given that this project is designed to run client-side, all we need ASP.NET Core to do is to serve up the static HTML and JavaScript files that will make up our application. The static file middleware is designed to do this. Register the static file middleware in `Startup.cs` in the ``Configure`` method (and at the same time remove everything else):: public void Configure(IApplicationBuilder app) { app.UseDefaultFiles(); app.UseStaticFiles(); } This middleware will now serve up static files from the application's `~/wwwroot` folder. This is where we will put our HTML and JavaScript files. If that folder does not exist in your project, create it now. Reference oidc-client ^^^^^^^^^^^^^^^^^^^^^ In one of the previous quickstarts in the ASP.NET Core MVC-based client project we used a library to handle the OpenID Connect protocol. In this quickstart in the `JavaScriptClient` project we need a similar library, except one that works in JavaScript and is designed to run in the browser. The `oidc-client library `_ is one such library. It is available via `NPM `_, `Bower `_, as well as a `direct download `_ from github. **NPM** If you want to use NPM to download `oidc-client`, then run these commands from your `JavaScriptClient` project directory:: npm i oidc-client copy node_modules\oidc-client\dist\* wwwroot This downloads the latest `oidc-client` package locally, and then copies the relevant JavaScript files into `~/wwwroot` so they can be served up by your application. **Manual download** If you want to simply download the `oidc-client` JavaScript files manually, browse to `the GitHub repository `_ and download the JavaScript files. Once downloaded, copy them into `~/wwwroot` so they can be served up by your application. Add your HTML and JavaScript files ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Next is to add your HTML and JavaScript files to `~/wwwroot`. We will have two HTML files and one application-specific JavaScript file (in addition to the `oidc-client.js` library). In `~/wwwroot`, add a HTML file named `index.html` and `callback.html`, and add a JavaScript file called `app.js`. **index.html** This will be the main page in our application. It will simply contain the HTML for the buttons for the user to login, logout, and call the web API. It will also contain the `` **app.js** This will contain the main code for our application. The first thing is to add a helper function to log messages to the ``
``::

    function log() {
        document.getElementById('results').innerText = '';

        Array.prototype.forEach.call(arguments, function (msg) {
            if (msg instanceof Error) {
                msg = "Error: " + msg.message;
            }
            else if (typeof msg !== 'string') {
                msg = JSON.stringify(msg, null, 2);
            }
            document.getElementById('results').innerHTML += msg + '\r\n';
        });
    }

Next, add code to register ``click`` event handlers to the three buttons::

    document.getElementById("login").addEventListener("click", login, false);
    document.getElementById("api").addEventListener("click", api, false);
    document.getElementById("logout").addEventListener("click", logout, false);

Next, we can use the ``UserManager`` class from the `oidc-client` library to manage the OpenID Connect protocol. 
It requires similar configuration that was necessary in the MVC Client (albeit with different values). 
Add this code to configure and instantiate the ``UserManager``::

    var config = {
        authority: "https://localhost:5001",
        client_id: "js",
        redirect_uri: "https://localhost:5003/callback.html",
        response_type: "code",
        scope:"openid profile api1",
        post_logout_redirect_uri : "https://localhost:5003/index.html",
    };
    var mgr = new Oidc.UserManager(config);

Next, the ``UserManager`` provides a ``getUser`` API to know if the user is logged into the JavaScript application.
It uses a JavaScript ``Promise`` to return the results asynchronously. 
The returned ``User`` object has a ``profile`` property which contains the claims for the user.
Add this code to detect if the user is logged into the JavaScript application::

    mgr.getUser().then(function (user) {
        if (user) {
            log("User logged in", user.profile);
        }
        else {
            log("User not logged in");
        }
    });

Next, we want to implement the ``login``, ``api``, and ``logout`` functions. 
The ``UserManager`` provides a ``signinRedirect`` to log the user in, and a ``signoutRedirect`` to log the user out.
The ``User`` object that we obtained in the above code also has an ``access_token`` property which can be used to authenticate to a web API.
The ``access_token`` will be passed to the web API via the `Authorization` header with the `Bearer` scheme.
Add this code to implement those three functions in our application::

    function login() {
        mgr.signinRedirect();
    }

    function api() {
        mgr.getUser().then(function (user) {
            var url = "https://localhost:6001/identity";

            var xhr = new XMLHttpRequest();
            xhr.open("GET", url);
            xhr.onload = function () {
                log(xhr.status, JSON.parse(xhr.responseText));
            }
            xhr.setRequestHeader("Authorization", "Bearer " + user.access_token);
            xhr.send();
        });
    }

    function logout() {
        mgr.signoutRedirect();
    }

.. Note:: See the :ref:`client credentials quickstart ` for information on how to create the api used in the code above.

**callback.html**

This HTML file is the designated ``redirect_uri`` page once the user has logged into IdentityServer.
It will complete the OpenID Connect protocol sign-in handshake with IdentityServer. 
The code for this is all provided by the ``UserManager`` class we used earlier. 
Once the sign-in is complete, we can then redirect the user back to the main `index.html` page. 
Add this code to complete the signin process::

    
    
    
        
        
    
    
        
        
    
    

Add a client registration to IdentityServer for the JavaScript client
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Now that the client application is ready to go, we need to define a configuration entry in IdentityServer for this new JavaScript client.
In the IdentityServer project locate the client configuration (in `Config.cs`).
Add a new `Client` to the list for our new JavaScript application.
It should have the configuration listed below::

    // JavaScript Client
    new Client
    {
        ClientId = "js",
        ClientName = "JavaScript Client",
        AllowedGrantTypes = GrantTypes.Code,
        RequireClientSecret = false,
        
        RedirectUris =           { "https://localhost:5003/callback.html" },
        PostLogoutRedirectUris = { "https://localhost:5003/index.html" },
        AllowedCorsOrigins =     { "https://localhost:5003" },

        AllowedScopes = 
        {
            IdentityServerConstants.StandardScopes.OpenId,
            IdentityServerConstants.StandardScopes.Profile,
            "api1"
        }
    }

Allowing Ajax calls to the Web API with CORS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

One last bit of configuration that is necessary is to configure CORS in the web API project. 
This will allow Ajax calls to be made from `https://localhost:5003` to `https://localhost:6001`.

**Configure CORS**

Add the CORS services to the dependency injection system in ``ConfigureServices`` in `Startup.cs`::

    public void ConfigureServices(IServiceCollection services)
    {
        // ...

        services.AddCors(options =>
        {
            // this defines a CORS policy called "default"
            options.AddPolicy("default", policy =>
            {
                policy.WithOrigins("https://localhost:5003")
                    .AllowAnyHeader()
                    .AllowAnyMethod();
            });
        });
    }

Add the CORS middleware to the pipeline in ``Configure`` (just after routing)::

    public void Configure(IApplicationBuilder app)
    {
        app.UseRouting();

        app.UseCors("default");

        // ...
    }

Run the JavaScript application
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Now you should be able to run the JavaScript client application:

.. image:: images/jsclient_not_logged_in.png

Click the "Login" button to sign the user in.
Once the user is returned back to the JavaScript application, you should see their profile information:
 
.. image:: images/jsclient_logged_in.png

And click the "API" button to invoke the web API:

.. image:: images/jsclient_api_results.png

And finally click "Logout" to sign the user out.

.. image:: images/jsclient_signed_out.png

You now have the start of a JavaScript client application that uses IdentityServer for sign-in, sign-out, and authenticating calls to web APIs.


================================================
FILE: docs/quickstarts/5_entityframework.rst
================================================
.. _refEntityFrameworkQuickstart:
Using EntityFramework Core for configuration and operational data
=================================================================

In the previous quickstarts, we created our client and scope data in code.
On startup, IdentityServer loaded this configuration data into memory.
If we wanted to modify this configuration data, we had to stop and start IdentityServer.

IdentityServer also generates temporary data, such as authorization codes, consent choices, and refresh tokens.
By default, these are also stored in-memory.

To move this data into a database that is persistent between restarts and across multiple IdentityServer instances, we can use the IdentityServer8 Entity Framework library.

.. Note:: In addition to manually configuring EF support, there is also an IdentityServer template to create a new project with EF support, using ``dotnet new is4ef``.

IdentityServer8.EntityFramework
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
``IdentityServer8.EntityFramework`` implements the required stores and services using the following DbContexts:

    * ConfigurationDbContext - used for configuration data such as clients, resources, and scopes
    * PersistedGrantDbContext - used for temporary operational data such as authorization codes, and refresh tokens

These contexts are suitable for any Entity Framework Core compatible relational database.

You can find these contexts, their entities, and the IdentityServer8 stores that use them in the ``IdentityServer8.EntityFramework.Storage`` nuget package.

You can find the extension methods to register them in your IdentityServer in ``IdentityServer8.EntityFramework``, which we will do now::

    dotnet add package IdentityServer8.EntityFramework

Using SqlServer
^^^^^^^^^^^^^^^

For this quickstart, we will use the LocalDb version of SQLServer that comes with Visual Studio.
To add SQL Server support to our IdentityServer project, you’ll need the following nuget package::

    dotnet add package Microsoft.EntityFrameworkCore.SqlServer

Database Schema Changes and Using EF Migrations
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The ``IdentityServer8.EntityFramework.Storage`` package contains entity classes that map from IdentityServer’s models.
As IdentityServer’s models change, so will the entity classes in ``IdentityServer8.EntityFramework.Storage``.
As you use ``IdentityServer8.EntityFramework.Storage`` and upgrade over time, you are responsible for your database schema and changes necessary to that schema as the entity classes change.
One approach for managing those changes is to use `EF migrations `_, which is what we’ll use in this quickstart.
If migrations are not your preference, then you can manage the schema changes in any way you see fit.

.. Note:: You can find the `latest SQL scripts `_ for SqlServer in the IdentityServer8.EntityFramework.Storage repository.

Configuring the Stores
^^^^^^^^^^^^^^^^^^^^^^

To start using these stores, you’ll need to replace any existing calls to ``AddInMemoryClients``, ``AddInMemoryIdentityResources``, ``AddInMemoryApiScopes``, ``AddInMemoryApiResources``, and ``AddInMemoryPersistedGrants`` in your ``ConfigureServices`` method in `Startup.cs` with ``AddConfigurationStore`` and ``AddOperationalStore``.

These methods each require a ``DbContextOptionsBuilder``, meaning your code will look something like this::

    var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
    const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer8.Quickstart.EntityFramework-4.0.0;trusted_connection=yes;";

    services.AddIdentityServer()
        .AddTestUsers(TestUsers.Users)
        .AddConfigurationStore(options =>
        {
            options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                sql => sql.MigrationsAssembly(migrationsAssembly));
        })
        .AddOperationalStore(options =>
        {
            options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                sql => sql.MigrationsAssembly(migrationsAssembly));
        });

You might need these namespaces added to the file::

    using Microsoft.EntityFrameworkCore;
    using System.Reflection;


Because we are using EF migrations in this quickstart, the call to ``MigrationsAssembly`` is used to inform Entity Framework that the host project will contain the migrations code.
This is necessary since the host project is in a different assembly than the one that contains the ``DbContext`` classes.

Adding Migrations
^^^^^^^^^^^^^^^^^

Once the IdentityServer has been configured to use Entity Framework, we’ll need to generate some migrations.

To create migrations, you will need to install the Entity Framework Core CLI on your machine and the ``Microsoft.EntityFrameworkCore.Design`` nuget package in IdentityServer::

    dotnet tool install --global dotnet-ef
    dotnet add package Microsoft.EntityFrameworkCore.Design

To create the migrations, open a command prompt in the IdentityServer project directory and run the following two commands::

    dotnet ef migrations add InitialIdentityServerPersistedGrantDbMigration -c PersistedGrantDbContext -o Data/Migrations/IdentityServer/PersistedGrantDb
    dotnet ef migrations add InitialIdentityServerConfigurationDbMigration -c ConfigurationDbContext -o Data/Migrations/IdentityServer/ConfigurationDb

You should now see a ``~/Data/Migrations/IdentityServer`` folder in your project containing the code for your newly created migrations.

Initializing the Database
^^^^^^^^^^^^^^^^^^^^^^^^^

Now that we have the migrations, we can write code to create the database from the migrations.
We can also seed the database with the in-memory configuration data that we already defined in the previous quickstarts.

.. Note:: The approach used in this quickstart is used to make it easy to get IdentityServer up and running. You should devise your own database creation and maintenance strategy that is appropriate for your architecture.

In `Startup.cs` add this method to help initialize the database::

    private void InitializeDatabase(IApplicationBuilder app)
    {
        using (var serviceScope = app.ApplicationServices.GetService().CreateScope())
        {
            serviceScope.ServiceProvider.GetRequiredService().Database.Migrate();

            var context = serviceScope.ServiceProvider.GetRequiredService();
            context.Database.Migrate();
            if (!context.Clients.Any())
            {
                foreach (var client in Config.Clients)
                {
                    context.Clients.Add(client.ToEntity());
                }
                context.SaveChanges();
            }

            if (!context.IdentityResources.Any())
            {
                foreach (var resource in Config.IdentityResources)
                {
                    context.IdentityResources.Add(resource.ToEntity());
                }
                context.SaveChanges();
            }

            if (!context.ApiScopes.Any())
            {
                foreach (var resource in Config.ApiScopes)
                {
                    context.ApiScopes.Add(resource.ToEntity());
                }
                context.SaveChanges();
            }
        }
    }

The above code may require you to add the following namespaces to your file::

    using System.Linq;
    using IdentityServer8.EntityFramework.DbContexts;
    using IdentityServer8.EntityFramework.Mappers;

And then we can invoke this from the ``Configure`` method::

    public void Configure(IApplicationBuilder app)
    {
        // this will do the initial DB population
        InitializeDatabase(app);

        // the rest of the code that was already here
        // ...
    }

Now if you run the IdentityServer project, the database should be created and seeded with the quickstart configuration data.
You should be able to use SQL Server Management Studio or Visual Studio to connect and inspect the data.

.. image:: images/ef_database.png

.. Note:: The above ``InitializeDatabase`` helper API is convenient to seed the database, but this approach is not ideal to leave in to execute each time the application runs. Once your database is populated, consider removing the call to the API.

Run the client applications
^^^^^^^^^^^^^^^^^^^^^^^^^^^

You should now be able to run any of the existing client applications and sign-in, get tokens, and call the API -- all based upon the database configuration.


================================================
FILE: docs/quickstarts/6_aspnet_identity.rst
================================================
.. _refAspNetIdentityQuickstart:
Using ASP.NET Core Identity
===========================

.. note:: For any pre-requisites (like e.g. templates) have a look at the :ref:`overview ` first.

IdentityServer is designed for flexibility and part of that is allowing you to use any database you want for your users and their data (including passwords).
If you are starting with a new user database, then ASP.NET Core Identity is one option you could choose.
This quickstart shows how to use ASP.NET Core Identity with IdentityServer.

The approach this quickstart takes to using ASP.NET Core Identity is to create a new project for the IdentityServer host.
This new project will replace the prior IdentityServer project we built up in the previous quickstarts.
The reason for this new project is due to the differences in UI assets when using ASP.NET Core Identity (mainly around the differences in login and logout).
All the other projects in this solution (for the clients and the API) will remain the same.

.. Note:: This quickstart assumes you are familiar with how ASP.NET Core Identity works. If you are not, it is recommended that you first `learn about it `_.

New Project for ASP.NET Core Identity
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The first step is to add a new project for ASP.NET Core Identity to your solution.
We provide a template that contains the minimal UI assets needed to ASP.NET Core Identity with IdentityServer.
You will eventually delete the old project for IdentityServer, but there are some items that you will need to migrate over.

Start by creating a new IdentityServer project that will use ASP.NET Core Identity::
    
    cd quickstart/src
    dotnet new is4aspid -n IdentityServerAspNetIdentity

When prompted to "seed" the user database, choose "Y" for "yes".
This populates the user database with our "alice" and "bob" users. 
Their passwords are "Pass123$".

.. Note:: The template uses Sqlite as the database for the users, and EF migrations are pre-created in the template. If you wish to use a different database provider, you will need to change the provider used in the code and re-create the EF migrations.

Inspect the new project
^^^^^^^^^^^^^^^^^^^^^^^

Open the new project in the editor of your choice, and inspect the generated code.
Be sure to look at:

IdentityServerAspNetIdentity.csproj
-----------------------------------

Notice the reference to `IdentityServer8.AspNetIdentity`. 
This NuGet package contains the ASP.NET Core Identity integration components for IdentityServer.

Startup.cs
----------

In `ConfigureServices` notice the necessary ``AddDbContext`` and ``AddIdentity`` calls are done to configure ASP.NET Core Identity.

Also notice that much of the same IdentityServer configuration you did in the previous quickstarts is already done.
The template uses the in-memory style for clients and resources, and those are sourced from `Config.cs`.

Finally, notice the addition of the new call to ``AddAspNetIdentity``.
``AddAspNetIdentity`` adds the integration layer to allow IdentityServer to access the user data for the ASP.NET Core Identity user database.
This is needed when IdentityServer must add claims for the users into tokens.

Note that ``AddIdentity`` must be invoked before ``AddIdentityServer``.

Config.cs
-----------

`Config.cs` contains the hard-coded in-memory clients and resource definitions.
To keep the same clients and API working as the prior quickstarts, we need to copy over the configuration data from the old IdentityServer project into this one.
Do that now, and afterwards `Config.cs` should look like this::

    public static class Config
    {
        public static IEnumerable IdentityResources =>
            new List
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile(),
            };

        public static IEnumerable ApiScopes =>
            new List
            {
                new ApiScope("api1", "My API")
            };

        public static IEnumerable Clients =>
            new List
            {
                // machine to machine client
                new Client
                {
                    ClientId = "client",
                    ClientSecrets = { new Secret("secret".Sha256()) },

                    AllowedGrantTypes = GrantTypes.ClientCredentials,
                    // scopes that client has access to
                    AllowedScopes = { "api1" }
                },
                
                // interactive ASP.NET Core MVC client
                new Client
                {
                    ClientId = "mvc",
                    ClientSecrets = { new Secret("secret".Sha256()) },

                    AllowedGrantTypes = GrantTypes.Code,
                    
                    // where to redirect to after login
                    RedirectUris = { "https://localhost:5002/signin-oidc" },

                    // where to redirect to after logout
                    PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                    AllowedScopes = new List
                    {
                        IdentityServerConstants.StandardScopes.OpenId,
                        IdentityServerConstants.StandardScopes.Profile,
                        "api1"
                    }
                }
            };
    }


At this point, you no longer need the old IdentityServer project.

Program.cs and SeedData.cs
--------------------------

`Program.cs`'s ``Main`` is a little different than most ASP.NET Core projects.
Notice how this looks for a command line argument called `/seed` which is used as a flag to seed the users in the ASP.NET Core Identity database.

Look at the ``SeedData`` class' code to see how the database is created and the first users are created.

AccountController
-----------------

The last code to inspect in this template is the ``AccountController``. 
This contains a slightly different login and logout code than the prior quickstart and templates.
Notice the use of the ``SignInManager`` and ``UserManager`` from ASP.NET Core Identity to validate credentials and manage the authentication session.

Much of the rest of the code is the same from the prior quickstarts and templates.

Logging in with the MVC client
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

At this point, you should be able to run all of the existing clients and samples.
One exception is the `ResourceOwnerClient` -- the password will need to be updated to ``Pass123$`` from ``password``.

Launch the MVC client application, and you should be able to click the "Secure" link to get logged in.

.. image:: images/aspid_mvc_client.png

You should be redirected to the ASP.NET Core Identity login page.
Login with your newly created user:

.. image:: images/aspid_login.png

After login you see the normal consent page. 
After consent you will be redirected back to the MVC client application where your user's claims should be listed.

.. image:: images/aspid_claims.png

You should also be able to click "Call API using application identity" to invoke the API on behalf of the user:

.. image:: images/aspid_api_claims.png

And now you're using users from ASP.NET Core Identity in IdentityServer.

What's Missing?
^^^^^^^^^^^^^^^

Much of the rest of the code in this template is similar to the other quickstart and templates we provide.
The one thing you will notice that is missing from this template is UI code for user registration, password reset, and the other things you might expect from the Visual Studio ASP.NET Core Identity template.

Given the variety of requirements and different approaches to using ASP.NET Core Identity, our template deliberately does not provide those features.
You are expected to know how ASP.NET Core Identity works sufficiently well to add those features to your project.
Alternatively, you can create a new project based on the Visual Studio ASP.NET Core Identity template and add the IdentityServer features you have learned about in these quickstarts to that project.


================================================
FILE: docs/quickstarts/community.rst
================================================
Community quickstarts & samples
===============================
These samples are not maintained by the IdentityServer organization.
The IdentityServer organization happily links to community samples, but can't make any guarantees about the samples.
Please contact the authors directly.

Various ASP.NET Core security samples
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
https://github.com/leastprivilege/AspNetCoreSecuritySamples

Co-hosting IdentityServer8 and a Web API
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
This sample shows how to host an API in the same host as the IdentityServer that is protecting the API.

https://github.com/brockallen/IdentityServerAndApi

IdentityServer8 samples for MongoDB
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* IdentityServer8-mongo: Similar to Quickstart EntityFramework configuration but using MongoDB for the configuration data.
* IdentityServer8-mongo-AspIdentity: More elaborated sample based on uses ASP.NET Identity for identity management that uses using MongoDB for the configuration data

https://github.com/souzartn/IdentityServer8.Samples.Mongo

Exchanging external tokens from Facebook, Google and Twitter
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* Shows how to exchange an external authentication token to an identity server acesss token using an extension grant

https://github.com/waqaskhan540/IdentityServerExternalAuth


.NET Core and ASP.NET Core "Platform" scenario
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* Shows an interaction of trusted "internal" applications and "external" applications with .NET Core 2.0 and ASP.NET Core 2.0 applications
https://github.com/BenjaminAbt/Samples.AspNetCore-IdentityServer8


Securing a Node API with tokens from IdentityServer8 using JWKS
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
* Shows how to secure a Node (Express) API using the JWKS endpoint and RS256 algorithm from IdentityServer8.
* Provides an alternative to the NodeJsApi sample from IdentityServer samples using higher quality - production ready modules.

https://github.com/lyphtec/idsvr4-node-jwks


================================================
FILE: docs/readme.md
================================================
# IdentityServer8 documentation

The folder contains the documentation for IdentityServer8.

We are using [Read the docs](https://readthedocs.org/) to host the documentation and the rendered version
can be found [here](https://IdentityServer8.readthedocs.io).

Doc pages are authored in ReStructuredText (RST) - you can find a primer [here](http://www.sphinx-doc.org/en/stable/rest.html).

You can find more information about RTD and Sphinx under the following links:

* [Read the Docs documentation](https://docs.readthedocs.io/en/latest/index.html)
* [Sphinx](http://www.sphinx-doc.org/)
* [Getting started Screencast](https://www.youtube.com/watch?feature=player_embedded&v=oJsUvBQyHBs)


================================================
FILE: docs/reference/api_resource.rst
================================================
.. _refApiResource:
API Resource
=================
This class models an API resource.

``Enabled``
    Indicates if this resource is enabled and can be requested. Defaults to true.
``Name``
    The unique name of the API. This value is used for authentication with introspection and will be added to the audience of the outgoing access token.
``DisplayName``
    This value can be used e.g. on the consent screen.
``Description``
    This value can be used e.g. on the consent screen.
``ApiSecrets``
    The API secret is used for the introspection endpoint. The API can authenticate with introspection using the API name and secret.
``AllowedAccessTokenSigningAlgorithms``
    List of allowed signing algorithms for access token. If empty, will use the server default signing algorithm.
``UserClaims``
    List of associated user claim types that should be included in the access token.
``Scopes``
    List of API scope names.

Defining API resources in appsettings.json
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
The ``AddInMemoryApiResource`` extensions method also supports adding API resources from the ASP.NET Core configuration file::

    "IdentityServer": {
        "IssuerUri": "urn:sso.company.com",
        "ApiResources": [
            {
                "Name": "resource1",
                "DisplayName": "Resource #1",

                "Scopes": [
                    "resource1.scope1",
                    "shared.scope"
                ]
            },
            {
                "Name": "resource2",
                "DisplayName": "Resource #2",
                
                "UserClaims": [
                    "name",
                    "email"
                ],

                "Scopes": [
                    "resource2.scope1",
                    "shared.scope"
                ]
            }
        ]
    }

Then pass the configuration section to the ``AddInMemoryApiResource`` method::

    AddInMemoryApiResources(configuration.GetSection("IdentityServer:ApiResources"))


================================================
FILE: docs/reference/api_scope.rst
================================================
.. _refApiScope:
API Scope
=================
This class models an OAuth scope.

``Enabled``
    Indicates if this resource is enabled and can be requested. Defaults to true.
``Name``
    The unique name of the API. This value is used for authentication with introspection and will be added to the audience of the outgoing access token.
``DisplayName``
    This value can be used e.g. on the consent screen.
``Description``
    This value can be used e.g. on the consent screen.
``UserClaims``
    List of associated user claim types that should be included in the access token.

Defining API scope in appsettings.json
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The ``AddInMemoryApiResource`` extension method also supports adding clients from the ASP.NET Core configuration file::

    "IdentityServer": {
        "IssuerUri": "urn:sso.company.com",
        "ApiScopes": [
            {
                "Name": "IdentityServerApi"
            },
            {
                "Name": "resource1.scope1"
            },
            {
                "Name": "resource2.scope1"
            },
            {
                "Name": "scope3"
            },
            {
                "Name": "shared.scope"
            },
            {
                "Name": "transaction",
                "DisplayName": "Transaction",
                "Description": "A transaction"
            }
        ]
    }

Then pass the configuration section to the ``AddInMemoryApiScopes`` method::

    AddInMemoryApiScopes(configuration.GetSection("IdentityServer:ApiScopes"))


================================================
FILE: docs/reference/aspnet_identity.rst
================================================
.. _refAspNetId:
ASP.NET Identity Support
========================

An ASP.NET Identity-based implementation is provided for managing the identity database for users of IdentityServer.
This implementation implements the extensibility points in IdentityServer needed to load identity data for your users to emit claims into tokens.

The repo for this support is located `here `_ and the NuGet package is `here `_.

To use this library, configure ASP.NET Identity normally. 
Then use the ``AddAspNetIdentity`` extension method after the call to ``AddIdentityServer``::

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddIdentity()
            .AddEntityFrameworkStores()
            .AddDefaultTokenProviders();

        services.AddIdentityServer()
            .AddAspNetIdentity();
    }

``AddAspNetIdentity`` requires as a generic parameter the class that models your user for ASP.NET Identity (and the same one passed to ``AddIdentity`` to configure ASP.NET Identity).
This configures IdentityServer to use the ASP.NET Identity implementations of ``IUserClaimsPrincipalFactory``, ``IResourceOwnerPasswordValidator``, and ``IProfileService``.
It also configures some of ASP.NET Identity's options for use with IdentityServer (such as claim types to use and authentication cookie settings).

When using your own implementation of ``IUserClaimsPrincipalFactory``, make sure that you register it before calling the IdentityServer ``AddAspNetIdentity`` extension method.

================================================
FILE: docs/reference/client.rst
================================================
.. _refClient:
Client
======
The ``Client`` class models an OpenID Connect or OAuth 2.0 client - 
e.g. a native application, a web application or a JS-based application.

Basics
^^^^^^
``Enabled``
    Specifies if client is enabled. Defaults to `true`.
``ClientId``
    Unique ID of the client
``ClientSecrets``
    List of client secrets - credentials to access the token endpoint.
``RequireClientSecret``
    Specifies whether this client needs a secret to request tokens from the token endpoint (defaults to ``true``)
``RequireRequestObject``
    Specifies whether this client needs to wrap the authorize request parameters in a JWT (defaults to ``false``)
``AllowedGrantTypes``
    Specifies the grant types the client is allowed to use. Use the ``GrantTypes`` class for common combinations.
``RequirePkce``
    Specifies whether clients using an authorization code based grant type must send a proof key (defaults to ``true``).
``AllowPlainTextPkce``
    Specifies whether clients using PKCE can use a plain text code challenge (not recommended - and default to ``false``)
``RedirectUris``
    Specifies the allowed URIs to return tokens or authorization codes to
``AllowedScopes``
    By default a client has no access to any resources - specify the allowed resources by adding the corresponding scopes names
``AllowOfflineAccess``
    Specifies whether this client can request refresh tokens (be requesting the ``offline_access`` scope)
``AllowAccessTokensViaBrowser``
    Specifies whether this client is allowed to receive access tokens via the browser. 
    This is useful to harden flows that allow multiple response types 
    (e.g. by disallowing a hybrid flow client that is supposed to use `code id_token` to add the `token` response type 
    and thus leaking the token to the browser.
``Properties``
    Dictionary to hold any custom client-specific values as needed.

Authentication/Logout
^^^^^^^^^^^^^^^^^^^^^
``PostLogoutRedirectUris``
    Specifies allowed URIs to redirect to after logout. See the `OIDC Connect Session Management spec `_ for more details.
``FrontChannelLogoutUri``
    Specifies logout URI at client for HTTP based front-channel logout. See the `OIDC Front-Channel spec `_ for more details.
``FrontChannelLogoutSessionRequired``
    Specifies if the user's session id should be sent to the FrontChannelLogoutUri. Defaults to true.
``BackChannelLogoutUri``
    Specifies logout URI at client for HTTP based back-channel logout. See the `OIDC Back-Channel spec `_ for more details.
``BackChannelLogoutSessionRequired``
    Specifies if the user's session id should be sent in the request to the BackChannelLogoutUri. Defaults to true.
``EnableLocalLogin``
    Specifies if this client can use local accounts, or external IdPs only. Defaults to `true`.
``IdentityProviderRestrictions``
    Specifies which external IdPs can be used with this client (if list is empty all IdPs are allowed). Defaults to empty.
``UserSsoLifetime`` `added in 2.3`
    The maximum duration (in seconds) since the last time the user authenticated. Defaults to ``null``.
    You can adjust the lifetime of a session token to control when and how often a user is required to reenter credentials instead of being silently authenticated, when using a web application.

Token
^^^^^
``IdentityTokenLifetime``
    Lifetime to identity token in seconds (defaults to 300 seconds / 5 minutes)
``AllowedIdentityTokenSigningAlgorithms``
    List of allowed signing algorithms for identity token. If empty, will use the server default signing algorithm.
``AccessTokenLifetime``
    Lifetime of access token in seconds (defaults to 3600 seconds / 1 hour)
``AuthorizationCodeLifetime``
    Lifetime of authorization code in seconds (defaults to 300 seconds / 5 minutes)
``AbsoluteRefreshTokenLifetime``
    Maximum lifetime of a refresh token in seconds. Defaults to 2592000 seconds / 30 days
``SlidingRefreshTokenLifetime``
    Sliding lifetime of a refresh token in seconds. Defaults to 1296000 seconds / 15 days
``RefreshTokenUsage``
    ``ReUse`` the refresh token handle will stay the same when refreshing tokens
    
    ``OneTime`` the refresh token handle will be updated when refreshing tokens. This is the default.
``RefreshTokenExpiration``
    ``Absolute`` the refresh token will expire on a fixed point in time (specified by the AbsoluteRefreshTokenLifetime). This is the default.
    
    ``Sliding`` when refreshing the token, the lifetime of the refresh token will be renewed (by the amount specified in SlidingRefreshTokenLifetime). The lifetime will not exceed `AbsoluteRefreshTokenLifetime`.
``UpdateAccessTokenClaimsOnRefresh``
    Gets or sets a value indicating whether the access token (and its claims) should be updated on a refresh token request.
``AccessTokenType``
    Specifies whether the access token is a reference token or a self contained JWT token (defaults to `Jwt`).
``IncludeJwtId``
    Specifies whether JWT access tokens should have an embedded unique ID (via the `jti` claim). Defaults to ``true``.
``AllowedCorsOrigins``
    If specified, will be used by the default CORS policy service implementations (In-Memory and EF) to build a CORS policy for JavaScript clients.
``Claims``
    Allows settings claims for the client (will be included in the access token).
``AlwaysSendClientClaims``
    If set, the client claims will be sent for every flow. If not, only for client credentials flow (default is `false`)
``AlwaysIncludeUserClaimsInIdToken``
    When requesting both an id token and access token, should the user claims always be added to the id token instead of requiring the client to use the userinfo endpoint. Default is `false`.
``ClientClaimsPrefix``
    If set, the prefix client claim types will be prefixed with. Defaults to `client_`. The intent is to make sure they don't accidentally collide with user claims.
``PairWiseSubjectSalt``
    Salt value used in pair-wise subjectId generation for users of this client.

Consent Screen
^^^^^^^^^^^^^^
``RequireConsent``
    Specifies whether a consent screen is required. Defaults to ``false``.
``AllowRememberConsent``
    Specifies whether user can choose to store consent decisions. Defaults to ``true``.
``ConsentLifetime``
    Lifetime of a user consent in seconds. Defaults to null (no expiration).
``ClientName``
    Client display name (used for logging and consent screen)
``ClientUri``
    URI to further information about client (used on consent screen)
``LogoUri``
    URI to client logo (used on consent screen)

Device flow
^^^^^^^^^^^
``UserCodeType``
    Specifies the type of user code to use for the client. Otherwise falls back to default.
``DeviceCodeLifetime``
    Lifetime to device code in seconds (defaults to 300 seconds / 5 minutes)


================================================
FILE: docs/reference/deviceflow_interactionservice.rst
================================================
Device Flow Interaction Service
==================================

The ``IDeviceFlowInteractionService`` interface is intended to provide services to be used by the user interface to communicate with IdentityServer during device flow authorization.
It is available from the dependency injection system and would normally be injected as a constructor parameter into your MVC controllers for the user interface of IdentityServer.

IDeviceFlowInteractionService APIs
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

``GetAuthorizationContextAsync``
    Returns the ``DeviceFlowAuthorizationRequest`` based on the ``userCode`` passed to the login or consent pages.

``DeviceFlowInteractionResult``
    Completes device authorization for the given ``userCode``.

DeviceFlowAuthorizationRequest
^^^^^^^^^^^^^^^^^^^^
``ClientId``
    The client identifier that initiated the request.
``ScopesRequested``
    The scopes requested from the authorization request.

DeviceFlowInteractionResult
^^^^^^^^^^^^^^^^^^^^^^^^^^^
``IsError``
    Specifies if the authorization request errored.
``ErrorDescription``
    Error description upon failure.


================================================
FILE: docs/reference/ef.rst
================================================
.. _refEF:
Entity Framework Support
========================

An EntityFramework-based implementation is provided for the configuration and operational data extensibility points in IdentityServer.
The use of EntityFramework allows any EF-supported database to be used with this library.

The code for this library is located `here `_ (with the underlying storage code `here `_) and the NuGet package is `here `_.

The features provided by this library are broken down into two main areas: configuration store and operational store support.
These two different areas can be used independently or together, based upon the needs of the hosting application.

Configuration Store support for Clients, Resources, and CORS settings
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

If client, identity resource, API resource, or CORS data is desired to be loaded from a EF-supported database 
(rather than use in-memory configuration), then the configuration store can be used.
This support provides implementations of the ``IClientStore``, ``IResourceStore``, and the ``ICorsPolicyService`` extensibility points.
These implementations use a ``DbContext``-derived class called ``ConfigurationDbContext`` to model the tables in the database.

To use the configuration store support, use the ``AddConfigurationStore`` extension method after the call to ``AddIdentityServer``::

    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer8.EntityFramework-2.0.0;trusted_connection=yes;";
        var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
        
        services.AddIdentityServer()
            // this adds the config data from DB (clients, resources, CORS)
            .AddConfigurationStore(options =>
            {
                options.ConfigureDbContext = builder =>
                    builder.UseSqlServer(connectionString,
                        sql => sql.MigrationsAssembly(migrationsAssembly));
            });
    }

To configure the configuration store, use the ``ConfigurationStoreOptions`` options object passed to the configuration callback.

ConfigurationStoreOptions
^^^^^^^^^^^^^^^^^^^^^^^^^
This options class contains properties to control the configuration store and ``ConfigurationDbContext``.

``ConfigureDbContext``
    Delegate of type ``Action`` used as a callback to configure the underlying ``ConfigurationDbContext``.
    The delegate can configure the ``ConfigurationDbContext`` in the same way if EF were being used directly with ``AddDbContext``, which allows any EF-supported database to be used.
``DefaultSchema``
    Allows setting the default database schema name for all the tables in the ``ConfigurationDbContext``
    ::
            options.DefaultSchema = "myConfigurationSchema";      

If you need to change the schema for the Migration History Table, you can chain another action to the ``UseSqlServer``::

    options.ConfigureDbContext = b =>
        b.UseSqlServer(connectionString,
            sql => sql.MigrationsAssembly(migrationsAssembly).MigrationsHistoryTable("MyConfigurationMigrationTable", "myConfigurationSchema"));

Operational Store support for persisted grants
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

If :ref:`persisted grants ` are desired to be loaded from a EF-supported database (rather than the default in-memory database), then the operational store can be used.
This support provides implementations of the ``IPersistedGrantStore`` extensibility point.
The implementation uses a ``DbContext``-derived class called ``PersistedGrantDbContext`` to model the table in the database.

To use the operational store support, use the ``AddOperationalStore`` extension method after the call to ``AddIdentityServer``::

    public IServiceProvider ConfigureServices(IServiceCollection services)
    {
        const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer8.EntityFramework-2.0.0;trusted_connection=yes;";
        var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
        
        services.AddIdentityServer()
            // this adds the operational data from DB (codes, tokens, consents)
            .AddOperationalStore(options =>
            {
                options.ConfigureDbContext = builder =>
                    builder.UseSqlServer(connectionString,
                        sql => sql.MigrationsAssembly(migrationsAssembly));

                // this enables automatic token cleanup. this is optional.
                options.EnableTokenCleanup = true;
                options.TokenCleanupInterval = 3600; // interval in seconds (default is 3600)
            });
    }

To configure the operational store, use the ``OperationalStoreOptions`` options object passed to the configuration callback.

OperationalStoreOptions
^^^^^^^^^^^^^^^^^^^^^^^
This options class contains properties to control the operational store and ``PersistedGrantDbContext``.

``ConfigureDbContext``
    Delegate of type ``Action`` used as a callback to configure the underlying ``PersistedGrantDbContext``.
    The delegate can configure the ``PersistedGrantDbContext`` in the same way if EF were being used directly with ``AddDbContext``, which allows any EF-supported database to be used.
``DefaultSchema``
    Allows setting the default database schema name for all the tables in the ``PersistedGrantDbContext``.
``EnableTokenCleanup``
    Indicates whether expired grants will be automatically cleaned up from the database. The default is ``false``.
``TokenCleanupInterval``
    The token cleanup interval (in seconds). The default is 3600 (1 hour).

.. note:: The token cleanup feature does *not* remove persisted grants that are *consumed* (see :ref:`persisted grants `).

Database creation and schema changes across different versions of IdentityServer
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

It is very likely that across different versions of IdentityServer (and the EF support) that the database schema will change to accommodate new and changing features.

We do not provide any support for creating your database or migrating your data from one version to another. 
You are expected to manage the database creation, schema changes, and data migration in any way your organization sees fit.

Using EF migrations is one possible approach to this. 
If you do wish to use migrations, then see the :ref:`EF quickstart ` for samples on how to get started, or consult the Microsoft `documentation on EF migrations `_.

We also publish `sample SQL scripts `_ for the current version of the database schema.


================================================
FILE: docs/reference/grant_validation_result.rst
================================================
.. _refGrantValidationResult:
GrantValidationResult
=====================

The ``GrantValidationResult`` class models the outcome of grant validation for extensions grants and resource owner password grants.

The most common usage is to either new it up using an identity (success case)::

    context.Result = new GrantValidationResult(
        subject: "818727", 
        authenticationMethod: "custom", 
        claims: optionalClaims);

...or using an error and description (failure case)::

    context.Result = new GrantValidationResult(
        TokenRequestErrors.InvalidGrant, 
        "invalid custom credential");

In both case you can pass additional custom values that will be included in the token response.

================================================
FILE: docs/reference/identity_resource.rst
================================================
.. _refIdentityResource:
Identity Resource
=================

This class models an identity resource.

``Enabled``
    Indicates if this resource is enabled and can be requested. Defaults to true.
``Name``
    The unique name of the identity resource. This is the value a client will use for the scope parameter in the authorize request.
``DisplayName``
    This value will be used e.g. on the consent screen.
``Description``
    This value will be used e.g. on the consent screen.
``Required``
    Specifies whether the user can de-select the scope on the consent screen (if the consent screen wants to implement such a feature). Defaults to false.
``Emphasize``
    Specifies whether the consent screen will emphasize this scope (if the consent screen wants to implement such a feature). Use this setting for sensitive or important scopes. Defaults to false.
``ShowInDiscoveryDocument``
    Specifies whether this scope is shown in the discovery document. Defaults to true.
``UserClaims``
    List of associated user claim types that should be included in the identity token.

================================================
FILE: docs/reference/interactionservice.rst
================================================
.. _refInteractionService:
IdentityServer Interaction Service
==================================

The ``IIdentityServerInteractionService`` interface is intended to provide services to be used by the user interface to communicate with IdentityServer, mainly pertaining to user interaction.
It is available from the dependency injection system and would normally be injected as a constructor parameter into your MVC controllers for the user interface of IdentityServer.

IIdentityServerInteractionService APIs
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

``GetAuthorizationContextAsync``
    Returns the ``AuthorizationRequest`` based on the ``returnUrl`` passed to the login or consent pages.

``IsValidReturnUrl``
    Indicates if the ``returnUrl`` is a valid URL for redirect after login or consent.

``GetErrorContextAsync``
    Returns the ``ErrorMessage`` based on the ``errorId`` passed to the error page.

``GetLogoutContextAsync``
    Returns the ``LogoutRequest`` based on the ``logoutId`` passed to the logout page.

``CreateLogoutContextAsync``
    Used to create a ``logoutId`` if there is not one presently.
    This creates a cookie capturing all the current state needed for signout and the ``logoutId`` identifies that cookie.
    This is typically used when there is no current ``logoutId`` and the logout page must capture the current user's state needed for sign-out prior to redirecting to an external identity provider for signout.
    The newly created ``logoutId`` would need to be round-tripped to the external identity provider at signout time, and then used on the signout callback page in the same way it would be on the normal logout page.

``GrantConsentAsync``
    Accepts a ``ConsentResponse`` to inform IdentityServer of the user's consent to a particular ``AuthorizationRequest``.

``DenyAuthorizationAsync``
    Accepts a ``AuthorizationError`` to inform IdentityServer of the error to return to the client for a particular ``AuthorizationRequest``.

``GetAllUserGrantsAsync``
    Returns a collection of ``Grant`` for the user. These represent a user's consent or a clients access to a user's resource.

``RevokeUserConsentAsync``
    Revokes all of a user's consents and grants for a client.

``RevokeTokensForCurrentSessionAsync``
    Revokes all of a user's consents and grants for clients the user has signed into during their current session.

AuthorizationRequest
^^^^^^^^^^^^^^^^^^^^
``Client``
    The client that initiated the request.
``RedirectUri``
    The URI to redirect the user to after successful authorization.
``DisplayMode``
    The display mode passed from the authorization request.
``UiLocales``
    The UI locales passed from the authorization request.
``IdP``
    The external identity provider requested.
    This is used to bypass home realm discovery (HRD).
    This is provided via the "idp:" prefix to the ``acr_values`` parameter on the authorize request.
``Tenant``
    The tenant requested.
    This is provided via the "tenant:" prefix to the ``acr_values`` parameter on the authorize request.
``LoginHint``
    The expected username the user will use to login.
    This is requested from the client via the ``login_hint`` parameter on the authorize request.
``PromptMode``
    The prompt mode requested from the authorization request.
``AcrValues``
    The acr values passed from the authorization request.
``ValidatedResources``
    The ``ResourceValidationResult`` which represents the validated resources from the authorization request.
``Parameters``
    The entire parameter collection passed to the authorization request.
``RequestObjectValues``
    The validated contents of the request object (if present).

ResourceValidationResult
^^^^^^^^^^^^^^^^^^^^^^^^
``Resources``
    The resources of the result.
``ParsedScopes``
    The parsed scopes represented by the result.
``RawScopeValues``
    The original (raw) scope values represented by the validated result.

ErrorMessage
^^^^^^^^^^^^
``DisplayMode``
    The display mode passed from the authorization request.
``UiLocales``
    The UI locales passed from the authorization request.
``Error``
    The error code.
``RequestId``
    The per-request identifier. This can be used to display to the end user and can be used in diagnostics.

LogoutRequest
^^^^^^^^^^^^^
``ClientId``
    The client identifier that initiated the request.
``PostLogoutRedirectUri``
    The URL to redirect the user to after they have logged out.
``SessionId``
    The user's current session id.
``SignOutIFrameUrl``
    The URL to render in an ``
    }


@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel



    

        
Logout

        
Would you like to logout of IdentityServer?

    


    

        
        

            
        

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel



    

        @if (Model.ClientLogoUrl != null)
        {
            
        }
        

            @Model.ClientName
            is requesting your permission
        

        
Uncheck the permissions you do not wish to grant.

    


    

        

            
        

    


    

        
        

            

                @if (Model.IdentityScopes.Any())
                {
                    

                        

                            

                                
                                Personal Information
                            

                            
    
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            

                        

                    

                }

                @if (Model.ApiScopes.Any())
                {
                    

                        

                            

                                
                                Application Access
                            

                            
    
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            

                        

                    

                }

                

                    

                        

                            
                            Description
                        

                        

                            
                        

                    

                


                @if (Model.AllowRememberConsent)
                {
                    

                        

                            
                            
                        

                    

                }
            

        


        

            

                
                
            

            

                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            

        

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Device/Success.cshtml
================================================



    

        
Success

        
You have successfully authorized the device

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Device/UserCodeCapture.cshtml
================================================
@model string



    

        
User Code

        
Please enter the code displayed on your device.

    


    

    

        

            

                

                    
                    
                


                
            

        

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel



    

        @if (Model.ClientLogoUrl != null)
        {
            
        }
        

            @Model.ClientName
            is requesting your permission
        

        @if (Model.ConfirmUserCode)
        {
            
Please confirm that the authorization request quotes the code: @Model.UserCode.

        }
        
Uncheck the permissions you do not wish to grant.

    


    

        

            
        

    


    

        
        

            

                @if (Model.IdentityScopes.Any())
                {
                    

                        

                            

                                
                                Personal Information
                            

                            
    
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            

                        

                    

                }

                @if (Model.ApiScopes.Any())
                {
                    

                        

                            

                                
                                Application Access
                            

                            
    
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            

                        

                    

                }

                

                    

                        

                            
                            Description
                        

                        

                            
                        

                    

                


                @if (Model.AllowRememberConsent)
                {
                    

                        

                            
                            
                        

                    

                }
            

        


        

            

                
                
            

            

                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            

        

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel



    

        
Authentication Cookie

    


    

        

            

                

                    
Claims

                

                

                    

                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
@claim.Type

                            
@claim.Value

                        }
                    

                

            

        

        
        

            

                

                    
Properties

                

                

                    

                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
@prop.Key

                            
@prop.Value

                        }
                        @if (Model.Clients.Any())
                        {
                            
Clients

                            

                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            

                        }
                    

                

            

        

    









================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel



    

        
Client Application Permissions

        
Below is the list of applications you have given permission to and the resources they have access to.

    


    @if (Model.Grants.Any() == false)
    {
        

            

                

                    You have not given access to any applications
                

            

        

    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            

                

                    

                        

                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        


                        

                            

                                
                                
                            

                        

                    

                

                
                
    
                    @if (grant.Description != null)
                    {
                        
  • 
                             @grant.Description
                        
    •    
                    }
                    
  • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
    • 
                    @if (grant.Expires.HasValue)
                    {
                        
  • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
    • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
  • 
                            
                            
      
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
    • @name
      • 
                                }
                            
    
                        
    • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
  • 
                            
                            
      
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
    • @name
      • 
                                }
                            
    
                        
    • 
                    }
                

            

        }
    }



================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}



    

        
        Welcome to IdentityServer8
        (version @version)
    


    




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}



    

        
Error

    


    

        

            

                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
@errorDescription

                    }
                }
            


            @if (request_id != null)
            {
                
Request Id: @request_id

            }
        

    





================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;


    

        
You are now being returned to the application

        
Once complete, you may close this tab.

    








================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    

        @RenderBody()
    


    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}



    




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/IdentityServer/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/MvcClient.csproj
================================================


  
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/2_InteractiveAspNetCore/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/Quickstart.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BD8BA25C-A91D-419D-99B6-B575ADD6D061}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer", "src\IdentityServer\IdentityServer.csproj", "{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MvcClient", "src\MvcClient\MvcClient.csproj", "{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Api", "..\Shared\src\Api\Api.csproj", "{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Client", "..\Shared\src\Client\Client.csproj", "{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.Build.0 = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|x64.ActiveCfg = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|x64.Build.0 = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|x86.ActiveCfg = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Debug|x86.Build.0 = Debug|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|Any CPU.Build.0 = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|x64.ActiveCfg = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|x64.Build.0 = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|x86.ActiveCfg = Release|Any CPU
		{FB7DDF43-1EB6-4FBF-B83D-6E19F723D7E4}.Release|x86.Build.0 = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|x64.ActiveCfg = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|x64.Build.0 = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|x86.ActiveCfg = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Debug|x86.Build.0 = Debug|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|Any CPU.Build.0 = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|x64.ActiveCfg = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|x64.Build.0 = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|x86.ActiveCfg = Release|Any CPU
		{78C0AEF8-E8B7-4F62-948C-FEFBF0ED881B}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {84D5AF06-1243-46F1-9D58-70ED572832C3}
	EndGlobalSection
EndGlobal


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/Quickstart.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft
 Written by Alexander Higgins https://github.com/alexhiggins732/ 
 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code for this software can be found at https://github.com/alexhiggins732/IdentityServer8

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

*/


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Secret = IdentityServer8.Models.Secret;

public static class Config
{
    public static IEnumerable IdentityResources =>
        new List
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
        };


    public static IEnumerable ApiScopes =>
        new List
        {
            new ApiScope("api1", "My API")
        };

    public static IEnumerable Clients =>
        new List
        {
            // machine to machine client
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                // scopes that client has access to
                AllowedScopes = { "api1" }
            },
            
            // interactive ASP.NET Core MVC client
            new Client
            {
                ClientId = "mvc",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.Code,
                
                // where to redirect to after login
                RedirectUris = { "https://localhost:5002/signin-oidc" },

                // where to redirect to after logout
                PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                AllowedScopes = new List
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    "api1"
                }
            }
        };
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Options;
global using Microsoft.IdentityModel.Tokens;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System;
global using System.ComponentModel.DataAnnotations;
global using System.Security.Claims;
global using System.Text;
global using System.Text.Json;
global using static IdentityModel.JwtClaimTypes;
global using IdentityServerClaimValueTypes = IdentityServer8.IdentityServerConstants.ClaimValueTypes;


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/IdentityServer.csproj
================================================

  
    
    

    
  



================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

ConfigureLogger();

try
{
    Log.Information("Starting host...");

    var builder = WebApplication.CreateBuilder(args);

    var services = builder.Services;

    services.AddControllersWithViews();

    services
        .AddIdentityServer()
        .AddInMemoryIdentityResources(Config.IdentityResources)
        .AddInMemoryApiScopes(Config.ApiScopes)
        .AddInMemoryClients(Config.Clients)
        .AddTestUsers(TestUsers.Users)
        .AddDeveloperSigningCredential();

    services.AddAuthentication()
        .AddGoogle("Google", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

            options.ClientId = "";
            options.ClientSecret = "";
        })
        .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
            options.SignOutScheme = IdentityServerConstants.SignoutScheme;
            options.SaveTokens = true;

            options.Authority = "https://demo.identityserver8.io/";
            options.ClientId = "interactive.confidential";
            options.ClientSecret = "secret";
            options.ResponseType = "code";

            options.TokenValidationParameters = new()
            {
                NameClaimType = "name",
                RoleClaimType = "role"
            };
        });


    using (var app = builder.Build())
    {
        if (app.Environment.IsDevelopment())
            app.UseDeveloperExceptionPage();

        app.UseStaticFiles()
            .UseRouting()
            .UseIdentityServer()
            .UseAuthorization();

        app.MapDefaultControllerRoute();

        await app.RunAsync();
    }

    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host terminated unexpectedly.");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}


void ConfigureLogger() => Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
    .Enrich.FromLogContext()
    // uncomment to write to Azure diagnostics stream
    //.WriteTo.File(
    //    @"D:\home\LogFiles\Application\identityserver.txt",
    //    fileSizeLimitBytes: 1_000_000,
    //    rollOnFileSizeLimit: true,
    //    shared: true,
    //    flushToDiskInterval: TimeSpan.FromSeconds(1))
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
    .CreateLogger();


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI
{
    public class AccountOptions
    {
        public static bool AllowLocalLogin = true;
        public static bool AllowRememberLogin = true;
        public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

        public static bool ShowLogoutPrompt = true;
        public static bool AutomaticRedirectAfterSignOut = false;

        public static string InvalidCredentialsErrorMessage = "Invalid username or password";
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonSerializer.Deserialize(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{

    static readonly object UserAddress = new
    {
        street_address = "One Hacker Way",
        locality = "Heidelberg",
        postal_code = 69118,
        country = "Germany"
    };

    public static List Users => new List
    {
        new()
        {
            SubjectId = "818727",
            Username = "alice",
            Password = "alice",
            Claims =
            {
                new (Name, "Alice Smith"),
                new (GivenName, "Alice"),
                new (FamilyName, "Smith"),
                new (Email, "AliceSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://alice.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        },
        new()
        {
            SubjectId = "88421113",
            Username = "bob",
            Password = "bob",
            Claims =
            {
                new (Name, "Bob Smith"),
                new (GivenName, "Bob"),
                new (FamilyName, "Smith"),
                new (Email, "BobSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://bob.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        }
    };
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    






================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/IdentityServer/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/MvcClient.csproj
================================================


  
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/3_AspNetCoreAndApis/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/Quickstart.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BD8BA25C-A91D-419D-99B6-B575ADD6D061}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer", "src\IdentityServer\IdentityServer.csproj", "{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MvcClient", "src\MvcClient\MvcClient.csproj", "{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "JavaScriptClient", "src\JavaScriptClient\JavaScriptClient.csproj", "{DD8D4022-0073-40EE-84F0-8E4833522BB9}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Api", "..\Shared\src\Api\Api.csproj", "{8D0EA8BB-7B55-4F60-8011-EF220103BADB}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Client", "..\Shared\src\Client\Client.csproj", "{8FC8CFB9-740B-4D13-B396-99283AA758AC}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.Build.0 = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|x64.ActiveCfg = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|x64.Build.0 = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|x86.ActiveCfg = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Debug|x86.Build.0 = Debug|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|Any CPU.Build.0 = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|x64.ActiveCfg = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|x64.Build.0 = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|x86.ActiveCfg = Release|Any CPU
		{DD8D4022-0073-40EE-84F0-8E4833522BB9}.Release|x86.Build.0 = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|x64.ActiveCfg = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|x64.Build.0 = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|x86.ActiveCfg = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Debug|x86.Build.0 = Debug|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|Any CPU.Build.0 = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|x64.ActiveCfg = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|x64.Build.0 = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|x86.ActiveCfg = Release|Any CPU
		{8D0EA8BB-7B55-4F60-8011-EF220103BADB}.Release|x86.Build.0 = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|x64.ActiveCfg = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|x64.Build.0 = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|x86.ActiveCfg = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Debug|x86.Build.0 = Debug|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|Any CPU.Build.0 = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|x64.ActiveCfg = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|x64.Build.0 = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|x86.ActiveCfg = Release|Any CPU
		{8FC8CFB9-740B-4D13-B396-99283AA758AC}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
		{DD8D4022-0073-40EE-84F0-8E4833522BB9} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {84D5AF06-1243-46F1-9D58-70ED572832C3}
	EndGlobalSection
EndGlobal


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/Quickstart.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft
 Written by Alexander Higgins https://github.com/alexhiggins732/ 
 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code for this software can be found at https://github.com/alexhiggins732/IdentityServer8

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

*/


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Secret = IdentityServer8.Models.Secret;

public static class Config
{
    public static IEnumerable IdentityResources =>
        new List
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
        };


    public static IEnumerable ApiScopes =>
        new List
        {
            new ApiScope("api1", "My API")
        };

    public static IEnumerable Clients =>
        new List
        {
            // machine to machine client
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                // scopes that client has access to
                AllowedScopes = { "api1" }
            },
            
            // interactive ASP.NET Core MVC client
            new Client
            {
                ClientId = "mvc",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.Code,
                
                // where to redirect to after login
                RedirectUris = { "https://localhost:5002/signin-oidc" },

                // where to redirect to after logout
                PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                AllowedScopes = new List
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    "api1"
                }
            }
        };
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Options;
global using Microsoft.IdentityModel.Tokens;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System;
global using System.ComponentModel.DataAnnotations;
global using System.Security.Claims;
global using System.Text;
global using System.Text.Json;
global using static IdentityModel.JwtClaimTypes;
global using IdentityServerClaimValueTypes = IdentityServer8.IdentityServerConstants.ClaimValueTypes;

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/IdentityServer.csproj
================================================

  
    
      
    
  



================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

ConfigureLogger();

try
{
    Log.Information("Starting host...");

    var builder = WebApplication.CreateBuilder(args);

    var services = builder.Services;

    services.AddControllersWithViews();

    services
        .AddIdentityServer()
        .AddInMemoryIdentityResources(Config.IdentityResources)
        .AddInMemoryApiScopes(Config.ApiScopes)
        .AddInMemoryClients(Config.Clients)
        .AddTestUsers(TestUsers.Users)
        .AddDeveloperSigningCredential();

    services.AddAuthentication()
        .AddGoogle("Google", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

            options.ClientId = "";
            options.ClientSecret = "";
        })
        .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
            options.SignOutScheme = IdentityServerConstants.SignoutScheme;
            options.SaveTokens = true;

            options.Authority = "https://demo.identityserver8.io/";
            options.ClientId = "interactive.confidential";
            options.ClientSecret = "secret";
            options.ResponseType = "code";

            options.TokenValidationParameters = new()
            {
                NameClaimType = "name",
                RoleClaimType = "role"
            };
        });


    using (var app = builder.Build())
    {
        if (app.Environment.IsDevelopment())
            app.UseDeveloperExceptionPage();

        app.UseStaticFiles()
            .UseRouting()
            .UseIdentityServer()
            .UseAuthorization();

        app.MapDefaultControllerRoute();

        await app.RunAsync();
    }

    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host terminated unexpectedly.");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}


void ConfigureLogger() => Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
    .Enrich.FromLogContext()
    // uncomment to write to Azure diagnostics stream
    //.WriteTo.File(
    //    @"D:\home\LogFiles\Application\identityserver.txt",
    //    fileSizeLimitBytes: 1_000_000,
    //    rollOnFileSizeLimit: true,
    //    shared: true,
    //    flushToDiskInterval: TimeSpan.FromSeconds(1))
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
    .CreateLogger();


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI
{
    public class AccountOptions
    {
        public static bool AllowLocalLogin = true;
        public static bool AllowRememberLogin = true;
        public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

        public static bool ShowLogoutPrompt = true;
        public static bool AutomaticRedirectAfterSignOut = false;

        public static string InvalidCredentialsErrorMessage = "Invalid username or password";
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonSerializer.Deserialize(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{

    static readonly object UserAddress = new
    {
        street_address = "One Hacker Way",
        locality = "Heidelberg",
        postal_code = 69118,
        country = "Germany"
    };

    public static List Users => new List
    {
        new()
        {
            SubjectId = "818727",
            Username = "alice",
            Password = "alice",
            Claims =
            {
                new (Name, "Alice Smith"),
                new (GivenName, "Alice"),
                new (FamilyName, "Smith"),
                new (Email, "AliceSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://alice.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        },
        new()
        {
            SubjectId = "88421113",
            Username = "bob",
            Password = "bob",
            Claims =
            {
                new (Name, "Bob Smith"),
                new (GivenName, "Bob"),
                new (FamilyName, "Smith"),
                new (Email, "BobSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://bob.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        }
    };
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8;
using IdentityServerHost.Quickstart.UI;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.IdentityModel.Tokens;

namespace IdentityServer
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

            var builder = services.AddIdentityServer()
                .AddInMemoryIdentityResources(Config.IdentityResources)
                .AddInMemoryApiScopes(Config.ApiScopes)
                .AddInMemoryClients(Config.Clients)
                .AddTestUsers(TestUsers.Users);

            builder.AddDeveloperSigningCredential();

            services.AddAuthentication()
                .AddGoogle("Google", options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

                    options.ClientId = "";
                    options.ClientSecret = "";
                })
                .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                    options.SignOutScheme = IdentityServerConstants.SignoutScheme;
                    options.SaveTokens = true;

                    options.Authority = "https://demo.identityserver8.io/";
                    options.ClientId = "interactive.confidential";
                    options.ClientSecret = "secret";
                    options.ResponseType = "code";

                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        NameClaimType = "name",
                        RoleClaimType = "role"
                    };
                });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseStaticFiles();
            app.UseRouting();

            app.UseIdentityServer();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute();
            });
        }
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/wwwroot/js/signin-redirect.js
================================================
// window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/IdentityServer/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/JavaScriptClient.csproj
================================================





================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

var app = WebApplication.Create(args);
app.UseDefaultFiles();
app.UseStaticFiles();
await app.RunAsync();


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:5003",
      "sslPort": 0
    }
  },
  "profiles": {
    "JavaScriptClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5003"
    }
  }
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Builder;

namespace JavaScriptClient
{
    public class Startup
    {
        public void Configure(IApplicationBuilder app)
        {
            app.UseDefaultFiles();
            app.UseStaticFiles();
        }
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Warning"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/wwwroot/app.js
================================================
/// 

function log() {
    document.getElementById('results').innerText = '';

    Array.prototype.forEach.call(arguments, function (msg) {
        if (msg instanceof Error) {
            msg = "Error: " + msg.message;
        }
        else if (typeof msg !== 'string') {
            msg = JSON.stringify(msg, null, 2);
        }
        document.getElementById('results').innerText += msg + '\r\n';
    });
}

document.getElementById("login").addEventListener("click", login, false);
document.getElementById("api").addEventListener("click", api, false);
document.getElementById("logout").addEventListener("click", logout, false);

var config = {
    authority: "https://localhost:5001",
    client_id: "js",
    redirect_uri: "https://localhost:5003/callback.html",
    response_type: "code",
    scope:"openid profile api1",
    post_logout_redirect_uri : "https://localhost:5003/index.html",
};
var mgr = new Oidc.UserManager(config);

mgr.getUser().then(function (user) {
    if (user) {
        log("User logged in", user.profile);
    }
    else {
        log("User not logged in");
    }
});

function login() {
    mgr.signinRedirect();
}

function api() {
    mgr.getUser().then(function (user) {
        var url = "https://localhost:6001/identity";

        var xhr = new XMLHttpRequest();
        xhr.open("GET", url);
        xhr.onload = function () {
            log(xhr.status, JSON.parse(xhr.responseText));
        }
        xhr.setRequestHeader("Authorization", "Bearer " + user.access_token);
        xhr.send();
    });
}

function logout() {
    mgr.signoutRedirect();
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/wwwroot/callback.html
================================================



    
    


    
    




================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/wwwroot/index.html
================================================



    
    


    
    
    

    
    

    
    



================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/JavaScriptClient/wwwroot/oidc-client.js
================================================
var Oidc =
/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId]) {
/******/ 			return installedModules[moduleId].exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			i: moduleId,
/******/ 			l: false,
/******/ 			exports: {}
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.l = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// define getter function for harmony exports
/******/ 	__webpack_require__.d = function(exports, name, getter) {
/******/ 		if(!__webpack_require__.o(exports, name)) {
/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ 		}
/******/ 	};
/******/
/******/ 	// define __esModule on exports
/******/ 	__webpack_require__.r = function(exports) {
/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 		}
/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
/******/ 	};
/******/
/******/ 	// create a fake namespace object
/******/ 	// mode & 1: value is a module id, require it
/******/ 	// mode & 2: merge all properties of value into the ns
/******/ 	// mode & 4: return value when already ns object
/******/ 	// mode & 8|1: behave like require
/******/ 	__webpack_require__.t = function(value, mode) {
/******/ 		if(mode & 1) value = __webpack_require__(value);
/******/ 		if(mode & 8) return value;
/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ 		var ns = Object.create(null);
/******/ 		__webpack_require__.r(ns);
/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ 		return ns;
/******/ 	};
/******/
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = function(module) {
/******/ 		var getter = module && module.__esModule ?
/******/ 			function getDefault() { return module['default']; } :
/******/ 			function getModuleExports() { return module; };
/******/ 		__webpack_require__.d(getter, 'a', getter);
/******/ 		return getter;
/******/ 	};
/******/
/******/ 	// Object.prototype.hasOwnProperty.call
/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(__webpack_require__.s = 0);
/******/ })
/************************************************************************/
/******/ ({

/***/ "./index.js":
/*!******************!*\
  !*** ./index.js ***!
  \******************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _Log = __webpack_require__(/*! ./src/Log.js */ "./src/Log.js");

var _OidcClient = __webpack_require__(/*! ./src/OidcClient.js */ "./src/OidcClient.js");

var _OidcClientSettings = __webpack_require__(/*! ./src/OidcClientSettings.js */ "./src/OidcClientSettings.js");

var _WebStorageStateStore = __webpack_require__(/*! ./src/WebStorageStateStore.js */ "./src/WebStorageStateStore.js");

var _InMemoryWebStorage = __webpack_require__(/*! ./src/InMemoryWebStorage.js */ "./src/InMemoryWebStorage.js");

var _UserManager = __webpack_require__(/*! ./src/UserManager.js */ "./src/UserManager.js");

var _AccessTokenEvents = __webpack_require__(/*! ./src/AccessTokenEvents.js */ "./src/AccessTokenEvents.js");

var _MetadataService = __webpack_require__(/*! ./src/MetadataService.js */ "./src/MetadataService.js");

var _CordovaPopupNavigator = __webpack_require__(/*! ./src/CordovaPopupNavigator.js */ "./src/CordovaPopupNavigator.js");

var _CordovaIFrameNavigator = __webpack_require__(/*! ./src/CordovaIFrameNavigator.js */ "./src/CordovaIFrameNavigator.js");

var _CheckSessionIFrame = __webpack_require__(/*! ./src/CheckSessionIFrame.js */ "./src/CheckSessionIFrame.js");

var _TokenRevocationClient = __webpack_require__(/*! ./src/TokenRevocationClient.js */ "./src/TokenRevocationClient.js");

var _SessionMonitor = __webpack_require__(/*! ./src/SessionMonitor.js */ "./src/SessionMonitor.js");

var _Global = __webpack_require__(/*! ./src/Global.js */ "./src/Global.js");

var _User = __webpack_require__(/*! ./src/User.js */ "./src/User.js");

var _version = __webpack_require__(/*! ./version.js */ "./version.js");

// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

exports.default = {
    Version: _version.Version,
    Log: _Log.Log,
    OidcClient: _OidcClient.OidcClient,
    OidcClientSettings: _OidcClientSettings.OidcClientSettings,
    WebStorageStateStore: _WebStorageStateStore.WebStorageStateStore,
    InMemoryWebStorage: _InMemoryWebStorage.InMemoryWebStorage,
    UserManager: _UserManager.UserManager,
    AccessTokenEvents: _AccessTokenEvents.AccessTokenEvents,
    MetadataService: _MetadataService.MetadataService,
    CordovaPopupNavigator: _CordovaPopupNavigator.CordovaPopupNavigator,
    CordovaIFrameNavigator: _CordovaIFrameNavigator.CordovaIFrameNavigator,
    CheckSessionIFrame: _CheckSessionIFrame.CheckSessionIFrame,
    TokenRevocationClient: _TokenRevocationClient.TokenRevocationClient,
    SessionMonitor: _SessionMonitor.SessionMonitor,
    Global: _Global.Global,
    User: _User.User
};
module.exports = exports['default'];

/***/ }),

/***/ "./jsrsasign/dist/jsrsasign.js":
/*!*************************************!*\
  !*** ./jsrsasign/dist/jsrsasign.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(Buffer) {

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

/*
 * jsrsasign(all) 8.0.12 (2018-04-22) (c) 2010-2018 Kenji Urushima | kjur.github.com/jsrsasign/license
 */

var navigator = {};
navigator.userAgent = false;

var window = {};

/*!
Copyright (c) 2011, Yahoo! Inc. All rights reserved.
Code licensed under the BSD License:
http://developer.yahoo.com/yui/license.html
version: 2.9.0
*/
if (YAHOO === undefined) {
  var YAHOO = {};
}YAHOO.lang = { extend: function extend(g, h, f) {
    if (!h || !g) {
      throw new Error("YAHOO.lang.extend failed, please check that all dependencies are included.");
    }var d = function d() {};d.prototype = h.prototype;g.prototype = new d();g.prototype.constructor = g;g.superclass = h.prototype;if (h.prototype.constructor == Object.prototype.constructor) {
      h.prototype.constructor = h;
    }if (f) {
      var b;for (b in f) {
        g.prototype[b] = f[b];
      }var e = function e() {},
          c = ["toString", "valueOf"];try {
        if (/MSIE/.test(navigator.userAgent)) {
          e = function e(j, i) {
            for (b = 0; b < c.length; b = b + 1) {
              var l = c[b],
                  k = i[l];if (typeof k === "function" && k != Object.prototype[l]) {
                j[l] = k;
              }
            }
          };
        }
      } catch (a) {}e(g.prototype, f);
    }
  } };
/*! CryptoJS v3.1.2 core-fix.js
 * code.google.com/p/crypto-js
 * (c) 2009-2013 by Jeff Mott. All rights reserved.
 * code.google.com/p/crypto-js/wiki/License
 * THIS IS FIX of 'core.js' to fix Hmac issue.
 * https://code.google.com/p/crypto-js/issues/detail?id=84
 * https://crypto-js.googlecode.com/svn-history/r667/branches/3.x/src/core.js
 */
var CryptoJS = CryptoJS || function (e, g) {
  var a = {};var b = a.lib = {};var j = b.Base = function () {
    function n() {}return { extend: function extend(p) {
        n.prototype = this;var o = new n();if (p) {
          o.mixIn(p);
        }if (!o.hasOwnProperty("init")) {
          o.init = function () {
            o.$super.init.apply(this, arguments);
          };
        }o.init.prototype = o;o.$super = this;return o;
      }, create: function create() {
        var o = this.extend();o.init.apply(o, arguments);return o;
      }, init: function init() {}, mixIn: function mixIn(p) {
        for (var o in p) {
          if (p.hasOwnProperty(o)) {
            this[o] = p[o];
          }
        }if (p.hasOwnProperty("toString")) {
          this.toString = p.toString;
        }
      }, clone: function clone() {
        return this.init.prototype.extend(this);
      } };
  }();var l = b.WordArray = j.extend({ init: function init(o, n) {
      o = this.words = o || [];if (n != g) {
        this.sigBytes = n;
      } else {
        this.sigBytes = o.length * 4;
      }
    }, toString: function toString(n) {
      return (n || h).stringify(this);
    }, concat: function concat(t) {
      var q = this.words;var p = t.words;var n = this.sigBytes;var s = t.sigBytes;this.clamp();if (n % 4) {
        for (var r = 0; r < s; r++) {
          var o = p[r >>> 2] >>> 24 - r % 4 * 8 & 255;q[n + r >>> 2] |= o << 24 - (n + r) % 4 * 8;
        }
      } else {
        for (var r = 0; r < s; r += 4) {
          q[n + r >>> 2] = p[r >>> 2];
        }
      }this.sigBytes += s;return this;
    }, clamp: function clamp() {
      var o = this.words;var n = this.sigBytes;o[n >>> 2] &= 4294967295 << 32 - n % 4 * 8;o.length = e.ceil(n / 4);
    }, clone: function clone() {
      var n = j.clone.call(this);n.words = this.words.slice(0);return n;
    }, random: function random(p) {
      var o = [];for (var n = 0; n < p; n += 4) {
        o.push(e.random() * 4294967296 | 0);
      }return new l.init(o, p);
    } });var m = a.enc = {};var h = m.Hex = { stringify: function stringify(p) {
      var r = p.words;var o = p.sigBytes;var q = [];for (var n = 0; n < o; n++) {
        var s = r[n >>> 2] >>> 24 - n % 4 * 8 & 255;q.push((s >>> 4).toString(16));q.push((s & 15).toString(16));
      }return q.join("");
    }, parse: function parse(p) {
      var n = p.length;var q = [];for (var o = 0; o < n; o += 2) {
        q[o >>> 3] |= parseInt(p.substr(o, 2), 16) << 24 - o % 8 * 4;
      }return new l.init(q, n / 2);
    } };var d = m.Latin1 = { stringify: function stringify(q) {
      var r = q.words;var p = q.sigBytes;var n = [];for (var o = 0; o < p; o++) {
        var s = r[o >>> 2] >>> 24 - o % 4 * 8 & 255;n.push(String.fromCharCode(s));
      }return n.join("");
    }, parse: function parse(p) {
      var n = p.length;var q = [];for (var o = 0; o < n; o++) {
        q[o >>> 2] |= (p.charCodeAt(o) & 255) << 24 - o % 4 * 8;
      }return new l.init(q, n);
    } };var c = m.Utf8 = { stringify: function stringify(n) {
      try {
        return decodeURIComponent(escape(d.stringify(n)));
      } catch (o) {
        throw new Error("Malformed UTF-8 data");
      }
    }, parse: function parse(n) {
      return d.parse(unescape(encodeURIComponent(n)));
    } };var i = b.BufferedBlockAlgorithm = j.extend({ reset: function reset() {
      this._data = new l.init();this._nDataBytes = 0;
    }, _append: function _append(n) {
      if (typeof n == "string") {
        n = c.parse(n);
      }this._data.concat(n);this._nDataBytes += n.sigBytes;
    }, _process: function _process(w) {
      var q = this._data;var x = q.words;var n = q.sigBytes;var t = this.blockSize;var v = t * 4;var u = n / v;if (w) {
        u = e.ceil(u);
      } else {
        u = e.max((u | 0) - this._minBufferSize, 0);
      }var s = u * t;var r = e.min(s * 4, n);if (s) {
        for (var p = 0; p < s; p += t) {
          this._doProcessBlock(x, p);
        }var o = x.splice(0, s);q.sigBytes -= r;
      }return new l.init(o, r);
    }, clone: function clone() {
      var n = j.clone.call(this);n._data = this._data.clone();return n;
    }, _minBufferSize: 0 });var f = b.Hasher = i.extend({ cfg: j.extend(), init: function init(n) {
      this.cfg = this.cfg.extend(n);this.reset();
    }, reset: function reset() {
      i.reset.call(this);this._doReset();
    }, update: function update(n) {
      this._append(n);this._process();return this;
    }, finalize: function finalize(n) {
      if (n) {
        this._append(n);
      }var o = this._doFinalize();return o;
    }, blockSize: 512 / 32, _createHelper: function _createHelper(n) {
      return function (p, o) {
        return new n.init(o).finalize(p);
      };
    }, _createHmacHelper: function _createHmacHelper(n) {
      return function (p, o) {
        return new k.HMAC.init(n, o).finalize(p);
      };
    } });var k = a.algo = {};return a;
}(Math);
/*
CryptoJS v3.1.2 x64-core-min.js
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function (g) {
  var a = CryptoJS,
      f = a.lib,
      e = f.Base,
      h = f.WordArray,
      a = a.x64 = {};a.Word = e.extend({ init: function init(b, c) {
      this.high = b;this.low = c;
    } });a.WordArray = e.extend({ init: function init(b, c) {
      b = this.words = b || [];this.sigBytes = c != g ? c : 8 * b.length;
    }, toX32: function toX32() {
      for (var b = this.words, c = b.length, a = [], d = 0; d < c; d++) {
        var e = b[d];a.push(e.high);a.push(e.low);
      }return h.create(a, this.sigBytes);
    }, clone: function clone() {
      for (var b = e.clone.call(this), c = b.words = this.words.slice(0), a = c.length, d = 0; d < a; d++) {
        c[d] = c[d].clone();
      }return b;
    } });
})();

/*
CryptoJS v3.1.2 enc-base64.js
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function () {
  var h = CryptoJS,
      j = h.lib.WordArray;h.enc.Base64 = { stringify: function stringify(b) {
      var e = b.words,
          f = b.sigBytes,
          c = this._map;b.clamp();b = [];for (var a = 0; a < f; a += 3) {
        for (var d = (e[a >>> 2] >>> 24 - 8 * (a % 4) & 255) << 16 | (e[a + 1 >>> 2] >>> 24 - 8 * ((a + 1) % 4) & 255) << 8 | e[a + 2 >>> 2] >>> 24 - 8 * ((a + 2) % 4) & 255, g = 0; 4 > g && a + 0.75 * g < f; g++) {
          b.push(c.charAt(d >>> 6 * (3 - g) & 63));
        }
      }if (e = c.charAt(64)) for (; b.length % 4;) {
        b.push(e);
      }return b.join("");
    }, parse: function parse(b) {
      var e = b.length,
          f = this._map,
          c = f.charAt(64);c && (c = b.indexOf(c), -1 != c && (e = c));for (var c = [], a = 0, d = 0; d < e; d++) {
        if (d % 4) {
          var g = f.indexOf(b.charAt(d - 1)) << 2 * (d % 4),
              h = f.indexOf(b.charAt(d)) >>> 6 - 2 * (d % 4);c[a >>> 2] |= (g | h) << 24 - 8 * (a % 4);a++;
        }
      }return j.create(c, a);
    }, _map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=" };
})();

/*
CryptoJS v3.1.2 sha256-min.js
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function (k) {
  for (var g = CryptoJS, h = g.lib, v = h.WordArray, j = h.Hasher, h = g.algo, s = [], t = [], u = function u(q) {
    return 4294967296 * (q - (q | 0)) | 0;
  }, l = 2, b = 0; 64 > b;) {
    var d;a: {
      d = l;for (var w = k.sqrt(d), r = 2; r <= w; r++) {
        if (!(d % r)) {
          d = !1;break a;
        }
      }d = !0;
    }d && (8 > b && (s[b] = u(k.pow(l, 0.5))), t[b] = u(k.pow(l, 1 / 3)), b++);l++;
  }var n = [],
      h = h.SHA256 = j.extend({ _doReset: function _doReset() {
      this._hash = new v.init(s.slice(0));
    }, _doProcessBlock: function _doProcessBlock(q, h) {
      for (var a = this._hash.words, c = a[0], d = a[1], b = a[2], k = a[3], f = a[4], g = a[5], j = a[6], l = a[7], e = 0; 64 > e; e++) {
        if (16 > e) n[e] = q[h + e] | 0;else {
          var m = n[e - 15],
              p = n[e - 2];n[e] = ((m << 25 | m >>> 7) ^ (m << 14 | m >>> 18) ^ m >>> 3) + n[e - 7] + ((p << 15 | p >>> 17) ^ (p << 13 | p >>> 19) ^ p >>> 10) + n[e - 16];
        }m = l + ((f << 26 | f >>> 6) ^ (f << 21 | f >>> 11) ^ (f << 7 | f >>> 25)) + (f & g ^ ~f & j) + t[e] + n[e];p = ((c << 30 | c >>> 2) ^ (c << 19 | c >>> 13) ^ (c << 10 | c >>> 22)) + (c & d ^ c & b ^ d & b);l = j;j = g;g = f;f = k + m | 0;k = b;b = d;d = c;c = m + p | 0;
      }a[0] = a[0] + c | 0;a[1] = a[1] + d | 0;a[2] = a[2] + b | 0;a[3] = a[3] + k | 0;a[4] = a[4] + f | 0;a[5] = a[5] + g | 0;a[6] = a[6] + j | 0;a[7] = a[7] + l | 0;
    }, _doFinalize: function _doFinalize() {
      var d = this._data,
          b = d.words,
          a = 8 * this._nDataBytes,
          c = 8 * d.sigBytes;
      b[c >>> 5] |= 128 << 24 - c % 32;b[(c + 64 >>> 9 << 4) + 14] = k.floor(a / 4294967296);b[(c + 64 >>> 9 << 4) + 15] = a;d.sigBytes = 4 * b.length;this._process();return this._hash;
    }, clone: function clone() {
      var b = j.clone.call(this);b._hash = this._hash.clone();return b;
    } });g.SHA256 = j._createHelper(h);g.HmacSHA256 = j._createHmacHelper(h);
})(Math);

/*
CryptoJS v3.1.2 sha512-min.js
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function () {
  function a() {
    return d.create.apply(d, arguments);
  }for (var n = CryptoJS, r = n.lib.Hasher, e = n.x64, d = e.Word, T = e.WordArray, e = n.algo, ea = [a(1116352408, 3609767458), a(1899447441, 602891725), a(3049323471, 3964484399), a(3921009573, 2173295548), a(961987163, 4081628472), a(1508970993, 3053834265), a(2453635748, 2937671579), a(2870763221, 3664609560), a(3624381080, 2734883394), a(310598401, 1164996542), a(607225278, 1323610764), a(1426881987, 3590304994), a(1925078388, 4068182383), a(2162078206, 991336113), a(2614888103, 633803317), a(3248222580, 3479774868), a(3835390401, 2666613458), a(4022224774, 944711139), a(264347078, 2341262773), a(604807628, 2007800933), a(770255983, 1495990901), a(1249150122, 1856431235), a(1555081692, 3175218132), a(1996064986, 2198950837), a(2554220882, 3999719339), a(2821834349, 766784016), a(2952996808, 2566594879), a(3210313671, 3203337956), a(3336571891, 1034457026), a(3584528711, 2466948901), a(113926993, 3758326383), a(338241895, 168717936), a(666307205, 1188179964), a(773529912, 1546045734), a(1294757372, 1522805485), a(1396182291, 2643833823), a(1695183700, 2343527390), a(1986661051, 1014477480), a(2177026350, 1206759142), a(2456956037, 344077627), a(2730485921, 1290863460), a(2820302411, 3158454273), a(3259730800, 3505952657), a(3345764771, 106217008), a(3516065817, 3606008344), a(3600352804, 1432725776), a(4094571909, 1467031594), a(275423344, 851169720), a(430227734, 3100823752), a(506948616, 1363258195), a(659060556, 3750685593), a(883997877, 3785050280), a(958139571, 3318307427), a(1322822218, 3812723403), a(1537002063, 2003034995), a(1747873779, 3602036899), a(1955562222, 1575990012), a(2024104815, 1125592928), a(2227730452, 2716904306), a(2361852424, 442776044), a(2428436474, 593698344), a(2756734187, 3733110249), a(3204031479, 2999351573), a(3329325298, 3815920427), a(3391569614, 3928383900), a(3515267271, 566280711), a(3940187606, 3454069534), a(4118630271, 4000239992), a(116418474, 1914138554), a(174292421, 2731055270), a(289380356, 3203993006), a(460393269, 320620315), a(685471733, 587496836), a(852142971, 1086792851), a(1017036298, 365543100), a(1126000580, 2618297676), a(1288033470, 3409855158), a(1501505948, 4234509866), a(1607167915, 987167468), a(1816402316, 1246189591)], v = [], w = 0; 80 > w; w++) {
    v[w] = a();
  }e = e.SHA512 = r.extend({ _doReset: function _doReset() {
      this._hash = new T.init([new d.init(1779033703, 4089235720), new d.init(3144134277, 2227873595), new d.init(1013904242, 4271175723), new d.init(2773480762, 1595750129), new d.init(1359893119, 2917565137), new d.init(2600822924, 725511199), new d.init(528734635, 4215389547), new d.init(1541459225, 327033209)]);
    }, _doProcessBlock: function _doProcessBlock(a, d) {
      for (var f = this._hash.words, F = f[0], e = f[1], n = f[2], r = f[3], G = f[4], H = f[5], I = f[6], f = f[7], w = F.high, J = F.low, X = e.high, K = e.low, Y = n.high, L = n.low, Z = r.high, M = r.low, $ = G.high, N = G.low, aa = H.high, O = H.low, ba = I.high, P = I.low, ca = f.high, Q = f.low, k = w, g = J, z = X, x = K, A = Y, y = L, U = Z, B = M, l = $, h = N, R = aa, C = O, S = ba, D = P, V = ca, E = Q, m = 0; 80 > m; m++) {
        var s = v[m];if (16 > m) var j = s.high = a[d + 2 * m] | 0,
            b = s.low = a[d + 2 * m + 1] | 0;else {
          var j = v[m - 15],
              b = j.high,
              p = j.low,
              j = (b >>> 1 | p << 31) ^ (b >>> 8 | p << 24) ^ b >>> 7,
              p = (p >>> 1 | b << 31) ^ (p >>> 8 | b << 24) ^ (p >>> 7 | b << 25),
              u = v[m - 2],
              b = u.high,
              c = u.low,
              u = (b >>> 19 | c << 13) ^ (b << 3 | c >>> 29) ^ b >>> 6,
              c = (c >>> 19 | b << 13) ^ (c << 3 | b >>> 29) ^ (c >>> 6 | b << 26),
              b = v[m - 7],
              W = b.high,
              t = v[m - 16],
              q = t.high,
              t = t.low,
              b = p + b.low,
              j = j + W + (b >>> 0 < p >>> 0 ? 1 : 0),
              b = b + c,
              j = j + u + (b >>> 0 < c >>> 0 ? 1 : 0),
              b = b + t,
              j = j + q + (b >>> 0 < t >>> 0 ? 1 : 0);s.high = j;s.low = b;
        }var W = l & R ^ ~l & S,
            t = h & C ^ ~h & D,
            s = k & z ^ k & A ^ z & A,
            T = g & x ^ g & y ^ x & y,
            p = (k >>> 28 | g << 4) ^ (k << 30 | g >>> 2) ^ (k << 25 | g >>> 7),
            u = (g >>> 28 | k << 4) ^ (g << 30 | k >>> 2) ^ (g << 25 | k >>> 7),
            c = ea[m],
            fa = c.high,
            da = c.low,
            c = E + ((h >>> 14 | l << 18) ^ (h >>> 18 | l << 14) ^ (h << 23 | l >>> 9)),
            q = V + ((l >>> 14 | h << 18) ^ (l >>> 18 | h << 14) ^ (l << 23 | h >>> 9)) + (c >>> 0 < E >>> 0 ? 1 : 0),
            c = c + t,
            q = q + W + (c >>> 0 < t >>> 0 ? 1 : 0),
            c = c + da,
            q = q + fa + (c >>> 0 < da >>> 0 ? 1 : 0),
            c = c + b,
            q = q + j + (c >>> 0 < b >>> 0 ? 1 : 0),
            b = u + T,
            s = p + s + (b >>> 0 < u >>> 0 ? 1 : 0),
            V = S,
            E = D,
            S = R,
            D = C,
            R = l,
            C = h,
            h = B + c | 0,
            l = U + q + (h >>> 0 < B >>> 0 ? 1 : 0) | 0,
            U = A,
            B = y,
            A = z,
            y = x,
            z = k,
            x = g,
            g = c + b | 0,
            k = q + s + (g >>> 0 < c >>> 0 ? 1 : 0) | 0;
      }J = F.low = J + g;F.high = w + k + (J >>> 0 < g >>> 0 ? 1 : 0);K = e.low = K + x;e.high = X + z + (K >>> 0 < x >>> 0 ? 1 : 0);L = n.low = L + y;n.high = Y + A + (L >>> 0 < y >>> 0 ? 1 : 0);M = r.low = M + B;r.high = Z + U + (M >>> 0 < B >>> 0 ? 1 : 0);N = G.low = N + h;G.high = $ + l + (N >>> 0 < h >>> 0 ? 1 : 0);O = H.low = O + C;H.high = aa + R + (O >>> 0 < C >>> 0 ? 1 : 0);P = I.low = P + D;
      I.high = ba + S + (P >>> 0 < D >>> 0 ? 1 : 0);Q = f.low = Q + E;f.high = ca + V + (Q >>> 0 < E >>> 0 ? 1 : 0);
    }, _doFinalize: function _doFinalize() {
      var a = this._data,
          d = a.words,
          f = 8 * this._nDataBytes,
          e = 8 * a.sigBytes;d[e >>> 5] |= 128 << 24 - e % 32;d[(e + 128 >>> 10 << 5) + 30] = Math.floor(f / 4294967296);d[(e + 128 >>> 10 << 5) + 31] = f;a.sigBytes = 4 * d.length;this._process();return this._hash.toX32();
    }, clone: function clone() {
      var a = r.clone.call(this);a._hash = this._hash.clone();return a;
    }, blockSize: 32 });n.SHA512 = r._createHelper(e);n.HmacSHA512 = r._createHmacHelper(e);
})();

/*
CryptoJS v3.1.2 sha384-min.js
code.google.com/p/crypto-js
(c) 2009-2013 by Jeff Mott. All rights reserved.
code.google.com/p/crypto-js/wiki/License
*/
(function () {
  var c = CryptoJS,
      a = c.x64,
      b = a.Word,
      e = a.WordArray,
      a = c.algo,
      d = a.SHA512,
      a = a.SHA384 = d.extend({ _doReset: function _doReset() {
      this._hash = new e.init([new b.init(3418070365, 3238371032), new b.init(1654270250, 914150663), new b.init(2438529370, 812702999), new b.init(355462360, 4144912697), new b.init(1731405415, 4290775857), new b.init(2394180231, 1750603025), new b.init(3675008525, 1694076839), new b.init(1203062813, 3204075428)]);
    }, _doFinalize: function _doFinalize() {
      var a = d._doFinalize.call(this);a.sigBytes -= 16;return a;
    } });c.SHA384 = d._createHelper(a);c.HmacSHA384 = d._createHmacHelper(a);
})();

/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
var b64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";var b64pad = "=";function hex2b64(d) {
  var b;var e;var a = "";for (b = 0; b + 3 <= d.length; b += 3) {
    e = parseInt(d.substring(b, b + 3), 16);a += b64map.charAt(e >> 6) + b64map.charAt(e & 63);
  }if (b + 1 == d.length) {
    e = parseInt(d.substring(b, b + 1), 16);a += b64map.charAt(e << 2);
  } else {
    if (b + 2 == d.length) {
      e = parseInt(d.substring(b, b + 2), 16);a += b64map.charAt(e >> 2) + b64map.charAt((e & 3) << 4);
    }
  }if (b64pad) {
    while ((a.length & 3) > 0) {
      a += b64pad;
    }
  }return a;
}function b64tohex(f) {
  var d = "";var e;var b = 0;var c;var a;for (e = 0; e < f.length; ++e) {
    if (f.charAt(e) == b64pad) {
      break;
    }a = b64map.indexOf(f.charAt(e));if (a < 0) {
      continue;
    }if (b == 0) {
      d += int2char(a >> 2);c = a & 3;b = 1;
    } else {
      if (b == 1) {
        d += int2char(c << 2 | a >> 4);c = a & 15;b = 2;
      } else {
        if (b == 2) {
          d += int2char(c);d += int2char(a >> 2);c = a & 3;b = 3;
        } else {
          d += int2char(c << 2 | a >> 4);d += int2char(a & 15);b = 0;
        }
      }
    }
  }if (b == 1) {
    d += int2char(c << 2);
  }return d;
}function b64toBA(e) {
  var d = b64tohex(e);var c;var b = new Array();for (c = 0; 2 * c < d.length; ++c) {
    b[c] = parseInt(d.substring(2 * c, 2 * c + 2), 16);
  }return b;
};
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
var dbits;var canary = 244837814094590;var j_lm = (canary & 16777215) == 15715070;function BigInteger(e, d, f) {
  if (e != null) {
    if ("number" == typeof e) {
      this.fromNumber(e, d, f);
    } else {
      if (d == null && "string" != typeof e) {
        this.fromString(e, 256);
      } else {
        this.fromString(e, d);
      }
    }
  }
}function nbi() {
  return new BigInteger(null);
}function am1(f, a, b, e, h, g) {
  while (--g >= 0) {
    var d = a * this[f++] + b[e] + h;h = Math.floor(d / 67108864);b[e++] = d & 67108863;
  }return h;
}function am2(f, q, r, e, o, a) {
  var k = q & 32767,
      p = q >> 15;while (--a >= 0) {
    var d = this[f] & 32767;var g = this[f++] >> 15;var b = p * d + g * k;d = k * d + ((b & 32767) << 15) + r[e] + (o & 1073741823);o = (d >>> 30) + (b >>> 15) + p * g + (o >>> 30);r[e++] = d & 1073741823;
  }return o;
}function am3(f, q, r, e, o, a) {
  var k = q & 16383,
      p = q >> 14;while (--a >= 0) {
    var d = this[f] & 16383;var g = this[f++] >> 14;var b = p * d + g * k;d = k * d + ((b & 16383) << 14) + r[e] + o;o = (d >> 28) + (b >> 14) + p * g;r[e++] = d & 268435455;
  }return o;
}if (j_lm && navigator.appName == "Microsoft Internet Explorer") {
  BigInteger.prototype.am = am2;dbits = 30;
} else {
  if (j_lm && navigator.appName != "Netscape") {
    BigInteger.prototype.am = am1;dbits = 26;
  } else {
    BigInteger.prototype.am = am3;dbits = 28;
  }
}BigInteger.prototype.DB = dbits;BigInteger.prototype.DM = (1 << dbits) - 1;BigInteger.prototype.DV = 1 << dbits;var BI_FP = 52;BigInteger.prototype.FV = Math.pow(2, BI_FP);BigInteger.prototype.F1 = BI_FP - dbits;BigInteger.prototype.F2 = 2 * dbits - BI_FP;var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";var BI_RC = new Array();var rr, vv;rr = "0".charCodeAt(0);for (vv = 0; vv <= 9; ++vv) {
  BI_RC[rr++] = vv;
}rr = "a".charCodeAt(0);for (vv = 10; vv < 36; ++vv) {
  BI_RC[rr++] = vv;
}rr = "A".charCodeAt(0);for (vv = 10; vv < 36; ++vv) {
  BI_RC[rr++] = vv;
}function int2char(a) {
  return BI_RM.charAt(a);
}function intAt(b, a) {
  var d = BI_RC[b.charCodeAt(a)];return d == null ? -1 : d;
}function bnpCopyTo(b) {
  for (var a = this.t - 1; a >= 0; --a) {
    b[a] = this[a];
  }b.t = this.t;b.s = this.s;
}function bnpFromInt(a) {
  this.t = 1;this.s = a < 0 ? -1 : 0;if (a > 0) {
    this[0] = a;
  } else {
    if (a < -1) {
      this[0] = a + this.DV;
    } else {
      this.t = 0;
    }
  }
}function nbv(a) {
  var b = nbi();b.fromInt(a);return b;
}function bnpFromString(h, c) {
  var e;if (c == 16) {
    e = 4;
  } else {
    if (c == 8) {
      e = 3;
    } else {
      if (c == 256) {
        e = 8;
      } else {
        if (c == 2) {
          e = 1;
        } else {
          if (c == 32) {
            e = 5;
          } else {
            if (c == 4) {
              e = 2;
            } else {
              this.fromRadix(h, c);return;
            }
          }
        }
      }
    }
  }this.t = 0;this.s = 0;var g = h.length,
      d = false,
      f = 0;while (--g >= 0) {
    var a = e == 8 ? h[g] & 255 : intAt(h, g);if (a < 0) {
      if (h.charAt(g) == "-") {
        d = true;
      }continue;
    }d = false;if (f == 0) {
      this[this.t++] = a;
    } else {
      if (f + e > this.DB) {
        this[this.t - 1] |= (a & (1 << this.DB - f) - 1) << f;this[this.t++] = a >> this.DB - f;
      } else {
        this[this.t - 1] |= a << f;
      }
    }f += e;if (f >= this.DB) {
      f -= this.DB;
    }
  }if (e == 8 && (h[0] & 128) != 0) {
    this.s = -1;if (f > 0) {
      this[this.t - 1] |= (1 << this.DB - f) - 1 << f;
    }
  }this.clamp();if (d) {
    BigInteger.ZERO.subTo(this, this);
  }
}function bnpClamp() {
  var a = this.s & this.DM;while (this.t > 0 && this[this.t - 1] == a) {
    --this.t;
  }
}function bnToString(c) {
  if (this.s < 0) {
    return "-" + this.negate().toString(c);
  }var e;if (c == 16) {
    e = 4;
  } else {
    if (c == 8) {
      e = 3;
    } else {
      if (c == 2) {
        e = 1;
      } else {
        if (c == 32) {
          e = 5;
        } else {
          if (c == 4) {
            e = 2;
          } else {
            return this.toRadix(c);
          }
        }
      }
    }
  }var g = (1 << e) - 1,
      l,
      a = false,
      h = "",
      f = this.t;var j = this.DB - f * this.DB % e;if (f-- > 0) {
    if (j < this.DB && (l = this[f] >> j) > 0) {
      a = true;h = int2char(l);
    }while (f >= 0) {
      if (j < e) {
        l = (this[f] & (1 << j) - 1) << e - j;l |= this[--f] >> (j += this.DB - e);
      } else {
        l = this[f] >> (j -= e) & g;if (j <= 0) {
          j += this.DB;--f;
        }
      }if (l > 0) {
        a = true;
      }if (a) {
        h += int2char(l);
      }
    }
  }return a ? h : "0";
}function bnNegate() {
  var a = nbi();BigInteger.ZERO.subTo(this, a);return a;
}function bnAbs() {
  return this.s < 0 ? this.negate() : this;
}function bnCompareTo(b) {
  var d = this.s - b.s;if (d != 0) {
    return d;
  }var c = this.t;d = c - b.t;if (d != 0) {
    return this.s < 0 ? -d : d;
  }while (--c >= 0) {
    if ((d = this[c] - b[c]) != 0) {
      return d;
    }
  }return 0;
}function nbits(a) {
  var c = 1,
      b;if ((b = a >>> 16) != 0) {
    a = b;c += 16;
  }if ((b = a >> 8) != 0) {
    a = b;c += 8;
  }if ((b = a >> 4) != 0) {
    a = b;c += 4;
  }if ((b = a >> 2) != 0) {
    a = b;c += 2;
  }if ((b = a >> 1) != 0) {
    a = b;c += 1;
  }return c;
}function bnBitLength() {
  if (this.t <= 0) {
    return 0;
  }return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);
}function bnpDLShiftTo(c, b) {
  var a;for (a = this.t - 1; a >= 0; --a) {
    b[a + c] = this[a];
  }for (a = c - 1; a >= 0; --a) {
    b[a] = 0;
  }b.t = this.t + c;b.s = this.s;
}function bnpDRShiftTo(c, b) {
  for (var a = c; a < this.t; ++a) {
    b[a - c] = this[a];
  }b.t = Math.max(this.t - c, 0);b.s = this.s;
}function bnpLShiftTo(j, e) {
  var b = j % this.DB;var a = this.DB - b;var g = (1 << a) - 1;var f = Math.floor(j / this.DB),
      h = this.s << b & this.DM,
      d;for (d = this.t - 1; d >= 0; --d) {
    e[d + f + 1] = this[d] >> a | h;h = (this[d] & g) << b;
  }for (d = f - 1; d >= 0; --d) {
    e[d] = 0;
  }e[f] = h;e.t = this.t + f + 1;e.s = this.s;e.clamp();
}function bnpRShiftTo(g, d) {
  d.s = this.s;var e = Math.floor(g / this.DB);if (e >= this.t) {
    d.t = 0;return;
  }var b = g % this.DB;var a = this.DB - b;var f = (1 << b) - 1;d[0] = this[e] >> b;for (var c = e + 1; c < this.t; ++c) {
    d[c - e - 1] |= (this[c] & f) << a;d[c - e] = this[c] >> b;
  }if (b > 0) {
    d[this.t - e - 1] |= (this.s & f) << a;
  }d.t = this.t - e;d.clamp();
}function bnpSubTo(d, f) {
  var e = 0,
      g = 0,
      b = Math.min(d.t, this.t);while (e < b) {
    g += this[e] - d[e];f[e++] = g & this.DM;g >>= this.DB;
  }if (d.t < this.t) {
    g -= d.s;while (e < this.t) {
      g += this[e];f[e++] = g & this.DM;g >>= this.DB;
    }g += this.s;
  } else {
    g += this.s;while (e < d.t) {
      g -= d[e];f[e++] = g & this.DM;g >>= this.DB;
    }g -= d.s;
  }f.s = g < 0 ? -1 : 0;if (g < -1) {
    f[e++] = this.DV + g;
  } else {
    if (g > 0) {
      f[e++] = g;
    }
  }f.t = e;f.clamp();
}function bnpMultiplyTo(c, e) {
  var b = this.abs(),
      f = c.abs();var d = b.t;e.t = d + f.t;while (--d >= 0) {
    e[d] = 0;
  }for (d = 0; d < f.t; ++d) {
    e[d + b.t] = b.am(0, f[d], e, d, 0, b.t);
  }e.s = 0;e.clamp();if (this.s != c.s) {
    BigInteger.ZERO.subTo(e, e);
  }
}function bnpSquareTo(d) {
  var a = this.abs();var b = d.t = 2 * a.t;while (--b >= 0) {
    d[b] = 0;
  }for (b = 0; b < a.t - 1; ++b) {
    var e = a.am(b, a[b], d, 2 * b, 0, 1);if ((d[b + a.t] += a.am(b + 1, 2 * a[b], d, 2 * b + 1, e, a.t - b - 1)) >= a.DV) {
      d[b + a.t] -= a.DV;d[b + a.t + 1] = 1;
    }
  }if (d.t > 0) {
    d[d.t - 1] += a.am(b, a[b], d, 2 * b, 0, 1);
  }d.s = 0;d.clamp();
}function bnpDivRemTo(n, h, g) {
  var w = n.abs();if (w.t <= 0) {
    return;
  }var k = this.abs();if (k.t < w.t) {
    if (h != null) {
      h.fromInt(0);
    }if (g != null) {
      this.copyTo(g);
    }return;
  }if (g == null) {
    g = nbi();
  }var d = nbi(),
      a = this.s,
      l = n.s;var v = this.DB - nbits(w[w.t - 1]);if (v > 0) {
    w.lShiftTo(v, d);k.lShiftTo(v, g);
  } else {
    w.copyTo(d);k.copyTo(g);
  }var p = d.t;var b = d[p - 1];if (b == 0) {
    return;
  }var o = b * (1 << this.F1) + (p > 1 ? d[p - 2] >> this.F2 : 0);var A = this.FV / o,
      z = (1 << this.F1) / o,
      x = 1 << this.F2;var u = g.t,
      s = u - p,
      f = h == null ? nbi() : h;d.dlShiftTo(s, f);if (g.compareTo(f) >= 0) {
    g[g.t++] = 1;g.subTo(f, g);
  }BigInteger.ONE.dlShiftTo(p, f);f.subTo(d, d);while (d.t < p) {
    d[d.t++] = 0;
  }while (--s >= 0) {
    var c = g[--u] == b ? this.DM : Math.floor(g[u] * A + (g[u - 1] + x) * z);if ((g[u] += d.am(0, c, g, s, 0, p)) < c) {
      d.dlShiftTo(s, f);g.subTo(f, g);while (g[u] < --c) {
        g.subTo(f, g);
      }
    }
  }if (h != null) {
    g.drShiftTo(p, h);if (a != l) {
      BigInteger.ZERO.subTo(h, h);
    }
  }g.t = p;g.clamp();if (v > 0) {
    g.rShiftTo(v, g);
  }if (a < 0) {
    BigInteger.ZERO.subTo(g, g);
  }
}function bnMod(b) {
  var c = nbi();this.abs().divRemTo(b, null, c);if (this.s < 0 && c.compareTo(BigInteger.ZERO) > 0) {
    b.subTo(c, c);
  }return c;
}function Classic(a) {
  this.m = a;
}function cConvert(a) {
  if (a.s < 0 || a.compareTo(this.m) >= 0) {
    return a.mod(this.m);
  } else {
    return a;
  }
}function cRevert(a) {
  return a;
}function cReduce(a) {
  a.divRemTo(this.m, null, a);
}function cMulTo(a, c, b) {
  a.multiplyTo(c, b);this.reduce(b);
}function cSqrTo(a, b) {
  a.squareTo(b);this.reduce(b);
}Classic.prototype.convert = cConvert;Classic.prototype.revert = cRevert;Classic.prototype.reduce = cReduce;Classic.prototype.mulTo = cMulTo;Classic.prototype.sqrTo = cSqrTo;function bnpInvDigit() {
  if (this.t < 1) {
    return 0;
  }var a = this[0];if ((a & 1) == 0) {
    return 0;
  }var b = a & 3;b = b * (2 - (a & 15) * b) & 15;b = b * (2 - (a & 255) * b) & 255;b = b * (2 - ((a & 65535) * b & 65535)) & 65535;b = b * (2 - a * b % this.DV) % this.DV;return b > 0 ? this.DV - b : -b;
}function Montgomery(a) {
  this.m = a;this.mp = a.invDigit();this.mpl = this.mp & 32767;this.mph = this.mp >> 15;this.um = (1 << a.DB - 15) - 1;this.mt2 = 2 * a.t;
}function montConvert(a) {
  var b = nbi();a.abs().dlShiftTo(this.m.t, b);b.divRemTo(this.m, null, b);if (a.s < 0 && b.compareTo(BigInteger.ZERO) > 0) {
    this.m.subTo(b, b);
  }return b;
}function montRevert(a) {
  var b = nbi();a.copyTo(b);this.reduce(b);return b;
}function montReduce(a) {
  while (a.t <= this.mt2) {
    a[a.t++] = 0;
  }for (var c = 0; c < this.m.t; ++c) {
    var b = a[c] & 32767;var d = b * this.mpl + ((b * this.mph + (a[c] >> 15) * this.mpl & this.um) << 15) & a.DM;b = c + this.m.t;a[b] += this.m.am(0, d, a, c, 0, this.m.t);while (a[b] >= a.DV) {
      a[b] -= a.DV;a[++b]++;
    }
  }a.clamp();a.drShiftTo(this.m.t, a);if (a.compareTo(this.m) >= 0) {
    a.subTo(this.m, a);
  }
}function montSqrTo(a, b) {
  a.squareTo(b);this.reduce(b);
}function montMulTo(a, c, b) {
  a.multiplyTo(c, b);this.reduce(b);
}Montgomery.prototype.convert = montConvert;Montgomery.prototype.revert = montRevert;Montgomery.prototype.reduce = montReduce;Montgomery.prototype.mulTo = montMulTo;Montgomery.prototype.sqrTo = montSqrTo;function bnpIsEven() {
  return (this.t > 0 ? this[0] & 1 : this.s) == 0;
}function bnpExp(h, j) {
  if (h > 4294967295 || h < 1) {
    return BigInteger.ONE;
  }var f = nbi(),
      a = nbi(),
      d = j.convert(this),
      c = nbits(h) - 1;d.copyTo(f);while (--c >= 0) {
    j.sqrTo(f, a);if ((h & 1 << c) > 0) {
      j.mulTo(a, d, f);
    } else {
      var b = f;f = a;a = b;
    }
  }return j.revert(f);
}function bnModPowInt(b, a) {
  var c;if (b < 256 || a.isEven()) {
    c = new Classic(a);
  } else {
    c = new Montgomery(a);
  }return this.exp(b, c);
}BigInteger.prototype.copyTo = bnpCopyTo;BigInteger.prototype.fromInt = bnpFromInt;BigInteger.prototype.fromString = bnpFromString;BigInteger.prototype.clamp = bnpClamp;BigInteger.prototype.dlShiftTo = bnpDLShiftTo;BigInteger.prototype.drShiftTo = bnpDRShiftTo;BigInteger.prototype.lShiftTo = bnpLShiftTo;BigInteger.prototype.rShiftTo = bnpRShiftTo;BigInteger.prototype.subTo = bnpSubTo;BigInteger.prototype.multiplyTo = bnpMultiplyTo;BigInteger.prototype.squareTo = bnpSquareTo;BigInteger.prototype.divRemTo = bnpDivRemTo;BigInteger.prototype.invDigit = bnpInvDigit;BigInteger.prototype.isEven = bnpIsEven;BigInteger.prototype.exp = bnpExp;BigInteger.prototype.toString = bnToString;BigInteger.prototype.negate = bnNegate;BigInteger.prototype.abs = bnAbs;BigInteger.prototype.compareTo = bnCompareTo;BigInteger.prototype.bitLength = bnBitLength;BigInteger.prototype.mod = bnMod;BigInteger.prototype.modPowInt = bnModPowInt;BigInteger.ZERO = nbv(0);BigInteger.ONE = nbv(1);
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
function bnClone() {
  var a = nbi();this.copyTo(a);return a;
}function bnIntValue() {
  if (this.s < 0) {
    if (this.t == 1) {
      return this[0] - this.DV;
    } else {
      if (this.t == 0) {
        return -1;
      }
    }
  } else {
    if (this.t == 1) {
      return this[0];
    } else {
      if (this.t == 0) {
        return 0;
      }
    }
  }return (this[1] & (1 << 32 - this.DB) - 1) << this.DB | this[0];
}function bnByteValue() {
  return this.t == 0 ? this.s : this[0] << 24 >> 24;
}function bnShortValue() {
  return this.t == 0 ? this.s : this[0] << 16 >> 16;
}function bnpChunkSize(a) {
  return Math.floor(Math.LN2 * this.DB / Math.log(a));
}function bnSigNum() {
  if (this.s < 0) {
    return -1;
  } else {
    if (this.t <= 0 || this.t == 1 && this[0] <= 0) {
      return 0;
    } else {
      return 1;
    }
  }
}function bnpToRadix(c) {
  if (c == null) {
    c = 10;
  }if (this.signum() == 0 || c < 2 || c > 36) {
    return "0";
  }var f = this.chunkSize(c);var e = Math.pow(c, f);var i = nbv(e),
      j = nbi(),
      h = nbi(),
      g = "";this.divRemTo(i, j, h);while (j.signum() > 0) {
    g = (e + h.intValue()).toString(c).substr(1) + g;j.divRemTo(i, j, h);
  }return h.intValue().toString(c) + g;
}function bnpFromRadix(m, h) {
  this.fromInt(0);if (h == null) {
    h = 10;
  }var f = this.chunkSize(h);var g = Math.pow(h, f),
      e = false,
      a = 0,
      l = 0;for (var c = 0; c < m.length; ++c) {
    var k = intAt(m, c);if (k < 0) {
      if (m.charAt(c) == "-" && this.signum() == 0) {
        e = true;
      }continue;
    }l = h * l + k;if (++a >= f) {
      this.dMultiply(g);this.dAddOffset(l, 0);a = 0;l = 0;
    }
  }if (a > 0) {
    this.dMultiply(Math.pow(h, a));this.dAddOffset(l, 0);
  }if (e) {
    BigInteger.ZERO.subTo(this, this);
  }
}function bnpFromNumber(f, e, h) {
  if ("number" == typeof e) {
    if (f < 2) {
      this.fromInt(1);
    } else {
      this.fromNumber(f, h);if (!this.testBit(f - 1)) {
        this.bitwiseTo(BigInteger.ONE.shiftLeft(f - 1), op_or, this);
      }if (this.isEven()) {
        this.dAddOffset(1, 0);
      }while (!this.isProbablePrime(e)) {
        this.dAddOffset(2, 0);if (this.bitLength() > f) {
          this.subTo(BigInteger.ONE.shiftLeft(f - 1), this);
        }
      }
    }
  } else {
    var d = new Array(),
        g = f & 7;d.length = (f >> 3) + 1;e.nextBytes(d);if (g > 0) {
      d[0] &= (1 << g) - 1;
    } else {
      d[0] = 0;
    }this.fromString(d, 256);
  }
}function bnToByteArray() {
  var b = this.t,
      c = new Array();c[0] = this.s;var e = this.DB - b * this.DB % 8,
      f,
      a = 0;if (b-- > 0) {
    if (e < this.DB && (f = this[b] >> e) != (this.s & this.DM) >> e) {
      c[a++] = f | this.s << this.DB - e;
    }while (b >= 0) {
      if (e < 8) {
        f = (this[b] & (1 << e) - 1) << 8 - e;f |= this[--b] >> (e += this.DB - 8);
      } else {
        f = this[b] >> (e -= 8) & 255;if (e <= 0) {
          e += this.DB;--b;
        }
      }if ((f & 128) != 0) {
        f |= -256;
      }if (a == 0 && (this.s & 128) != (f & 128)) {
        ++a;
      }if (a > 0 || f != this.s) {
        c[a++] = f;
      }
    }
  }return c;
}function bnEquals(b) {
  return this.compareTo(b) == 0;
}function bnMin(b) {
  return this.compareTo(b) < 0 ? this : b;
}function bnMax(b) {
  return this.compareTo(b) > 0 ? this : b;
}function bnpBitwiseTo(c, h, e) {
  var d,
      g,
      b = Math.min(c.t, this.t);for (d = 0; d < b; ++d) {
    e[d] = h(this[d], c[d]);
  }if (c.t < this.t) {
    g = c.s & this.DM;for (d = b; d < this.t; ++d) {
      e[d] = h(this[d], g);
    }e.t = this.t;
  } else {
    g = this.s & this.DM;for (d = b; d < c.t; ++d) {
      e[d] = h(g, c[d]);
    }e.t = c.t;
  }e.s = h(this.s, c.s);e.clamp();
}function op_and(a, b) {
  return a & b;
}function bnAnd(b) {
  var c = nbi();this.bitwiseTo(b, op_and, c);return c;
}function op_or(a, b) {
  return a | b;
}function bnOr(b) {
  var c = nbi();this.bitwiseTo(b, op_or, c);return c;
}function op_xor(a, b) {
  return a ^ b;
}function bnXor(b) {
  var c = nbi();this.bitwiseTo(b, op_xor, c);return c;
}function op_andnot(a, b) {
  return a & ~b;
}function bnAndNot(b) {
  var c = nbi();this.bitwiseTo(b, op_andnot, c);return c;
}function bnNot() {
  var b = nbi();for (var a = 0; a < this.t; ++a) {
    b[a] = this.DM & ~this[a];
  }b.t = this.t;b.s = ~this.s;return b;
}function bnShiftLeft(b) {
  var a = nbi();if (b < 0) {
    this.rShiftTo(-b, a);
  } else {
    this.lShiftTo(b, a);
  }return a;
}function bnShiftRight(b) {
  var a = nbi();if (b < 0) {
    this.lShiftTo(-b, a);
  } else {
    this.rShiftTo(b, a);
  }return a;
}function lbit(a) {
  if (a == 0) {
    return -1;
  }var b = 0;if ((a & 65535) == 0) {
    a >>= 16;b += 16;
  }if ((a & 255) == 0) {
    a >>= 8;b += 8;
  }if ((a & 15) == 0) {
    a >>= 4;b += 4;
  }if ((a & 3) == 0) {
    a >>= 2;b += 2;
  }if ((a & 1) == 0) {
    ++b;
  }return b;
}function bnGetLowestSetBit() {
  for (var a = 0; a < this.t; ++a) {
    if (this[a] != 0) {
      return a * this.DB + lbit(this[a]);
    }
  }if (this.s < 0) {
    return this.t * this.DB;
  }return -1;
}function cbit(a) {
  var b = 0;while (a != 0) {
    a &= a - 1;++b;
  }return b;
}function bnBitCount() {
  var c = 0,
      a = this.s & this.DM;for (var b = 0; b < this.t; ++b) {
    c += cbit(this[b] ^ a);
  }return c;
}function bnTestBit(b) {
  var a = Math.floor(b / this.DB);if (a >= this.t) {
    return this.s != 0;
  }return (this[a] & 1 << b % this.DB) != 0;
}function bnpChangeBit(c, b) {
  var a = BigInteger.ONE.shiftLeft(c);this.bitwiseTo(a, b, a);return a;
}function bnSetBit(a) {
  return this.changeBit(a, op_or);
}function bnClearBit(a) {
  return this.changeBit(a, op_andnot);
}function bnFlipBit(a) {
  return this.changeBit(a, op_xor);
}function bnpAddTo(d, f) {
  var e = 0,
      g = 0,
      b = Math.min(d.t, this.t);while (e < b) {
    g += this[e] + d[e];f[e++] = g & this.DM;g >>= this.DB;
  }if (d.t < this.t) {
    g += d.s;while (e < this.t) {
      g += this[e];f[e++] = g & this.DM;g >>= this.DB;
    }g += this.s;
  } else {
    g += this.s;while (e < d.t) {
      g += d[e];f[e++] = g & this.DM;g >>= this.DB;
    }g += d.s;
  }f.s = g < 0 ? -1 : 0;if (g > 0) {
    f[e++] = g;
  } else {
    if (g < -1) {
      f[e++] = this.DV + g;
    }
  }f.t = e;f.clamp();
}function bnAdd(b) {
  var c = nbi();this.addTo(b, c);return c;
}function bnSubtract(b) {
  var c = nbi();this.subTo(b, c);return c;
}function bnMultiply(b) {
  var c = nbi();this.multiplyTo(b, c);return c;
}function bnSquare() {
  var a = nbi();this.squareTo(a);return a;
}function bnDivide(b) {
  var c = nbi();this.divRemTo(b, c, null);return c;
}function bnRemainder(b) {
  var c = nbi();this.divRemTo(b, null, c);return c;
}function bnDivideAndRemainder(b) {
  var d = nbi(),
      c = nbi();this.divRemTo(b, d, c);return new Array(d, c);
}function bnpDMultiply(a) {
  this[this.t] = this.am(0, a - 1, this, 0, 0, this.t);++this.t;this.clamp();
}function bnpDAddOffset(b, a) {
  if (b == 0) {
    return;
  }while (this.t <= a) {
    this[this.t++] = 0;
  }this[a] += b;while (this[a] >= this.DV) {
    this[a] -= this.DV;if (++a >= this.t) {
      this[this.t++] = 0;
    }++this[a];
  }
}function NullExp() {}function nNop(a) {
  return a;
}function nMulTo(a, c, b) {
  a.multiplyTo(c, b);
}function nSqrTo(a, b) {
  a.squareTo(b);
}NullExp.prototype.convert = nNop;NullExp.prototype.revert = nNop;NullExp.prototype.mulTo = nMulTo;NullExp.prototype.sqrTo = nSqrTo;function bnPow(a) {
  return this.exp(a, new NullExp());
}function bnpMultiplyLowerTo(b, f, e) {
  var d = Math.min(this.t + b.t, f);e.s = 0;e.t = d;while (d > 0) {
    e[--d] = 0;
  }var c;for (c = e.t - this.t; d < c; ++d) {
    e[d + this.t] = this.am(0, b[d], e, d, 0, this.t);
  }for (c = Math.min(b.t, f); d < c; ++d) {
    this.am(0, b[d], e, d, 0, f - d);
  }e.clamp();
}function bnpMultiplyUpperTo(b, e, d) {
  --e;var c = d.t = this.t + b.t - e;d.s = 0;while (--c >= 0) {
    d[c] = 0;
  }for (c = Math.max(e - this.t, 0); c < b.t; ++c) {
    d[this.t + c - e] = this.am(e - c, b[c], d, 0, 0, this.t + c - e);
  }d.clamp();d.drShiftTo(1, d);
}function Barrett(a) {
  this.r2 = nbi();this.q3 = nbi();BigInteger.ONE.dlShiftTo(2 * a.t, this.r2);this.mu = this.r2.divide(a);this.m = a;
}function barrettConvert(a) {
  if (a.s < 0 || a.t > 2 * this.m.t) {
    return a.mod(this.m);
  } else {
    if (a.compareTo(this.m) < 0) {
      return a;
    } else {
      var b = nbi();a.copyTo(b);this.reduce(b);return b;
    }
  }
}function barrettRevert(a) {
  return a;
}function barrettReduce(a) {
  a.drShiftTo(this.m.t - 1, this.r2);if (a.t > this.m.t + 1) {
    a.t = this.m.t + 1;a.clamp();
  }this.mu.multiplyUpperTo(this.r2, this.m.t + 1, this.q3);this.m.multiplyLowerTo(this.q3, this.m.t + 1, this.r2);while (a.compareTo(this.r2) < 0) {
    a.dAddOffset(1, this.m.t + 1);
  }a.subTo(this.r2, a);while (a.compareTo(this.m) >= 0) {
    a.subTo(this.m, a);
  }
}function barrettSqrTo(a, b) {
  a.squareTo(b);this.reduce(b);
}function barrettMulTo(a, c, b) {
  a.multiplyTo(c, b);this.reduce(b);
}Barrett.prototype.convert = barrettConvert;Barrett.prototype.revert = barrettRevert;Barrett.prototype.reduce = barrettReduce;Barrett.prototype.mulTo = barrettMulTo;Barrett.prototype.sqrTo = barrettSqrTo;function bnModPow(q, f) {
  var o = q.bitLength(),
      h,
      b = nbv(1),
      v;if (o <= 0) {
    return b;
  } else {
    if (o < 18) {
      h = 1;
    } else {
      if (o < 48) {
        h = 3;
      } else {
        if (o < 144) {
          h = 4;
        } else {
          if (o < 768) {
            h = 5;
          } else {
            h = 6;
          }
        }
      }
    }
  }if (o < 8) {
    v = new Classic(f);
  } else {
    if (f.isEven()) {
      v = new Barrett(f);
    } else {
      v = new Montgomery(f);
    }
  }var p = new Array(),
      d = 3,
      s = h - 1,
      a = (1 << h) - 1;p[1] = v.convert(this);if (h > 1) {
    var A = nbi();v.sqrTo(p[1], A);while (d <= a) {
      p[d] = nbi();v.mulTo(A, p[d - 2], p[d]);d += 2;
    }
  }var l = q.t - 1,
      x,
      u = true,
      c = nbi(),
      y;o = nbits(q[l]) - 1;while (l >= 0) {
    if (o >= s) {
      x = q[l] >> o - s & a;
    } else {
      x = (q[l] & (1 << o + 1) - 1) << s - o;if (l > 0) {
        x |= q[l - 1] >> this.DB + o - s;
      }
    }d = h;while ((x & 1) == 0) {
      x >>= 1;--d;
    }if ((o -= d) < 0) {
      o += this.DB;--l;
    }if (u) {
      p[x].copyTo(b);u = false;
    } else {
      while (d > 1) {
        v.sqrTo(b, c);v.sqrTo(c, b);d -= 2;
      }if (d > 0) {
        v.sqrTo(b, c);
      } else {
        y = b;b = c;c = y;
      }v.mulTo(c, p[x], b);
    }while (l >= 0 && (q[l] & 1 << o) == 0) {
      v.sqrTo(b, c);y = b;b = c;c = y;if (--o < 0) {
        o = this.DB - 1;--l;
      }
    }
  }return v.revert(b);
}function bnGCD(c) {
  var b = this.s < 0 ? this.negate() : this.clone();var h = c.s < 0 ? c.negate() : c.clone();if (b.compareTo(h) < 0) {
    var e = b;b = h;h = e;
  }var d = b.getLowestSetBit(),
      f = h.getLowestSetBit();if (f < 0) {
    return b;
  }if (d < f) {
    f = d;
  }if (f > 0) {
    b.rShiftTo(f, b);h.rShiftTo(f, h);
  }while (b.signum() > 0) {
    if ((d = b.getLowestSetBit()) > 0) {
      b.rShiftTo(d, b);
    }if ((d = h.getLowestSetBit()) > 0) {
      h.rShiftTo(d, h);
    }if (b.compareTo(h) >= 0) {
      b.subTo(h, b);b.rShiftTo(1, b);
    } else {
      h.subTo(b, h);h.rShiftTo(1, h);
    }
  }if (f > 0) {
    h.lShiftTo(f, h);
  }return h;
}function bnpModInt(e) {
  if (e <= 0) {
    return 0;
  }var c = this.DV % e,
      b = this.s < 0 ? e - 1 : 0;if (this.t > 0) {
    if (c == 0) {
      b = this[0] % e;
    } else {
      for (var a = this.t - 1; a >= 0; --a) {
        b = (c * b + this[a]) % e;
      }
    }
  }return b;
}function bnModInverse(f) {
  var j = f.isEven();if (this.isEven() && j || f.signum() == 0) {
    return BigInteger.ZERO;
  }var i = f.clone(),
      h = this.clone();var g = nbv(1),
      e = nbv(0),
      l = nbv(0),
      k = nbv(1);while (i.signum() != 0) {
    while (i.isEven()) {
      i.rShiftTo(1, i);if (j) {
        if (!g.isEven() || !e.isEven()) {
          g.addTo(this, g);e.subTo(f, e);
        }g.rShiftTo(1, g);
      } else {
        if (!e.isEven()) {
          e.subTo(f, e);
        }
      }e.rShiftTo(1, e);
    }while (h.isEven()) {
      h.rShiftTo(1, h);if (j) {
        if (!l.isEven() || !k.isEven()) {
          l.addTo(this, l);k.subTo(f, k);
        }l.rShiftTo(1, l);
      } else {
        if (!k.isEven()) {
          k.subTo(f, k);
        }
      }k.rShiftTo(1, k);
    }if (i.compareTo(h) >= 0) {
      i.subTo(h, i);if (j) {
        g.subTo(l, g);
      }e.subTo(k, e);
    } else {
      h.subTo(i, h);if (j) {
        l.subTo(g, l);
      }k.subTo(e, k);
    }
  }if (h.compareTo(BigInteger.ONE) != 0) {
    return BigInteger.ZERO;
  }if (k.compareTo(f) >= 0) {
    return k.subtract(f);
  }if (k.signum() < 0) {
    k.addTo(f, k);
  } else {
    return k;
  }if (k.signum() < 0) {
    return k.add(f);
  } else {
    return k;
  }
}var lowprimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997];var lplim = (1 << 26) / lowprimes[lowprimes.length - 1];function bnIsProbablePrime(e) {
  var d,
      b = this.abs();if (b.t == 1 && b[0] <= lowprimes[lowprimes.length - 1]) {
    for (d = 0; d < lowprimes.length; ++d) {
      if (b[0] == lowprimes[d]) {
        return true;
      }
    }return false;
  }if (b.isEven()) {
    return false;
  }d = 1;while (d < lowprimes.length) {
    var a = lowprimes[d],
        c = d + 1;while (c < lowprimes.length && a < lplim) {
      a *= lowprimes[c++];
    }a = b.modInt(a);while (d < c) {
      if (a % lowprimes[d++] == 0) {
        return false;
      }
    }
  }return b.millerRabin(e);
}function bnpMillerRabin(f) {
  var g = this.subtract(BigInteger.ONE);var c = g.getLowestSetBit();if (c <= 0) {
    return false;
  }var h = g.shiftRight(c);f = f + 1 >> 1;if (f > lowprimes.length) {
    f = lowprimes.length;
  }var b = nbi();for (var e = 0; e < f; ++e) {
    b.fromInt(lowprimes[Math.floor(Math.random() * lowprimes.length)]);var l = b.modPow(h, this);if (l.compareTo(BigInteger.ONE) != 0 && l.compareTo(g) != 0) {
      var d = 1;while (d++ < c && l.compareTo(g) != 0) {
        l = l.modPowInt(2, this);if (l.compareTo(BigInteger.ONE) == 0) {
          return false;
        }
      }if (l.compareTo(g) != 0) {
        return false;
      }
    }
  }return true;
}BigInteger.prototype.chunkSize = bnpChunkSize;BigInteger.prototype.toRadix = bnpToRadix;BigInteger.prototype.fromRadix = bnpFromRadix;BigInteger.prototype.fromNumber = bnpFromNumber;BigInteger.prototype.bitwiseTo = bnpBitwiseTo;BigInteger.prototype.changeBit = bnpChangeBit;BigInteger.prototype.addTo = bnpAddTo;BigInteger.prototype.dMultiply = bnpDMultiply;BigInteger.prototype.dAddOffset = bnpDAddOffset;BigInteger.prototype.multiplyLowerTo = bnpMultiplyLowerTo;BigInteger.prototype.multiplyUpperTo = bnpMultiplyUpperTo;BigInteger.prototype.modInt = bnpModInt;BigInteger.prototype.millerRabin = bnpMillerRabin;BigInteger.prototype.clone = bnClone;BigInteger.prototype.intValue = bnIntValue;BigInteger.prototype.byteValue = bnByteValue;BigInteger.prototype.shortValue = bnShortValue;BigInteger.prototype.signum = bnSigNum;BigInteger.prototype.toByteArray = bnToByteArray;BigInteger.prototype.equals = bnEquals;BigInteger.prototype.min = bnMin;BigInteger.prototype.max = bnMax;BigInteger.prototype.and = bnAnd;BigInteger.prototype.or = bnOr;BigInteger.prototype.xor = bnXor;BigInteger.prototype.andNot = bnAndNot;BigInteger.prototype.not = bnNot;BigInteger.prototype.shiftLeft = bnShiftLeft;BigInteger.prototype.shiftRight = bnShiftRight;BigInteger.prototype.getLowestSetBit = bnGetLowestSetBit;BigInteger.prototype.bitCount = bnBitCount;BigInteger.prototype.testBit = bnTestBit;BigInteger.prototype.setBit = bnSetBit;BigInteger.prototype.clearBit = bnClearBit;BigInteger.prototype.flipBit = bnFlipBit;BigInteger.prototype.add = bnAdd;BigInteger.prototype.subtract = bnSubtract;BigInteger.prototype.multiply = bnMultiply;BigInteger.prototype.divide = bnDivide;BigInteger.prototype.remainder = bnRemainder;BigInteger.prototype.divideAndRemainder = bnDivideAndRemainder;BigInteger.prototype.modPow = bnModPow;BigInteger.prototype.modInverse = bnModInverse;BigInteger.prototype.pow = bnPow;BigInteger.prototype.gcd = bnGCD;BigInteger.prototype.isProbablePrime = bnIsProbablePrime;BigInteger.prototype.square = bnSquare;
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
function Arcfour() {
  this.i = 0;this.j = 0;this.S = new Array();
}function ARC4init(d) {
  var c, a, b;for (c = 0; c < 256; ++c) {
    this.S[c] = c;
  }a = 0;for (c = 0; c < 256; ++c) {
    a = a + this.S[c] + d[c % d.length] & 255;b = this.S[c];this.S[c] = this.S[a];this.S[a] = b;
  }this.i = 0;this.j = 0;
}function ARC4next() {
  var a;this.i = this.i + 1 & 255;this.j = this.j + this.S[this.i] & 255;a = this.S[this.i];this.S[this.i] = this.S[this.j];this.S[this.j] = a;return this.S[a + this.S[this.i] & 255];
}Arcfour.prototype.init = ARC4init;Arcfour.prototype.next = ARC4next;function prng_newstate() {
  return new Arcfour();
}var rng_psize = 256;
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
var rng_state;var rng_pool;var rng_pptr;function rng_seed_int(a) {
  rng_pool[rng_pptr++] ^= a & 255;rng_pool[rng_pptr++] ^= a >> 8 & 255;rng_pool[rng_pptr++] ^= a >> 16 & 255;rng_pool[rng_pptr++] ^= a >> 24 & 255;if (rng_pptr >= rng_psize) {
    rng_pptr -= rng_psize;
  }
}function rng_seed_time() {
  rng_seed_int(new Date().getTime());
}if (rng_pool == null) {
  rng_pool = new Array();rng_pptr = 0;var t;if (window !== undefined && (window.crypto !== undefined || window.msCrypto !== undefined)) {
    var crypto = window.crypto || window.msCrypto;if (crypto.getRandomValues) {
      var ua = new Uint8Array(32);crypto.getRandomValues(ua);for (t = 0; t < 32; ++t) {
        rng_pool[rng_pptr++] = ua[t];
      }
    } else {
      if (navigator.appName == "Netscape" && navigator.appVersion < "5") {
        var z = window.crypto.random(32);for (t = 0; t < z.length; ++t) {
          rng_pool[rng_pptr++] = z.charCodeAt(t) & 255;
        }
      }
    }
  }while (rng_pptr < rng_psize) {
    t = Math.floor(65536 * Math.random());rng_pool[rng_pptr++] = t >>> 8;rng_pool[rng_pptr++] = t & 255;
  }rng_pptr = 0;rng_seed_time();
}function rng_get_byte() {
  if (rng_state == null) {
    rng_seed_time();rng_state = prng_newstate();rng_state.init(rng_pool);for (rng_pptr = 0; rng_pptr < rng_pool.length; ++rng_pptr) {
      rng_pool[rng_pptr] = 0;
    }rng_pptr = 0;
  }return rng_state.next();
}function rng_get_bytes(b) {
  var a;for (a = 0; a < b.length; ++a) {
    b[a] = rng_get_byte();
  }
}function SecureRandom() {}SecureRandom.prototype.nextBytes = rng_get_bytes;
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
function parseBigInt(b, a) {
  return new BigInteger(b, a);
}function linebrk(c, d) {
  var a = "";var b = 0;while (b + d < c.length) {
    a += c.substring(b, b + d) + "\n";b += d;
  }return a + c.substring(b, c.length);
}function byte2Hex(a) {
  if (a < 16) {
    return "0" + a.toString(16);
  } else {
    return a.toString(16);
  }
}function pkcs1pad2(e, h) {
  if (h < e.length + 11) {
    throw "Message too long for RSA";return null;
  }var g = new Array();var d = e.length - 1;while (d >= 0 && h > 0) {
    var f = e.charCodeAt(d--);if (f < 128) {
      g[--h] = f;
    } else {
      if (f > 127 && f < 2048) {
        g[--h] = f & 63 | 128;g[--h] = f >> 6 | 192;
      } else {
        g[--h] = f & 63 | 128;g[--h] = f >> 6 & 63 | 128;g[--h] = f >> 12 | 224;
      }
    }
  }g[--h] = 0;var b = new SecureRandom();var a = new Array();while (h > 2) {
    a[0] = 0;while (a[0] == 0) {
      b.nextBytes(a);
    }g[--h] = a[0];
  }g[--h] = 2;g[--h] = 0;return new BigInteger(g);
}function oaep_mgf1_arr(c, a, e) {
  var b = "",
      d = 0;while (b.length < a) {
    b += e(String.fromCharCode.apply(String, c.concat([(d & 4278190080) >> 24, (d & 16711680) >> 16, (d & 65280) >> 8, d & 255])));d += 1;
  }return b;
}function oaep_pad(q, a, f, l) {
  var c = KJUR.crypto.MessageDigest;var o = KJUR.crypto.Util;var b = null;if (!f) {
    f = "sha1";
  }if (typeof f === "string") {
    b = c.getCanonicalAlgName(f);l = c.getHashLength(b);f = function f(i) {
      return hextorstr(o.hashHex(rstrtohex(i), b));
    };
  }if (q.length + 2 * l + 2 > a) {
    throw "Message too long for RSA";
  }var k = "",
      e;for (e = 0; e < a - q.length - 2 * l - 2; e += 1) {
    k += "\x00";
  }var h = f("") + k + "\x01" + q;var g = new Array(l);new SecureRandom().nextBytes(g);var j = oaep_mgf1_arr(g, h.length, f);var p = [];for (e = 0; e < h.length; e += 1) {
    p[e] = h.charCodeAt(e) ^ j.charCodeAt(e);
  }var m = oaep_mgf1_arr(p, g.length, f);var d = [0];for (e = 0; e < g.length; e += 1) {
    d[e + 1] = g[e] ^ m.charCodeAt(e);
  }return new BigInteger(d.concat(p));
}function RSAKey() {
  this.n = null;this.e = 0;this.d = null;this.p = null;this.q = null;this.dmp1 = null;this.dmq1 = null;this.coeff = null;
}function RSASetPublic(b, a) {
  this.isPublic = true;this.isPrivate = false;if (typeof b !== "string") {
    this.n = b;this.e = a;
  } else {
    if (b != null && a != null && b.length > 0 && a.length > 0) {
      this.n = parseBigInt(b, 16);this.e = parseInt(a, 16);
    } else {
      throw "Invalid RSA public key";
    }
  }
}function RSADoPublic(a) {
  return a.modPowInt(this.e, this.n);
}function RSAEncrypt(d) {
  var a = pkcs1pad2(d, this.n.bitLength() + 7 >> 3);if (a == null) {
    return null;
  }var e = this.doPublic(a);if (e == null) {
    return null;
  }var b = e.toString(16);if ((b.length & 1) == 0) {
    return b;
  } else {
    return "0" + b;
  }
}function RSAEncryptOAEP(f, e, b) {
  var a = oaep_pad(f, this.n.bitLength() + 7 >> 3, e, b);if (a == null) {
    return null;
  }var g = this.doPublic(a);if (g == null) {
    return null;
  }var d = g.toString(16);if ((d.length & 1) == 0) {
    return d;
  } else {
    return "0" + d;
  }
}RSAKey.prototype.doPublic = RSADoPublic;RSAKey.prototype.setPublic = RSASetPublic;RSAKey.prototype.encrypt = RSAEncrypt;RSAKey.prototype.encryptOAEP = RSAEncryptOAEP;RSAKey.prototype.type = "RSA";
/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/
 */
function ECFieldElementFp(b, a) {
  this.x = a;this.q = b;
}function feFpEquals(a) {
  if (a == this) {
    return true;
  }return this.q.equals(a.q) && this.x.equals(a.x);
}function feFpToBigInteger() {
  return this.x;
}function feFpNegate() {
  return new ECFieldElementFp(this.q, this.x.negate().mod(this.q));
}function feFpAdd(a) {
  return new ECFieldElementFp(this.q, this.x.add(a.toBigInteger()).mod(this.q));
}function feFpSubtract(a) {
  return new ECFieldElementFp(this.q, this.x.subtract(a.toBigInteger()).mod(this.q));
}function feFpMultiply(a) {
  return new ECFieldElementFp(this.q, this.x.multiply(a.toBigInteger()).mod(this.q));
}function feFpSquare() {
  return new ECFieldElementFp(this.q, this.x.square().mod(this.q));
}function feFpDivide(a) {
  return new ECFieldElementFp(this.q, this.x.multiply(a.toBigInteger().modInverse(this.q)).mod(this.q));
}ECFieldElementFp.prototype.equals = feFpEquals;ECFieldElementFp.prototype.toBigInteger = feFpToBigInteger;ECFieldElementFp.prototype.negate = feFpNegate;ECFieldElementFp.prototype.add = feFpAdd;ECFieldElementFp.prototype.subtract = feFpSubtract;ECFieldElementFp.prototype.multiply = feFpMultiply;ECFieldElementFp.prototype.square = feFpSquare;ECFieldElementFp.prototype.divide = feFpDivide;function ECPointFp(c, a, d, b) {
  this.curve = c;this.x = a;this.y = d;if (b == null) {
    this.z = BigInteger.ONE;
  } else {
    this.z = b;
  }this.zinv = null;
}function pointFpGetX() {
  if (this.zinv == null) {
    this.zinv = this.z.modInverse(this.curve.q);
  }return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q));
}function pointFpGetY() {
  if (this.zinv == null) {
    this.zinv = this.z.modInverse(this.curve.q);
  }return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q));
}function pointFpEquals(a) {
  if (a == this) {
    return true;
  }if (this.isInfinity()) {
    return a.isInfinity();
  }if (a.isInfinity()) {
    return this.isInfinity();
  }var c, b;c = a.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(a.z)).mod(this.curve.q);if (!c.equals(BigInteger.ZERO)) {
    return false;
  }b = a.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(a.z)).mod(this.curve.q);return b.equals(BigInteger.ZERO);
}function pointFpIsInfinity() {
  if (this.x == null && this.y == null) {
    return true;
  }return this.z.equals(BigInteger.ZERO) && !this.y.toBigInteger().equals(BigInteger.ZERO);
}function pointFpNegate() {
  return new ECPointFp(this.curve, this.x, this.y.negate(), this.z);
}function pointFpAdd(l) {
  if (this.isInfinity()) {
    return l;
  }if (l.isInfinity()) {
    return this;
  }var p = l.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(l.z)).mod(this.curve.q);var o = l.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(l.z)).mod(this.curve.q);if (BigInteger.ZERO.equals(o)) {
    if (BigInteger.ZERO.equals(p)) {
      return this.twice();
    }return this.curve.getInfinity();
  }var j = new BigInteger("3");var e = this.x.toBigInteger();var n = this.y.toBigInteger();var c = l.x.toBigInteger();var k = l.y.toBigInteger();var m = o.square();var i = m.multiply(o);var d = e.multiply(m);var g = p.square().multiply(this.z);var a = g.subtract(d.shiftLeft(1)).multiply(l.z).subtract(i).multiply(o).mod(this.curve.q);var h = d.multiply(j).multiply(p).subtract(n.multiply(i)).subtract(g.multiply(p)).multiply(l.z).add(p.multiply(i)).mod(this.curve.q);var f = i.multiply(this.z).multiply(l.z).mod(this.curve.q);return new ECPointFp(this.curve, this.curve.fromBigInteger(a), this.curve.fromBigInteger(h), f);
}function pointFpTwice() {
  if (this.isInfinity()) {
    return this;
  }if (this.y.toBigInteger().signum() == 0) {
    return this.curve.getInfinity();
  }var g = new BigInteger("3");var c = this.x.toBigInteger();var h = this.y.toBigInteger();var e = h.multiply(this.z);var j = e.multiply(h).mod(this.curve.q);var i = this.curve.a.toBigInteger();var k = c.square().multiply(g);if (!BigInteger.ZERO.equals(i)) {
    k = k.add(this.z.square().multiply(i));
  }k = k.mod(this.curve.q);var b = k.square().subtract(c.shiftLeft(3).multiply(j)).shiftLeft(1).multiply(e).mod(this.curve.q);var f = k.multiply(g).multiply(c).subtract(j.shiftLeft(1)).shiftLeft(2).multiply(j).subtract(k.square().multiply(k)).mod(this.curve.q);var d = e.square().multiply(e).shiftLeft(3).mod(this.curve.q);return new ECPointFp(this.curve, this.curve.fromBigInteger(b), this.curve.fromBigInteger(f), d);
}function pointFpMultiply(b) {
  if (this.isInfinity()) {
    return this;
  }if (b.signum() == 0) {
    return this.curve.getInfinity();
  }var g = b;var f = g.multiply(new BigInteger("3"));var l = this.negate();var d = this;var c;for (c = f.bitLength() - 2; c > 0; --c) {
    d = d.twice();var a = f.testBit(c);var j = g.testBit(c);if (a != j) {
      d = d.add(a ? this : l);
    }
  }return d;
}function pointFpMultiplyTwo(c, a, b) {
  var d;if (c.bitLength() > b.bitLength()) {
    d = c.bitLength() - 1;
  } else {
    d = b.bitLength() - 1;
  }var f = this.curve.getInfinity();var e = this.add(a);while (d >= 0) {
    f = f.twice();if (c.testBit(d)) {
      if (b.testBit(d)) {
        f = f.add(e);
      } else {
        f = f.add(this);
      }
    } else {
      if (b.testBit(d)) {
        f = f.add(a);
      }
    }--d;
  }return f;
}ECPointFp.prototype.getX = pointFpGetX;ECPointFp.prototype.getY = pointFpGetY;ECPointFp.prototype.equals = pointFpEquals;ECPointFp.prototype.isInfinity = pointFpIsInfinity;ECPointFp.prototype.negate = pointFpNegate;ECPointFp.prototype.add = pointFpAdd;ECPointFp.prototype.twice = pointFpTwice;ECPointFp.prototype.multiply = pointFpMultiply;ECPointFp.prototype.multiplyTwo = pointFpMultiplyTwo;function ECCurveFp(e, d, c) {
  this.q = e;this.a = this.fromBigInteger(d);this.b = this.fromBigInteger(c);this.infinity = new ECPointFp(this, null, null);
}function curveFpGetQ() {
  return this.q;
}function curveFpGetA() {
  return this.a;
}function curveFpGetB() {
  return this.b;
}function curveFpEquals(a) {
  if (a == this) {
    return true;
  }return this.q.equals(a.q) && this.a.equals(a.a) && this.b.equals(a.b);
}function curveFpGetInfinity() {
  return this.infinity;
}function curveFpFromBigInteger(a) {
  return new ECFieldElementFp(this.q, a);
}function curveFpDecodePointHex(d) {
  switch (parseInt(d.substr(0, 2), 16)) {case 0:
      return this.infinity;case 2:case 3:
      return null;case 4:case 6:case 7:
      var a = (d.length - 2) / 2;var c = d.substr(2, a);var b = d.substr(a + 2, a);return new ECPointFp(this, this.fromBigInteger(new BigInteger(c, 16)), this.fromBigInteger(new BigInteger(b, 16)));default:
      return null;}
}ECCurveFp.prototype.getQ = curveFpGetQ;ECCurveFp.prototype.getA = curveFpGetA;ECCurveFp.prototype.getB = curveFpGetB;ECCurveFp.prototype.equals = curveFpEquals;ECCurveFp.prototype.getInfinity = curveFpGetInfinity;ECCurveFp.prototype.fromBigInteger = curveFpFromBigInteger;ECCurveFp.prototype.decodePointHex = curveFpDecodePointHex;
/*! (c) Stefan Thomas | https://github.com/bitcoinjs/bitcoinjs-lib
 */
ECFieldElementFp.prototype.getByteLength = function () {
  return Math.floor((this.toBigInteger().bitLength() + 7) / 8);
};ECPointFp.prototype.getEncoded = function (c) {
  var d = function d(h, f) {
    var g = h.toByteArrayUnsigned();if (f < g.length) {
      g = g.slice(g.length - f);
    } else {
      while (f > g.length) {
        g.unshift(0);
      }
    }return g;
  };var a = this.getX().toBigInteger();var e = this.getY().toBigInteger();var b = d(a, 32);if (c) {
    if (e.isEven()) {
      b.unshift(2);
    } else {
      b.unshift(3);
    }
  } else {
    b.unshift(4);b = b.concat(d(e, 32));
  }return b;
};ECPointFp.decodeFrom = function (g, c) {
  var f = c[0];var e = c.length - 1;var d = c.slice(1, 1 + e / 2);var b = c.slice(1 + e / 2, 1 + e);d.unshift(0);b.unshift(0);var a = new BigInteger(d);var h = new BigInteger(b);return new ECPointFp(g, g.fromBigInteger(a), g.fromBigInteger(h));
};ECPointFp.decodeFromHex = function (g, c) {
  var f = c.substr(0, 2);var e = c.length - 2;var d = c.substr(2, e / 2);var b = c.substr(2 + e / 2, e / 2);var a = new BigInteger(d, 16);var h = new BigInteger(b, 16);return new ECPointFp(g, g.fromBigInteger(a), g.fromBigInteger(h));
};ECPointFp.prototype.add2D = function (c) {
  if (this.isInfinity()) {
    return c;
  }if (c.isInfinity()) {
    return this;
  }if (this.x.equals(c.x)) {
    if (this.y.equals(c.y)) {
      return this.twice();
    }return this.curve.getInfinity();
  }var g = c.x.subtract(this.x);var e = c.y.subtract(this.y);var a = e.divide(g);var d = a.square().subtract(this.x).subtract(c.x);var f = a.multiply(this.x.subtract(d)).subtract(this.y);return new ECPointFp(this.curve, d, f);
};ECPointFp.prototype.twice2D = function () {
  if (this.isInfinity()) {
    return this;
  }if (this.y.toBigInteger().signum() == 0) {
    return this.curve.getInfinity();
  }var b = this.curve.fromBigInteger(BigInteger.valueOf(2));var e = this.curve.fromBigInteger(BigInteger.valueOf(3));var a = this.x.square().multiply(e).add(this.curve.a).divide(this.y.multiply(b));var c = a.square().subtract(this.x.multiply(b));var d = a.multiply(this.x.subtract(c)).subtract(this.y);return new ECPointFp(this.curve, c, d);
};ECPointFp.prototype.multiply2D = function (b) {
  if (this.isInfinity()) {
    return this;
  }if (b.signum() == 0) {
    return this.curve.getInfinity();
  }var g = b;var f = g.multiply(new BigInteger("3"));var l = this.negate();var d = this;var c;for (c = f.bitLength() - 2; c > 0; --c) {
    d = d.twice();var a = f.testBit(c);var j = g.testBit(c);if (a != j) {
      d = d.add2D(a ? this : l);
    }
  }return d;
};ECPointFp.prototype.isOnCurve = function () {
  var d = this.getX().toBigInteger();var i = this.getY().toBigInteger();var f = this.curve.getA().toBigInteger();var c = this.curve.getB().toBigInteger();var h = this.curve.getQ();var e = i.multiply(i).mod(h);var g = d.multiply(d).multiply(d).add(f.multiply(d)).add(c).mod(h);return e.equals(g);
};ECPointFp.prototype.toString = function () {
  return "(" + this.getX().toBigInteger().toString() + "," + this.getY().toBigInteger().toString() + ")";
};ECPointFp.prototype.validate = function () {
  var c = this.curve.getQ();if (this.isInfinity()) {
    throw new Error("Point is at infinity.");
  }var a = this.getX().toBigInteger();var b = this.getY().toBigInteger();if (a.compareTo(BigInteger.ONE) < 0 || a.compareTo(c.subtract(BigInteger.ONE)) > 0) {
    throw new Error("x coordinate out of bounds");
  }if (b.compareTo(BigInteger.ONE) < 0 || b.compareTo(c.subtract(BigInteger.ONE)) > 0) {
    throw new Error("y coordinate out of bounds");
  }if (!this.isOnCurve()) {
    throw new Error("Point is not on the curve.");
  }if (this.multiply(c).isInfinity()) {
    throw new Error("Point is not a scalar multiple of G.");
  }return true;
};
/*! Mike Samuel (c) 2009 | code.google.com/p/json-sans-eval
 */
var jsonParse = function () {
  var e = "(?:-?\\b(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\b)";var j = '(?:[^\\0-\\x08\\x0a-\\x1f"\\\\]|\\\\(?:["/\\\\bfnrt]|u[0-9A-Fa-f]{4}))';var i = '(?:"' + j + '*")';var d = new RegExp("(?:false|true|null|[\\{\\}\\[\\]]|" + e + "|" + i + ")", "g");var k = new RegExp("\\\\(?:([^u])|u(.{4}))", "g");var g = { '"': '"', "/": "/", "\\": "\\", b: "\b", f: "\f", n: "\n", r: "\r", t: "\t" };function h(l, m, n) {
    return m ? g[m] : String.fromCharCode(parseInt(n, 16));
  }var c = new String("");var a = "\\";var f = { "{": Object, "[": Array };var b = Object.hasOwnProperty;return function (u, q) {
    var p = u.match(d);var x;var v = p[0];var l = false;if ("{" === v) {
      x = {};
    } else {
      if ("[" === v) {
        x = [];
      } else {
        x = [];l = true;
      }
    }var t;var r = [x];for (var o = 1 - l, m = p.length; o < m; ++o) {
      v = p[o];var w;switch (v.charCodeAt(0)) {default:
          w = r[0];w[t || w.length] = +v;t = void 0;break;case 34:
          v = v.substring(1, v.length - 1);if (v.indexOf(a) !== -1) {
            v = v.replace(k, h);
          }w = r[0];if (!t) {
            if (w instanceof Array) {
              t = w.length;
            } else {
              t = v || c;break;
            }
          }w[t] = v;t = void 0;break;case 91:
          w = r[0];r.unshift(w[t || w.length] = []);t = void 0;break;case 93:
          r.shift();break;case 102:
          w = r[0];w[t || w.length] = false;t = void 0;break;case 110:
          w = r[0];w[t || w.length] = null;t = void 0;break;case 116:
          w = r[0];w[t || w.length] = true;t = void 0;break;case 123:
          w = r[0];r.unshift(w[t || w.length] = {});t = void 0;break;case 125:
          r.shift();break;}
    }if (l) {
      if (r.length !== 1) {
        throw new Error();
      }x = x[0];
    } else {
      if (r.length) {
        throw new Error();
      }
    }if (q) {
      var s = function s(C, B) {
        var D = C[B];if (D && (typeof D === "undefined" ? "undefined" : _typeof(D)) === "object") {
          var n = null;for (var z in D) {
            if (b.call(D, z) && D !== C) {
              var y = s(D, z);if (y !== void 0) {
                D[z] = y;
              } else {
                if (!n) {
                  n = [];
                }n.push(z);
              }
            }
          }if (n) {
            for (var A = n.length; --A >= 0;) {
              delete D[n[A]];
            }
          }
        }return q.call(C, B, D);
      };x = s({ "": x }, "");
    }return x;
  };
}();
if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.asn1 == "undefined" || !KJUR.asn1) {
  KJUR.asn1 = {};
}KJUR.asn1.ASN1Util = new function () {
  this.integerToByteHex = function (a) {
    var b = a.toString(16);if (b.length % 2 == 1) {
      b = "0" + b;
    }return b;
  };this.bigIntToMinTwosComplementsHex = function (j) {
    var f = j.toString(16);if (f.substr(0, 1) != "-") {
      if (f.length % 2 == 1) {
        f = "0" + f;
      } else {
        if (!f.match(/^[0-7]/)) {
          f = "00" + f;
        }
      }
    } else {
      var a = f.substr(1);var e = a.length;if (e % 2 == 1) {
        e += 1;
      } else {
        if (!f.match(/^[0-7]/)) {
          e += 2;
        }
      }var g = "";for (var d = 0; d < e; d++) {
        g += "f";
      }var c = new BigInteger(g, 16);var b = c.xor(j).add(BigInteger.ONE);f = b.toString(16).replace(/^-/, "");
    }return f;
  };this.getPEMStringFromHex = function (a, b) {
    return hextopem(a, b);
  };this.newObject = function (k) {
    var D = KJUR,
        n = D.asn1,
        z = n.DERBoolean,
        e = n.DERInteger,
        s = n.DERBitString,
        h = n.DEROctetString,
        v = n.DERNull,
        w = n.DERObjectIdentifier,
        l = n.DEREnumerated,
        g = n.DERUTF8String,
        f = n.DERNumericString,
        y = n.DERPrintableString,
        u = n.DERTeletexString,
        p = n.DERIA5String,
        C = n.DERUTCTime,
        j = n.DERGeneralizedTime,
        m = n.DERSequence,
        c = n.DERSet,
        r = n.DERTaggedObject,
        o = n.ASN1Util.newObject;var t = Object.keys(k);if (t.length != 1) {
      throw "key of param shall be only one.";
    }var F = t[0];if (":bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:seq:set:tag:".indexOf(":" + F + ":") == -1) {
      throw "undefined key: " + F;
    }if (F == "bool") {
      return new z(k[F]);
    }if (F == "int") {
      return new e(k[F]);
    }if (F == "bitstr") {
      return new s(k[F]);
    }if (F == "octstr") {
      return new h(k[F]);
    }if (F == "null") {
      return new v(k[F]);
    }if (F == "oid") {
      return new w(k[F]);
    }if (F == "enum") {
      return new l(k[F]);
    }if (F == "utf8str") {
      return new g(k[F]);
    }if (F == "numstr") {
      return new f(k[F]);
    }if (F == "prnstr") {
      return new y(k[F]);
    }if (F == "telstr") {
      return new u(k[F]);
    }if (F == "ia5str") {
      return new p(k[F]);
    }if (F == "utctime") {
      return new C(k[F]);
    }if (F == "gentime") {
      return new j(k[F]);
    }if (F == "seq") {
      var d = k[F];var E = [];for (var x = 0; x < d.length; x++) {
        var B = o(d[x]);E.push(B);
      }return new m({ array: E });
    }if (F == "set") {
      var d = k[F];var E = [];for (var x = 0; x < d.length; x++) {
        var B = o(d[x]);E.push(B);
      }return new c({ array: E });
    }if (F == "tag") {
      var A = k[F];if (Object.prototype.toString.call(A) === "[object Array]" && A.length == 3) {
        var q = o(A[2]);return new r({ tag: A[0], explicit: A[1], obj: q });
      } else {
        var b = {};if (A.explicit !== undefined) {
          b.explicit = A.explicit;
        }if (A.tag !== undefined) {
          b.tag = A.tag;
        }if (A.obj === undefined) {
          throw "obj shall be specified for 'tag'.";
        }b.obj = o(A.obj);return new r(b);
      }
    }
  };this.jsonToASN1HEX = function (b) {
    var a = this.newObject(b);return a.getEncodedHex();
  };
}();KJUR.asn1.ASN1Util.oidHexToInt = function (a) {
  var j = "";var k = parseInt(a.substr(0, 2), 16);var d = Math.floor(k / 40);var c = k % 40;var j = d + "." + c;var e = "";for (var f = 2; f < a.length; f += 2) {
    var g = parseInt(a.substr(f, 2), 16);var h = ("00000000" + g.toString(2)).slice(-8);e = e + h.substr(1, 7);if (h.substr(0, 1) == "0") {
      var b = new BigInteger(e, 2);j = j + "." + b.toString(10);e = "";
    }
  }return j;
};KJUR.asn1.ASN1Util.oidIntToHex = function (f) {
  var e = function e(a) {
    var k = a.toString(16);if (k.length == 1) {
      k = "0" + k;
    }return k;
  };var d = function d(o) {
    var n = "";var k = new BigInteger(o, 10);var a = k.toString(2);var l = 7 - a.length % 7;if (l == 7) {
      l = 0;
    }var q = "";for (var m = 0; m < l; m++) {
      q += "0";
    }a = q + a;for (var m = 0; m < a.length - 1; m += 7) {
      var p = a.substr(m, 7);if (m != a.length - 7) {
        p = "1" + p;
      }n += e(parseInt(p, 2));
    }return n;
  };if (!f.match(/^[0-9.]+$/)) {
    throw "malformed oid string: " + f;
  }var g = "";var b = f.split(".");var j = parseInt(b[0]) * 40 + parseInt(b[1]);g += e(j);b.splice(0, 2);for (var c = 0; c < b.length; c++) {
    g += d(b[c]);
  }return g;
};KJUR.asn1.ASN1Object = function () {
  var c = true;var b = null;var d = "00";var e = "00";var a = "";this.getLengthHexFromValue = function () {
    if (typeof this.hV == "undefined" || this.hV == null) {
      throw "this.hV is null or undefined.";
    }if (this.hV.length % 2 == 1) {
      throw "value hex must be even length: n=" + a.length + ",v=" + this.hV;
    }var i = this.hV.length / 2;var h = i.toString(16);if (h.length % 2 == 1) {
      h = "0" + h;
    }if (i < 128) {
      return h;
    } else {
      var g = h.length / 2;if (g > 15) {
        throw "ASN.1 length too long to represent by 8x: n = " + i.toString(16);
      }var f = 128 + g;return f.toString(16) + h;
    }
  };this.getEncodedHex = function () {
    if (this.hTLV == null || this.isModified) {
      this.hV = this.getFreshValueHex();this.hL = this.getLengthHexFromValue();this.hTLV = this.hT + this.hL + this.hV;this.isModified = false;
    }return this.hTLV;
  };this.getValueHex = function () {
    this.getEncodedHex();return this.hV;
  };this.getFreshValueHex = function () {
    return "";
  };
};KJUR.asn1.DERAbstractString = function (c) {
  KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var b = null;var a = null;this.getString = function () {
    return this.s;
  };this.setString = function (d) {
    this.hTLV = null;this.isModified = true;this.s = d;this.hV = utf8tohex(this.s).toLowerCase();
  };this.setStringHex = function (d) {
    this.hTLV = null;this.isModified = true;this.s = null;this.hV = d;
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (typeof c != "undefined") {
    if (typeof c == "string") {
      this.setString(c);
    } else {
      if (typeof c.str != "undefined") {
        this.setString(c.str);
      } else {
        if (typeof c.hex != "undefined") {
          this.setStringHex(c.hex);
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERAbstractString, KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractTime = function (c) {
  KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);var b = null;var a = null;this.localDateToUTC = function (f) {
    utc = f.getTime() + f.getTimezoneOffset() * 60000;var e = new Date(utc);return e;
  };this.formatDate = function (m, o, e) {
    var g = this.zeroPadding;var n = this.localDateToUTC(m);var p = String(n.getFullYear());if (o == "utc") {
      p = p.substr(2, 2);
    }var l = g(String(n.getMonth() + 1), 2);var q = g(String(n.getDate()), 2);var h = g(String(n.getHours()), 2);var i = g(String(n.getMinutes()), 2);var j = g(String(n.getSeconds()), 2);var r = p + l + q + h + i + j;if (e === true) {
      var f = n.getMilliseconds();if (f != 0) {
        var k = g(String(f), 3);k = k.replace(/[0]+$/, "");r = r + "." + k;
      }
    }return r + "Z";
  };this.zeroPadding = function (e, d) {
    if (e.length >= d) {
      return e;
    }return new Array(d - e.length + 1).join("0") + e;
  };this.getString = function () {
    return this.s;
  };this.setString = function (d) {
    this.hTLV = null;this.isModified = true;this.s = d;this.hV = stohex(d);
  };this.setByDateValue = function (h, j, e, d, f, g) {
    var i = new Date(Date.UTC(h, j - 1, e, d, f, g, 0));this.setByDate(i);
  };this.getFreshValueHex = function () {
    return this.hV;
  };
};YAHOO.lang.extend(KJUR.asn1.DERAbstractTime, KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractStructured = function (b) {
  KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var a = null;this.setByASN1ObjectArray = function (c) {
    this.hTLV = null;this.isModified = true;this.asn1Array = c;
  };this.appendASN1Object = function (c) {
    this.hTLV = null;this.isModified = true;this.asn1Array.push(c);
  };this.asn1Array = new Array();if (typeof b != "undefined") {
    if (typeof b.array != "undefined") {
      this.asn1Array = b.array;
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERAbstractStructured, KJUR.asn1.ASN1Object);KJUR.asn1.DERBoolean = function () {
  KJUR.asn1.DERBoolean.superclass.constructor.call(this);this.hT = "01";this.hTLV = "0101ff";
};YAHOO.lang.extend(KJUR.asn1.DERBoolean, KJUR.asn1.ASN1Object);KJUR.asn1.DERInteger = function (a) {
  KJUR.asn1.DERInteger.superclass.constructor.call(this);this.hT = "02";this.setByBigInteger = function (b) {
    this.hTLV = null;this.isModified = true;this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b);
  };this.setByInteger = function (c) {
    var b = new BigInteger(String(c), 10);this.setByBigInteger(b);
  };this.setValueHex = function (b) {
    this.hV = b;
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (typeof a != "undefined") {
    if (typeof a.bigint != "undefined") {
      this.setByBigInteger(a.bigint);
    } else {
      if (typeof a["int"] != "undefined") {
        this.setByInteger(a["int"]);
      } else {
        if (typeof a == "number") {
          this.setByInteger(a);
        } else {
          if (typeof a.hex != "undefined") {
            this.setValueHex(a.hex);
          }
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERInteger, KJUR.asn1.ASN1Object);KJUR.asn1.DERBitString = function (b) {
  if (b !== undefined && typeof b.obj !== "undefined") {
    var a = KJUR.asn1.ASN1Util.newObject(b.obj);b.hex = "00" + a.getEncodedHex();
  }KJUR.asn1.DERBitString.superclass.constructor.call(this);this.hT = "03";this.setHexValueIncludingUnusedBits = function (c) {
    this.hTLV = null;this.isModified = true;this.hV = c;
  };this.setUnusedBitsAndHexValue = function (c, e) {
    if (c < 0 || 7 < c) {
      throw "unused bits shall be from 0 to 7: u = " + c;
    }var d = "0" + c;this.hTLV = null;this.isModified = true;this.hV = d + e;
  };this.setByBinaryString = function (e) {
    e = e.replace(/0+$/, "");var f = 8 - e.length % 8;if (f == 8) {
      f = 0;
    }for (var g = 0; g <= f; g++) {
      e += "0";
    }var j = "";for (var g = 0; g < e.length - 1; g += 8) {
      var d = e.substr(g, 8);var c = parseInt(d, 2).toString(16);if (c.length == 1) {
        c = "0" + c;
      }j += c;
    }this.hTLV = null;this.isModified = true;this.hV = "0" + f + j;
  };this.setByBooleanArray = function (e) {
    var d = "";for (var c = 0; c < e.length; c++) {
      if (e[c] == true) {
        d += "1";
      } else {
        d += "0";
      }
    }this.setByBinaryString(d);
  };this.newFalseArray = function (e) {
    var c = new Array(e);for (var d = 0; d < e; d++) {
      c[d] = false;
    }return c;
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (typeof b != "undefined") {
    if (typeof b == "string" && b.toLowerCase().match(/^[0-9a-f]+$/)) {
      this.setHexValueIncludingUnusedBits(b);
    } else {
      if (typeof b.hex != "undefined") {
        this.setHexValueIncludingUnusedBits(b.hex);
      } else {
        if (typeof b.bin != "undefined") {
          this.setByBinaryString(b.bin);
        } else {
          if (typeof b.array != "undefined") {
            this.setByBooleanArray(b.array);
          }
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERBitString, KJUR.asn1.ASN1Object);KJUR.asn1.DEROctetString = function (b) {
  if (b !== undefined && typeof b.obj !== "undefined") {
    var a = KJUR.asn1.ASN1Util.newObject(b.obj);b.hex = a.getEncodedHex();
  }KJUR.asn1.DEROctetString.superclass.constructor.call(this, b);this.hT = "04";
};YAHOO.lang.extend(KJUR.asn1.DEROctetString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERNull = function () {
  KJUR.asn1.DERNull.superclass.constructor.call(this);this.hT = "05";this.hTLV = "0500";
};YAHOO.lang.extend(KJUR.asn1.DERNull, KJUR.asn1.ASN1Object);KJUR.asn1.DERObjectIdentifier = function (c) {
  var b = function b(d) {
    var e = d.toString(16);if (e.length == 1) {
      e = "0" + e;
    }return e;
  };var a = function a(k) {
    var j = "";var e = new BigInteger(k, 10);var d = e.toString(2);var f = 7 - d.length % 7;if (f == 7) {
      f = 0;
    }var m = "";for (var g = 0; g < f; g++) {
      m += "0";
    }d = m + d;for (var g = 0; g < d.length - 1; g += 7) {
      var l = d.substr(g, 7);if (g != d.length - 7) {
        l = "1" + l;
      }j += b(parseInt(l, 2));
    }return j;
  };KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);this.hT = "06";this.setValueHex = function (d) {
    this.hTLV = null;this.isModified = true;this.s = null;this.hV = d;
  };this.setValueOidString = function (f) {
    if (!f.match(/^[0-9.]+$/)) {
      throw "malformed oid string: " + f;
    }var g = "";var d = f.split(".");var j = parseInt(d[0]) * 40 + parseInt(d[1]);g += b(j);d.splice(0, 2);for (var e = 0; e < d.length; e++) {
      g += a(d[e]);
    }this.hTLV = null;this.isModified = true;this.s = null;this.hV = g;
  };this.setValueName = function (e) {
    var d = KJUR.asn1.x509.OID.name2oid(e);if (d !== "") {
      this.setValueOidString(d);
    } else {
      throw "DERObjectIdentifier oidName undefined: " + e;
    }
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (c !== undefined) {
    if (typeof c === "string") {
      if (c.match(/^[0-2].[0-9.]+$/)) {
        this.setValueOidString(c);
      } else {
        this.setValueName(c);
      }
    } else {
      if (c.oid !== undefined) {
        this.setValueOidString(c.oid);
      } else {
        if (c.hex !== undefined) {
          this.setValueHex(c.hex);
        } else {
          if (c.name !== undefined) {
            this.setValueName(c.name);
          }
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERObjectIdentifier, KJUR.asn1.ASN1Object);KJUR.asn1.DEREnumerated = function (a) {
  KJUR.asn1.DEREnumerated.superclass.constructor.call(this);this.hT = "0a";this.setByBigInteger = function (b) {
    this.hTLV = null;this.isModified = true;this.hV = KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b);
  };this.setByInteger = function (c) {
    var b = new BigInteger(String(c), 10);this.setByBigInteger(b);
  };this.setValueHex = function (b) {
    this.hV = b;
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (typeof a != "undefined") {
    if (typeof a["int"] != "undefined") {
      this.setByInteger(a["int"]);
    } else {
      if (typeof a == "number") {
        this.setByInteger(a);
      } else {
        if (typeof a.hex != "undefined") {
          this.setValueHex(a.hex);
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DEREnumerated, KJUR.asn1.ASN1Object);KJUR.asn1.DERUTF8String = function (a) {
  KJUR.asn1.DERUTF8String.superclass.constructor.call(this, a);this.hT = "0c";
};YAHOO.lang.extend(KJUR.asn1.DERUTF8String, KJUR.asn1.DERAbstractString);KJUR.asn1.DERNumericString = function (a) {
  KJUR.asn1.DERNumericString.superclass.constructor.call(this, a);this.hT = "12";
};YAHOO.lang.extend(KJUR.asn1.DERNumericString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERPrintableString = function (a) {
  KJUR.asn1.DERPrintableString.superclass.constructor.call(this, a);this.hT = "13";
};YAHOO.lang.extend(KJUR.asn1.DERPrintableString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERTeletexString = function (a) {
  KJUR.asn1.DERTeletexString.superclass.constructor.call(this, a);this.hT = "14";
};YAHOO.lang.extend(KJUR.asn1.DERTeletexString, KJUR.asn1.DERAbstractString);KJUR.asn1.DERIA5String = function (a) {
  KJUR.asn1.DERIA5String.superclass.constructor.call(this, a);this.hT = "16";
};YAHOO.lang.extend(KJUR.asn1.DERIA5String, KJUR.asn1.DERAbstractString);KJUR.asn1.DERUTCTime = function (a) {
  KJUR.asn1.DERUTCTime.superclass.constructor.call(this, a);this.hT = "17";this.setByDate = function (b) {
    this.hTLV = null;this.isModified = true;this.date = b;this.s = this.formatDate(this.date, "utc");this.hV = stohex(this.s);
  };this.getFreshValueHex = function () {
    if (typeof this.date == "undefined" && typeof this.s == "undefined") {
      this.date = new Date();this.s = this.formatDate(this.date, "utc");this.hV = stohex(this.s);
    }return this.hV;
  };if (a !== undefined) {
    if (a.str !== undefined) {
      this.setString(a.str);
    } else {
      if (typeof a == "string" && a.match(/^[0-9]{12}Z$/)) {
        this.setString(a);
      } else {
        if (a.hex !== undefined) {
          this.setStringHex(a.hex);
        } else {
          if (a.date !== undefined) {
            this.setByDate(a.date);
          }
        }
      }
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERUTCTime, KJUR.asn1.DERAbstractTime);KJUR.asn1.DERGeneralizedTime = function (a) {
  KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this, a);this.hT = "18";this.withMillis = false;this.setByDate = function (b) {
    this.hTLV = null;this.isModified = true;this.date = b;this.s = this.formatDate(this.date, "gen", this.withMillis);this.hV = stohex(this.s);
  };this.getFreshValueHex = function () {
    if (this.date === undefined && this.s === undefined) {
      this.date = new Date();this.s = this.formatDate(this.date, "gen", this.withMillis);this.hV = stohex(this.s);
    }return this.hV;
  };if (a !== undefined) {
    if (a.str !== undefined) {
      this.setString(a.str);
    } else {
      if (typeof a == "string" && a.match(/^[0-9]{14}Z$/)) {
        this.setString(a);
      } else {
        if (a.hex !== undefined) {
          this.setStringHex(a.hex);
        } else {
          if (a.date !== undefined) {
            this.setByDate(a.date);
          }
        }
      }
    }if (a.millis === true) {
      this.withMillis = true;
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERGeneralizedTime, KJUR.asn1.DERAbstractTime);KJUR.asn1.DERSequence = function (a) {
  KJUR.asn1.DERSequence.superclass.constructor.call(this, a);this.hT = "30";this.getFreshValueHex = function () {
    var c = "";for (var b = 0; b < this.asn1Array.length; b++) {
      var d = this.asn1Array[b];c += d.getEncodedHex();
    }this.hV = c;return this.hV;
  };
};YAHOO.lang.extend(KJUR.asn1.DERSequence, KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERSet = function (a) {
  KJUR.asn1.DERSet.superclass.constructor.call(this, a);this.hT = "31";this.sortFlag = true;this.getFreshValueHex = function () {
    var b = new Array();for (var c = 0; c < this.asn1Array.length; c++) {
      var d = this.asn1Array[c];b.push(d.getEncodedHex());
    }if (this.sortFlag == true) {
      b.sort();
    }this.hV = b.join("");return this.hV;
  };if (typeof a != "undefined") {
    if (typeof a.sortflag != "undefined" && a.sortflag == false) {
      this.sortFlag = false;
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERSet, KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERTaggedObject = function (a) {
  KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);this.hT = "a0";this.hV = "";this.isExplicit = true;this.asn1Object = null;this.setASN1Object = function (b, c, d) {
    this.hT = c;this.isExplicit = b;this.asn1Object = d;if (this.isExplicit) {
      this.hV = this.asn1Object.getEncodedHex();this.hTLV = null;this.isModified = true;
    } else {
      this.hV = null;this.hTLV = d.getEncodedHex();this.hTLV = this.hTLV.replace(/^../, c);this.isModified = false;
    }
  };this.getFreshValueHex = function () {
    return this.hV;
  };if (typeof a != "undefined") {
    if (typeof a.tag != "undefined") {
      this.hT = a.tag;
    }if (typeof a.explicit != "undefined") {
      this.isExplicit = a.explicit;
    }if (typeof a.obj != "undefined") {
      this.asn1Object = a.obj;this.setASN1Object(this.isExplicit, this.hT, this.asn1Object);
    }
  }
};YAHOO.lang.extend(KJUR.asn1.DERTaggedObject, KJUR.asn1.ASN1Object);
var ASN1HEX = new function () {}();ASN1HEX.getLblen = function (c, a) {
  if (c.substr(a + 2, 1) != "8") {
    return 1;
  }var b = parseInt(c.substr(a + 3, 1));if (b == 0) {
    return -1;
  }if (0 < b && b < 10) {
    return b + 1;
  }return -2;
};ASN1HEX.getL = function (c, b) {
  var a = ASN1HEX.getLblen(c, b);if (a < 1) {
    return "";
  }return c.substr(b + 2, a * 2);
};ASN1HEX.getVblen = function (d, a) {
  var c, b;c = ASN1HEX.getL(d, a);if (c == "") {
    return -1;
  }if (c.substr(0, 1) === "8") {
    b = new BigInteger(c.substr(2), 16);
  } else {
    b = new BigInteger(c, 16);
  }return b.intValue();
};ASN1HEX.getVidx = function (c, b) {
  var a = ASN1HEX.getLblen(c, b);if (a < 0) {
    return a;
  }return b + (a + 1) * 2;
};ASN1HEX.getV = function (d, a) {
  var c = ASN1HEX.getVidx(d, a);var b = ASN1HEX.getVblen(d, a);return d.substr(c, b * 2);
};ASN1HEX.getTLV = function (b, a) {
  return b.substr(a, 2) + ASN1HEX.getL(b, a) + ASN1HEX.getV(b, a);
};ASN1HEX.getNextSiblingIdx = function (d, a) {
  var c = ASN1HEX.getVidx(d, a);var b = ASN1HEX.getVblen(d, a);return c + b * 2;
};ASN1HEX.getChildIdx = function (e, f) {
  var j = ASN1HEX;var g = new Array();var i = j.getVidx(e, f);if (e.substr(f, 2) == "03") {
    g.push(i + 2);
  } else {
    g.push(i);
  }var l = j.getVblen(e, f);var c = i;var d = 0;while (1) {
    var b = j.getNextSiblingIdx(e, c);if (b == null || b - i >= l * 2) {
      break;
    }if (d >= 200) {
      break;
    }g.push(b);c = b;d++;
  }return g;
};ASN1HEX.getNthChildIdx = function (d, b, e) {
  var c = ASN1HEX.getChildIdx(d, b);return c[e];
};ASN1HEX.getIdxbyList = function (e, d, c, i) {
  var g = ASN1HEX;var f, b;if (c.length == 0) {
    if (i !== undefined) {
      if (e.substr(d, 2) !== i) {
        throw "checking tag doesn't match: " + e.substr(d, 2) + "!=" + i;
      }
    }return d;
  }f = c.shift();b = g.getChildIdx(e, d);return g.getIdxbyList(e, b[f], c, i);
};ASN1HEX.getTLVbyList = function (d, c, b, f) {
  var e = ASN1HEX;var a = e.getIdxbyList(d, c, b);if (a === undefined) {
    throw "can't find nthList object";
  }if (f !== undefined) {
    if (d.substr(a, 2) != f) {
      throw "checking tag doesn't match: " + d.substr(a, 2) + "!=" + f;
    }
  }return e.getTLV(d, a);
};ASN1HEX.getVbyList = function (e, c, b, g, i) {
  var f = ASN1HEX;var a, d;a = f.getIdxbyList(e, c, b, g);if (a === undefined) {
    throw "can't find nthList object";
  }d = f.getV(e, a);if (i === true) {
    d = d.substr(2);
  }return d;
};ASN1HEX.hextooidstr = function (e) {
  var h = function h(b, a) {
    if (b.length >= a) {
      return b;
    }return new Array(a - b.length + 1).join("0") + b;
  };var l = [];var o = e.substr(0, 2);var f = parseInt(o, 16);l[0] = new String(Math.floor(f / 40));l[1] = new String(f % 40);var m = e.substr(2);var k = [];for (var g = 0; g < m.length / 2; g++) {
    k.push(parseInt(m.substr(g * 2, 2), 16));
  }var j = [];var d = "";for (var g = 0; g < k.length; g++) {
    if (k[g] & 128) {
      d = d + h((k[g] & 127).toString(2), 7);
    } else {
      d = d + h((k[g] & 127).toString(2), 7);j.push(new String(parseInt(d, 2)));d = "";
    }
  }var n = l.join(".");if (j.length > 0) {
    n = n + "." + j.join(".");
  }return n;
};ASN1HEX.dump = function (t, c, l, g) {
  var p = ASN1HEX;var j = p.getV;var y = p.dump;var w = p.getChildIdx;var e = t;if (t instanceof KJUR.asn1.ASN1Object) {
    e = t.getEncodedHex();
  }var q = function q(A, i) {
    if (A.length <= i * 2) {
      return A;
    } else {
      var v = A.substr(0, i) + "..(total " + A.length / 2 + "bytes).." + A.substr(A.length - i, i);return v;
    }
  };if (c === undefined) {
    c = { ommit_long_octet: 32 };
  }if (l === undefined) {
    l = 0;
  }if (g === undefined) {
    g = "";
  }var x = c.ommit_long_octet;if (e.substr(l, 2) == "01") {
    var h = j(e, l);if (h == "00") {
      return g + "BOOLEAN FALSE\n";
    } else {
      return g + "BOOLEAN TRUE\n";
    }
  }if (e.substr(l, 2) == "02") {
    var h = j(e, l);return g + "INTEGER " + q(h, x) + "\n";
  }if (e.substr(l, 2) == "03") {
    var h = j(e, l);return g + "BITSTRING " + q(h, x) + "\n";
  }if (e.substr(l, 2) == "04") {
    var h = j(e, l);if (p.isASN1HEX(h)) {
      var k = g + "OCTETSTRING, encapsulates\n";k = k + y(h, c, 0, g + "  ");return k;
    } else {
      return g + "OCTETSTRING " + q(h, x) + "\n";
    }
  }if (e.substr(l, 2) == "05") {
    return g + "NULL\n";
  }if (e.substr(l, 2) == "06") {
    var m = j(e, l);var a = KJUR.asn1.ASN1Util.oidHexToInt(m);var o = KJUR.asn1.x509.OID.oid2name(a);var b = a.replace(/\./g, " ");if (o != "") {
      return g + "ObjectIdentifier " + o + " (" + b + ")\n";
    } else {
      return g + "ObjectIdentifier (" + b + ")\n";
    }
  }if (e.substr(l, 2) == "0c") {
    return g + "UTF8String '" + hextoutf8(j(e, l)) + "'\n";
  }if (e.substr(l, 2) == "13") {
    return g + "PrintableString '" + hextoutf8(j(e, l)) + "'\n";
  }if (e.substr(l, 2) == "14") {
    return g + "TeletexString '" + hextoutf8(j(e, l)) + "'\n";
  }if (e.substr(l, 2) == "16") {
    return g + "IA5String '" + hextoutf8(j(e, l)) + "'\n";
  }if (e.substr(l, 2) == "17") {
    return g + "UTCTime " + hextoutf8(j(e, l)) + "\n";
  }if (e.substr(l, 2) == "18") {
    return g + "GeneralizedTime " + hextoutf8(j(e, l)) + "\n";
  }if (e.substr(l, 2) == "30") {
    if (e.substr(l, 4) == "3000") {
      return g + "SEQUENCE {}\n";
    }var k = g + "SEQUENCE\n";var d = w(e, l);var f = c;if ((d.length == 2 || d.length == 3) && e.substr(d[0], 2) == "06" && e.substr(d[d.length - 1], 2) == "04") {
      var o = p.oidname(j(e, d[0]));var r = JSON.parse(JSON.stringify(c));r.x509ExtName = o;f = r;
    }for (var u = 0; u < d.length; u++) {
      k = k + y(e, f, d[u], g + "  ");
    }return k;
  }if (e.substr(l, 2) == "31") {
    var k = g + "SET\n";var d = w(e, l);for (var u = 0; u < d.length; u++) {
      k = k + y(e, c, d[u], g + "  ");
    }return k;
  }var z = parseInt(e.substr(l, 2), 16);if ((z & 128) != 0) {
    var n = z & 31;if ((z & 32) != 0) {
      var k = g + "[" + n + "]\n";var d = w(e, l);for (var u = 0; u < d.length; u++) {
        k = k + y(e, c, d[u], g + "  ");
      }return k;
    } else {
      var h = j(e, l);if (h.substr(0, 8) == "68747470") {
        h = hextoutf8(h);
      }if (c.x509ExtName === "subjectAltName" && n == 2) {
        h = hextoutf8(h);
      }var k = g + "[" + n + "] " + h + "\n";return k;
    }
  }return g + "UNKNOWN(" + e.substr(l, 2) + ") " + j(e, l) + "\n";
};ASN1HEX.isASN1HEX = function (e) {
  var d = ASN1HEX;if (e.length % 2 == 1) {
    return false;
  }var c = d.getVblen(e, 0);var b = e.substr(0, 2);var f = d.getL(e, 0);var a = e.length - b.length - f.length;if (a == c * 2) {
    return true;
  }return false;
};ASN1HEX.oidname = function (a) {
  var c = KJUR.asn1;if (KJUR.lang.String.isHex(a)) {
    a = c.ASN1Util.oidHexToInt(a);
  }var b = c.x509.OID.oid2name(a);if (b === "") {
    b = a;
  }return b;
};
var KJUR;if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.lang == "undefined" || !KJUR.lang) {
  KJUR.lang = {};
}KJUR.lang.String = function () {};function Base64x() {}function stoBA(d) {
  var b = new Array();for (var c = 0; c < d.length; c++) {
    b[c] = d.charCodeAt(c);
  }return b;
}function BAtos(b) {
  var d = "";for (var c = 0; c < b.length; c++) {
    d = d + String.fromCharCode(b[c]);
  }return d;
}function BAtohex(b) {
  var e = "";for (var d = 0; d < b.length; d++) {
    var c = b[d].toString(16);if (c.length == 1) {
      c = "0" + c;
    }e = e + c;
  }return e;
}function stohex(a) {
  return BAtohex(stoBA(a));
}function stob64(a) {
  return hex2b64(stohex(a));
}function stob64u(a) {
  return b64tob64u(hex2b64(stohex(a)));
}function b64utos(a) {
  return BAtos(b64toBA(b64utob64(a)));
}function b64tob64u(a) {
  a = a.replace(/\=/g, "");a = a.replace(/\+/g, "-");a = a.replace(/\//g, "_");return a;
}function b64utob64(a) {
  if (a.length % 4 == 2) {
    a = a + "==";
  } else {
    if (a.length % 4 == 3) {
      a = a + "=";
    }
  }a = a.replace(/-/g, "+");a = a.replace(/_/g, "/");return a;
}function hextob64u(a) {
  if (a.length % 2 == 1) {
    a = "0" + a;
  }return b64tob64u(hex2b64(a));
}function b64utohex(a) {
  return b64tohex(b64utob64(a));
}var utf8tob64u, b64utoutf8;if (typeof Buffer === "function") {
  exports.utf8tob64u = utf8tob64u = function utf8tob64u(a) {
    return b64tob64u(new Buffer(a, "utf8").toString("base64"));
  };exports.b64utoutf8 = b64utoutf8 = function b64utoutf8(a) {
    return new Buffer(b64utob64(a), "base64").toString("utf8");
  };
} else {
  exports.utf8tob64u = utf8tob64u = function utf8tob64u(a) {
    return hextob64u(uricmptohex(encodeURIComponentAll(a)));
  };exports.b64utoutf8 = b64utoutf8 = function b64utoutf8(a) {
    return decodeURIComponent(hextouricmp(b64utohex(a)));
  };
}function utf8tob64(a) {
  return hex2b64(uricmptohex(encodeURIComponentAll(a)));
}function b64toutf8(a) {
  return decodeURIComponent(hextouricmp(b64tohex(a)));
}function utf8tohex(a) {
  return uricmptohex(encodeURIComponentAll(a));
}function hextoutf8(a) {
  return decodeURIComponent(hextouricmp(a));
}function hextorstr(c) {
  var b = "";for (var a = 0; a < c.length - 1; a += 2) {
    b += String.fromCharCode(parseInt(c.substr(a, 2), 16));
  }return b;
}function rstrtohex(c) {
  var a = "";for (var b = 0; b < c.length; b++) {
    a += ("0" + c.charCodeAt(b).toString(16)).slice(-2);
  }return a;
}function hextob64(a) {
  return hex2b64(a);
}function hextob64nl(b) {
  var a = hextob64(b);var c = a.replace(/(.{64})/g, "$1\r\n");c = c.replace(/\r\n$/, "");return c;
}function b64nltohex(b) {
  var a = b.replace(/[^0-9A-Za-z\/+=]*/g, "");var c = b64tohex(a);return c;
}function hextopem(a, b) {
  var c = hextob64nl(a);return "-----BEGIN " + b + "-----\r\n" + c + "\r\n-----END " + b + "-----\r\n";
}function pemtohex(a, b) {
  if (a.indexOf("-----BEGIN ") == -1) {
    throw "can't find PEM header: " + b;
  }if (b !== undefined) {
    a = a.replace("-----BEGIN " + b + "-----", "");a = a.replace("-----END " + b + "-----", "");
  } else {
    a = a.replace(/-----BEGIN [^-]+-----/, "");a = a.replace(/-----END [^-]+-----/, "");
  }return b64nltohex(a);
}function hextoArrayBuffer(d) {
  if (d.length % 2 != 0) {
    throw "input is not even length";
  }if (d.match(/^[0-9A-Fa-f]+$/) == null) {
    throw "input is not hexadecimal";
  }var b = new ArrayBuffer(d.length / 2);var a = new DataView(b);for (var c = 0; c < d.length / 2; c++) {
    a.setUint8(c, parseInt(d.substr(c * 2, 2), 16));
  }return b;
}function ArrayBuffertohex(b) {
  var d = "";var a = new DataView(b);for (var c = 0; c < b.byteLength; c++) {
    d += ("00" + a.getUint8(c).toString(16)).slice(-2);
  }return d;
}function zulutomsec(n) {
  var l, j, m, e, f, i, b, k;var a, h, g, c;c = n.match(/^(\d{2}|\d{4})(\d\d)(\d\d)(\d\d)(\d\d)(\d\d)(|\.\d+)Z$/);if (c) {
    a = c[1];l = parseInt(a);if (a.length === 2) {
      if (50 <= l && l < 100) {
        l = 1900 + l;
      } else {
        if (0 <= l && l < 50) {
          l = 2000 + l;
        }
      }
    }j = parseInt(c[2]) - 1;m = parseInt(c[3]);e = parseInt(c[4]);f = parseInt(c[5]);i = parseInt(c[6]);b = 0;h = c[7];if (h !== "") {
      g = (h.substr(1) + "00").substr(0, 3);b = parseInt(g);
    }return Date.UTC(l, j, m, e, f, i, b);
  }throw "unsupported zulu format: " + n;
}function zulutosec(a) {
  var b = zulutomsec(a);return ~~(b / 1000);
}function zulutodate(a) {
  return new Date(zulutomsec(a));
}function datetozulu(g, e, f) {
  var b;var a = g.getUTCFullYear();if (e) {
    if (a < 1950 || 2049 < a) {
      throw "not proper year for UTCTime: " + a;
    }b = ("" + a).slice(-2);
  } else {
    b = ("000" + a).slice(-4);
  }b += ("0" + (g.getUTCMonth() + 1)).slice(-2);b += ("0" + g.getUTCDate()).slice(-2);b += ("0" + g.getUTCHours()).slice(-2);b += ("0" + g.getUTCMinutes()).slice(-2);b += ("0" + g.getUTCSeconds()).slice(-2);if (f) {
    var c = g.getUTCMilliseconds();if (c !== 0) {
      c = ("00" + c).slice(-3);c = c.replace(/0+$/g, "");b += "." + c;
    }
  }b += "Z";return b;
}function uricmptohex(a) {
  return a.replace(/%/g, "");
}function hextouricmp(a) {
  return a.replace(/(..)/g, "%$1");
}function ipv6tohex(g) {
  var b = "malformed IPv6 address";if (!g.match(/^[0-9A-Fa-f:]+$/)) {
    throw b;
  }g = g.toLowerCase();var d = g.split(":").length - 1;if (d < 2) {
    throw b;
  }var e = ":".repeat(7 - d + 2);g = g.replace("::", e);var c = g.split(":");if (c.length != 8) {
    throw b;
  }for (var f = 0; f < 8; f++) {
    c[f] = ("0000" + c[f]).slice(-4);
  }return c.join("");
}function hextoipv6(e) {
  if (!e.match(/^[0-9A-Fa-f]{32}$/)) {
    throw "malformed IPv6 address octet";
  }e = e.toLowerCase();var b = e.match(/.{1,4}/g);for (var d = 0; d < 8; d++) {
    b[d] = b[d].replace(/^0+/, "");if (b[d] == "") {
      b[d] = "0";
    }
  }e = ":" + b.join(":") + ":";var c = e.match(/:(0:){2,}/g);if (c === null) {
    return e.slice(1, -1);
  }var f = "";for (var d = 0; d < c.length; d++) {
    if (c[d].length > f.length) {
      f = c[d];
    }
  }e = e.replace(f, "::");return e.slice(1, -1);
}function hextoip(b) {
  var d = "malformed hex value";if (!b.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)) {
    throw d;
  }if (b.length == 8) {
    var c;try {
      c = parseInt(b.substr(0, 2), 16) + "." + parseInt(b.substr(2, 2), 16) + "." + parseInt(b.substr(4, 2), 16) + "." + parseInt(b.substr(6, 2), 16);return c;
    } catch (a) {
      throw d;
    }
  } else {
    if (b.length == 32) {
      return hextoipv6(b);
    } else {
      return b;
    }
  }
}function iptohex(f) {
  var j = "malformed IP address";f = f.toLowerCase(f);if (f.match(/^[0-9.]+$/)) {
    var b = f.split(".");if (b.length !== 4) {
      throw j;
    }var g = "";try {
      for (var e = 0; e < 4; e++) {
        var h = parseInt(b[e]);g += ("0" + h.toString(16)).slice(-2);
      }return g;
    } catch (c) {
      throw j;
    }
  } else {
    if (f.match(/^[0-9a-f:]+$/) && f.indexOf(":") !== -1) {
      return ipv6tohex(f);
    } else {
      throw j;
    }
  }
}function encodeURIComponentAll(a) {
  var d = encodeURIComponent(a);var b = "";for (var c = 0; c < d.length; c++) {
    if (d[c] == "%") {
      b = b + d.substr(c, 3);c = c + 2;
    } else {
      b = b + "%" + stohex(d[c]);
    }
  }return b;
}function newline_toUnix(a) {
  a = a.replace(/\r\n/mg, "\n");return a;
}function newline_toDos(a) {
  a = a.replace(/\r\n/mg, "\n");a = a.replace(/\n/mg, "\r\n");return a;
}KJUR.lang.String.isInteger = function (a) {
  if (a.match(/^[0-9]+$/)) {
    return true;
  } else {
    if (a.match(/^-[0-9]+$/)) {
      return true;
    } else {
      return false;
    }
  }
};KJUR.lang.String.isHex = function (a) {
  if (a.length % 2 == 0 && (a.match(/^[0-9a-f]+$/) || a.match(/^[0-9A-F]+$/))) {
    return true;
  } else {
    return false;
  }
};KJUR.lang.String.isBase64 = function (a) {
  a = a.replace(/\s+/g, "");if (a.match(/^[0-9A-Za-z+\/]+={0,3}$/) && a.length % 4 == 0) {
    return true;
  } else {
    return false;
  }
};KJUR.lang.String.isBase64URL = function (a) {
  if (a.match(/[+/=]/)) {
    return false;
  }a = b64utob64(a);return KJUR.lang.String.isBase64(a);
};KJUR.lang.String.isIntegerArray = function (a) {
  a = a.replace(/\s+/g, "");if (a.match(/^\[[0-9,]+\]$/)) {
    return true;
  } else {
    return false;
  }
};function hextoposhex(a) {
  if (a.length % 2 == 1) {
    return "0" + a;
  }if (a.substr(0, 1) > "7") {
    return "00" + a;
  }return a;
}function intarystrtohex(b) {
  b = b.replace(/^\s*\[\s*/, "");b = b.replace(/\s*\]\s*$/, "");b = b.replace(/\s*/g, "");try {
    var c = b.split(/,/).map(function (g, e, h) {
      var f = parseInt(g);if (f < 0 || 255 < f) {
        throw "integer not in range 0-255";
      }var d = ("00" + f.toString(16)).slice(-2);return d;
    }).join("");return c;
  } catch (a) {
    throw "malformed integer array string: " + a;
  }
}var strdiffidx = function strdiffidx(c, a) {
  var d = c.length;if (c.length > a.length) {
    d = a.length;
  }for (var b = 0; b < d; b++) {
    if (c.charCodeAt(b) != a.charCodeAt(b)) {
      return b;
    }
  }if (c.length != a.length) {
    return d;
  }return -1;
};
if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
  KJUR.crypto = {};
}KJUR.crypto.Util = new function () {
  this.DIGESTINFOHEAD = { sha1: "3021300906052b0e03021a05000414", sha224: "302d300d06096086480165030402040500041c", sha256: "3031300d060960864801650304020105000420", sha384: "3041300d060960864801650304020205000430", sha512: "3051300d060960864801650304020305000440", md2: "3020300c06082a864886f70d020205000410", md5: "3020300c06082a864886f70d020505000410", ripemd160: "3021300906052b2403020105000414" };this.DEFAULTPROVIDER = { md5: "cryptojs", sha1: "cryptojs", sha224: "cryptojs", sha256: "cryptojs", sha384: "cryptojs", sha512: "cryptojs", ripemd160: "cryptojs", hmacmd5: "cryptojs", hmacsha1: "cryptojs", hmacsha224: "cryptojs", hmacsha256: "cryptojs", hmacsha384: "cryptojs", hmacsha512: "cryptojs", hmacripemd160: "cryptojs", MD5withRSA: "cryptojs/jsrsa", SHA1withRSA: "cryptojs/jsrsa", SHA224withRSA: "cryptojs/jsrsa", SHA256withRSA: "cryptojs/jsrsa", SHA384withRSA: "cryptojs/jsrsa", SHA512withRSA: "cryptojs/jsrsa", RIPEMD160withRSA: "cryptojs/jsrsa", MD5withECDSA: "cryptojs/jsrsa", SHA1withECDSA: "cryptojs/jsrsa", SHA224withECDSA: "cryptojs/jsrsa", SHA256withECDSA: "cryptojs/jsrsa", SHA384withECDSA: "cryptojs/jsrsa", SHA512withECDSA: "cryptojs/jsrsa", RIPEMD160withECDSA: "cryptojs/jsrsa", SHA1withDSA: "cryptojs/jsrsa", SHA224withDSA: "cryptojs/jsrsa", SHA256withDSA: "cryptojs/jsrsa", MD5withRSAandMGF1: "cryptojs/jsrsa", SHA1withRSAandMGF1: "cryptojs/jsrsa", SHA224withRSAandMGF1: "cryptojs/jsrsa", SHA256withRSAandMGF1: "cryptojs/jsrsa", SHA384withRSAandMGF1: "cryptojs/jsrsa", SHA512withRSAandMGF1: "cryptojs/jsrsa", RIPEMD160withRSAandMGF1: "cryptojs/jsrsa" };this.CRYPTOJSMESSAGEDIGESTNAME = { md5: CryptoJS.algo.MD5, sha1: CryptoJS.algo.SHA1, sha224: CryptoJS.algo.SHA224, sha256: CryptoJS.algo.SHA256, sha384: CryptoJS.algo.SHA384, sha512: CryptoJS.algo.SHA512, ripemd160: CryptoJS.algo.RIPEMD160 };this.getDigestInfoHex = function (a, b) {
    if (typeof this.DIGESTINFOHEAD[b] == "undefined") {
      throw "alg not supported in Util.DIGESTINFOHEAD: " + b;
    }return this.DIGESTINFOHEAD[b] + a;
  };this.getPaddedDigestInfoHex = function (h, a, j) {
    var c = this.getDigestInfoHex(h, a);var d = j / 4;if (c.length + 22 > d) {
      throw "key is too short for SigAlg: keylen=" + j + "," + a;
    }var b = "0001";var k = "00" + c;var g = "";var l = d - b.length - k.length;for (var f = 0; f < l; f += 2) {
      g += "ff";
    }var e = b + g + k;return e;
  };this.hashString = function (a, c) {
    var b = new KJUR.crypto.MessageDigest({ alg: c });return b.digestString(a);
  };this.hashHex = function (b, c) {
    var a = new KJUR.crypto.MessageDigest({ alg: c });return a.digestHex(b);
  };this.sha1 = function (a) {
    var b = new KJUR.crypto.MessageDigest({ alg: "sha1", prov: "cryptojs" });return b.digestString(a);
  };this.sha256 = function (a) {
    var b = new KJUR.crypto.MessageDigest({ alg: "sha256", prov: "cryptojs" });return b.digestString(a);
  };this.sha256Hex = function (a) {
    var b = new KJUR.crypto.MessageDigest({ alg: "sha256", prov: "cryptojs" });return b.digestHex(a);
  };this.sha512 = function (a) {
    var b = new KJUR.crypto.MessageDigest({ alg: "sha512", prov: "cryptojs" });return b.digestString(a);
  };this.sha512Hex = function (a) {
    var b = new KJUR.crypto.MessageDigest({ alg: "sha512", prov: "cryptojs" });return b.digestHex(a);
  };
}();KJUR.crypto.Util.md5 = function (a) {
  var b = new KJUR.crypto.MessageDigest({ alg: "md5", prov: "cryptojs" });return b.digestString(a);
};KJUR.crypto.Util.ripemd160 = function (a) {
  var b = new KJUR.crypto.MessageDigest({ alg: "ripemd160", prov: "cryptojs" });return b.digestString(a);
};KJUR.crypto.Util.SECURERANDOMGEN = new SecureRandom();KJUR.crypto.Util.getRandomHexOfNbytes = function (b) {
  var a = new Array(b);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(a);return BAtohex(a);
};KJUR.crypto.Util.getRandomBigIntegerOfNbytes = function (a) {
  return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbytes(a), 16);
};KJUR.crypto.Util.getRandomHexOfNbits = function (d) {
  var c = d % 8;var a = (d - c) / 8;var b = new Array(a + 1);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(b);b[0] = (255 << c & 255 ^ 255) & b[0];return BAtohex(b);
};KJUR.crypto.Util.getRandomBigIntegerOfNbits = function (a) {
  return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbits(a), 16);
};KJUR.crypto.Util.getRandomBigIntegerZeroToMax = function (b) {
  var a = b.bitLength();while (1) {
    var c = KJUR.crypto.Util.getRandomBigIntegerOfNbits(a);if (b.compareTo(c) != -1) {
      return c;
    }
  }
};KJUR.crypto.Util.getRandomBigIntegerMinToMax = function (e, b) {
  var c = e.compareTo(b);if (c == 1) {
    throw "biMin is greater than biMax";
  }if (c == 0) {
    return e;
  }var a = b.subtract(e);var d = KJUR.crypto.Util.getRandomBigIntegerZeroToMax(a);return d.add(e);
};KJUR.crypto.MessageDigest = function (c) {
  var b = null;var a = null;var d = null;this.setAlgAndProvider = function (g, f) {
    g = KJUR.crypto.MessageDigest.getCanonicalAlgName(g);if (g !== null && f === undefined) {
      f = KJUR.crypto.Util.DEFAULTPROVIDER[g];
    }if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(g) != -1 && f == "cryptojs") {
      try {
        this.md = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g].create();
      } catch (e) {
        throw "setAlgAndProvider hash alg set fail alg=" + g + "/" + e;
      }this.updateString = function (h) {
        this.md.update(h);
      };this.updateHex = function (h) {
        var i = CryptoJS.enc.Hex.parse(h);this.md.update(i);
      };this.digest = function () {
        var h = this.md.finalize();return h.toString(CryptoJS.enc.Hex);
      };this.digestString = function (h) {
        this.updateString(h);return this.digest();
      };this.digestHex = function (h) {
        this.updateHex(h);return this.digest();
      };
    }if (":sha256:".indexOf(g) != -1 && f == "sjcl") {
      try {
        this.md = new sjcl.hash.sha256();
      } catch (e) {
        throw "setAlgAndProvider hash alg set fail alg=" + g + "/" + e;
      }this.updateString = function (h) {
        this.md.update(h);
      };this.updateHex = function (i) {
        var h = sjcl.codec.hex.toBits(i);this.md.update(h);
      };this.digest = function () {
        var h = this.md.finalize();return sjcl.codec.hex.fromBits(h);
      };this.digestString = function (h) {
        this.updateString(h);return this.digest();
      };this.digestHex = function (h) {
        this.updateHex(h);return this.digest();
      };
    }
  };this.updateString = function (e) {
    throw "updateString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
  };this.updateHex = function (e) {
    throw "updateHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
  };this.digest = function () {
    throw "digest() not supported for this alg/prov: " + this.algName + "/" + this.provName;
  };this.digestString = function (e) {
    throw "digestString(str) not supported for this alg/prov: " + this.algName + "/" + this.provName;
  };this.digestHex = function (e) {
    throw "digestHex(hex) not supported for this alg/prov: " + this.algName + "/" + this.provName;
  };if (c !== undefined) {
    if (c.alg !== undefined) {
      this.algName = c.alg;if (c.prov === undefined) {
        this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
      }this.setAlgAndProvider(this.algName, this.provName);
    }
  }
};KJUR.crypto.MessageDigest.getCanonicalAlgName = function (a) {
  if (typeof a === "string") {
    a = a.toLowerCase();a = a.replace(/-/, "");
  }return a;
};KJUR.crypto.MessageDigest.getHashLength = function (c) {
  var b = KJUR.crypto.MessageDigest;var a = b.getCanonicalAlgName(c);if (b.HASHLENGTH[a] === undefined) {
    throw "not supported algorithm: " + c;
  }return b.HASHLENGTH[a];
};KJUR.crypto.MessageDigest.HASHLENGTH = { md5: 16, sha1: 20, sha224: 28, sha256: 32, sha384: 48, sha512: 64, ripemd160: 20 };KJUR.crypto.Mac = function (d) {
  var f = null;var c = null;var a = null;var e = null;var b = null;this.setAlgAndProvider = function (k, i) {
    k = k.toLowerCase();if (k == null) {
      k = "hmacsha1";
    }k = k.toLowerCase();if (k.substr(0, 4) != "hmac") {
      throw "setAlgAndProvider unsupported HMAC alg: " + k;
    }if (i === undefined) {
      i = KJUR.crypto.Util.DEFAULTPROVIDER[k];
    }this.algProv = k + "/" + i;var g = k.substr(4);if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(g) != -1 && i == "cryptojs") {
      try {
        var j = KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g];this.mac = CryptoJS.algo.HMAC.create(j, this.pass);
      } catch (h) {
        throw "setAlgAndProvider hash alg set fail hashAlg=" + g + "/" + h;
      }this.updateString = function (l) {
        this.mac.update(l);
      };this.updateHex = function (l) {
        var m = CryptoJS.enc.Hex.parse(l);this.mac.update(m);
      };this.doFinal = function () {
        var l = this.mac.finalize();return l.toString(CryptoJS.enc.Hex);
      };this.doFinalString = function (l) {
        this.updateString(l);return this.doFinal();
      };this.doFinalHex = function (l) {
        this.updateHex(l);return this.doFinal();
      };
    }
  };this.updateString = function (g) {
    throw "updateString(str) not supported for this alg/prov: " + this.algProv;
  };this.updateHex = function (g) {
    throw "updateHex(hex) not supported for this alg/prov: " + this.algProv;
  };this.doFinal = function () {
    throw "digest() not supported for this alg/prov: " + this.algProv;
  };this.doFinalString = function (g) {
    throw "digestString(str) not supported for this alg/prov: " + this.algProv;
  };this.doFinalHex = function (g) {
    throw "digestHex(hex) not supported for this alg/prov: " + this.algProv;
  };this.setPassword = function (h) {
    if (typeof h == "string") {
      var g = h;if (h.length % 2 == 1 || !h.match(/^[0-9A-Fa-f]+$/)) {
        g = rstrtohex(h);
      }this.pass = CryptoJS.enc.Hex.parse(g);return;
    }if ((typeof h === "undefined" ? "undefined" : _typeof(h)) != "object") {
      throw "KJUR.crypto.Mac unsupported password type: " + h;
    }var g = null;if (h.hex !== undefined) {
      if (h.hex.length % 2 != 0 || !h.hex.match(/^[0-9A-Fa-f]+$/)) {
        throw "Mac: wrong hex password: " + h.hex;
      }g = h.hex;
    }if (h.utf8 !== undefined) {
      g = utf8tohex(h.utf8);
    }if (h.rstr !== undefined) {
      g = rstrtohex(h.rstr);
    }if (h.b64 !== undefined) {
      g = b64tohex(h.b64);
    }if (h.b64u !== undefined) {
      g = b64utohex(h.b64u);
    }if (g == null) {
      throw "KJUR.crypto.Mac unsupported password type: " + h;
    }this.pass = CryptoJS.enc.Hex.parse(g);
  };if (d !== undefined) {
    if (d.pass !== undefined) {
      this.setPassword(d.pass);
    }if (d.alg !== undefined) {
      this.algName = d.alg;if (d.prov === undefined) {
        this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
      }this.setAlgAndProvider(this.algName, this.provName);
    }
  }
};KJUR.crypto.Signature = function (o) {
  var q = null;var n = null;var r = null;var c = null;var l = null;var d = null;var k = null;var h = null;var p = null;var e = null;var b = -1;var g = null;var j = null;var a = null;var i = null;var f = null;this._setAlgNames = function () {
    var s = this.algName.match(/^(.+)with(.+)$/);if (s) {
      this.mdAlgName = s[1].toLowerCase();this.pubkeyAlgName = s[2].toLowerCase();
    }
  };this._zeroPaddingOfSignature = function (x, w) {
    var v = "";var t = w / 4 - x.length;for (var u = 0; u < t; u++) {
      v = v + "0";
    }return v + x;
  };this.setAlgAndProvider = function (u, t) {
    this._setAlgNames();if (t != "cryptojs/jsrsa") {
      throw "provider not supported: " + t;
    }if (":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:".indexOf(this.mdAlgName) != -1) {
      try {
        this.md = new KJUR.crypto.MessageDigest({ alg: this.mdAlgName });
      } catch (s) {
        throw "setAlgAndProvider hash alg set fail alg=" + this.mdAlgName + "/" + s;
      }this.init = function (w, x) {
        var y = null;try {
          if (x === undefined) {
            y = KEYUTIL.getKey(w);
          } else {
            y = KEYUTIL.getKey(w, x);
          }
        } catch (v) {
          throw "init failed:" + v;
        }if (y.isPrivate === true) {
          this.prvKey = y;this.state = "SIGN";
        } else {
          if (y.isPublic === true) {
            this.pubKey = y;this.state = "VERIFY";
          } else {
            throw "init failed.:" + y;
          }
        }
      };this.updateString = function (v) {
        this.md.updateString(v);
      };this.updateHex = function (v) {
        this.md.updateHex(v);
      };this.sign = function () {
        this.sHashHex = this.md.digest();if (typeof this.ecprvhex != "undefined" && typeof this.eccurvename != "undefined") {
          var v = new KJUR.crypto.ECDSA({ curve: this.eccurvename });this.hSign = v.signHex(this.sHashHex, this.ecprvhex);
        } else {
          if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") {
            this.hSign = this.prvKey.signWithMessageHashPSS(this.sHashHex, this.mdAlgName, this.pssSaltLen);
          } else {
            if (this.prvKey instanceof RSAKey && this.pubkeyAlgName === "rsa") {
              this.hSign = this.prvKey.signWithMessageHash(this.sHashHex, this.mdAlgName);
            } else {
              if (this.prvKey instanceof KJUR.crypto.ECDSA) {
                this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
              } else {
                if (this.prvKey instanceof KJUR.crypto.DSA) {
                  this.hSign = this.prvKey.signWithMessageHash(this.sHashHex);
                } else {
                  throw "Signature: unsupported private key alg: " + this.pubkeyAlgName;
                }
              }
            }
          }
        }return this.hSign;
      };this.signString = function (v) {
        this.updateString(v);return this.sign();
      };this.signHex = function (v) {
        this.updateHex(v);return this.sign();
      };this.verify = function (v) {
        this.sHashHex = this.md.digest();if (typeof this.ecpubhex != "undefined" && typeof this.eccurvename != "undefined") {
          var w = new KJUR.crypto.ECDSA({ curve: this.eccurvename });return w.verifyHex(this.sHashHex, v, this.ecpubhex);
        } else {
          if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsaandmgf1") {
            return this.pubKey.verifyWithMessageHashPSS(this.sHashHex, v, this.mdAlgName, this.pssSaltLen);
          } else {
            if (this.pubKey instanceof RSAKey && this.pubkeyAlgName === "rsa") {
              return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
            } else {
              if (KJUR.crypto.ECDSA !== undefined && this.pubKey instanceof KJUR.crypto.ECDSA) {
                return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
              } else {
                if (KJUR.crypto.DSA !== undefined && this.pubKey instanceof KJUR.crypto.DSA) {
                  return this.pubKey.verifyWithMessageHash(this.sHashHex, v);
                } else {
                  throw "Signature: unsupported public key alg: " + this.pubkeyAlgName;
                }
              }
            }
          }
        }
      };
    }
  };this.init = function (s, t) {
    throw "init(key, pass) not supported for this alg:prov=" + this.algProvName;
  };this.updateString = function (s) {
    throw "updateString(str) not supported for this alg:prov=" + this.algProvName;
  };this.updateHex = function (s) {
    throw "updateHex(hex) not supported for this alg:prov=" + this.algProvName;
  };this.sign = function () {
    throw "sign() not supported for this alg:prov=" + this.algProvName;
  };this.signString = function (s) {
    throw "digestString(str) not supported for this alg:prov=" + this.algProvName;
  };this.signHex = function (s) {
    throw "digestHex(hex) not supported for this alg:prov=" + this.algProvName;
  };this.verify = function (s) {
    throw "verify(hSigVal) not supported for this alg:prov=" + this.algProvName;
  };this.initParams = o;if (o !== undefined) {
    if (o.alg !== undefined) {
      this.algName = o.alg;if (o.prov === undefined) {
        this.provName = KJUR.crypto.Util.DEFAULTPROVIDER[this.algName];
      } else {
        this.provName = o.prov;
      }this.algProvName = this.algName + ":" + this.provName;this.setAlgAndProvider(this.algName, this.provName);this._setAlgNames();
    }if (o.psssaltlen !== undefined) {
      this.pssSaltLen = o.psssaltlen;
    }if (o.prvkeypem !== undefined) {
      if (o.prvkeypas !== undefined) {
        throw "both prvkeypem and prvkeypas parameters not supported";
      } else {
        try {
          var q = KEYUTIL.getKey(o.prvkeypem);this.init(q);
        } catch (m) {
          throw "fatal error to load pem private key: " + m;
        }
      }
    }
  }
};KJUR.crypto.Cipher = function (a) {};KJUR.crypto.Cipher.encrypt = function (e, f, d) {
  if (f instanceof RSAKey && f.isPublic) {
    var c = KJUR.crypto.Cipher.getAlgByKeyAndName(f, d);if (c === "RSA") {
      return f.encrypt(e);
    }if (c === "RSAOAEP") {
      return f.encryptOAEP(e, "sha1");
    }var b = c.match(/^RSAOAEP(\d+)$/);if (b !== null) {
      return f.encryptOAEP(e, "sha" + b[1]);
    }throw "Cipher.encrypt: unsupported algorithm for RSAKey: " + d;
  } else {
    throw "Cipher.encrypt: unsupported key or algorithm";
  }
};KJUR.crypto.Cipher.decrypt = function (e, f, d) {
  if (f instanceof RSAKey && f.isPrivate) {
    var c = KJUR.crypto.Cipher.getAlgByKeyAndName(f, d);if (c === "RSA") {
      return f.decrypt(e);
    }if (c === "RSAOAEP") {
      return f.decryptOAEP(e, "sha1");
    }var b = c.match(/^RSAOAEP(\d+)$/);if (b !== null) {
      return f.decryptOAEP(e, "sha" + b[1]);
    }throw "Cipher.decrypt: unsupported algorithm for RSAKey: " + d;
  } else {
    throw "Cipher.decrypt: unsupported key or algorithm";
  }
};KJUR.crypto.Cipher.getAlgByKeyAndName = function (b, a) {
  if (b instanceof RSAKey) {
    if (":RSA:RSAOAEP:RSAOAEP224:RSAOAEP256:RSAOAEP384:RSAOAEP512:".indexOf(a) != -1) {
      return a;
    }if (a === null || a === undefined) {
      return "RSA";
    }throw "getAlgByKeyAndName: not supported algorithm name for RSAKey: " + a;
  }throw "getAlgByKeyAndName: not supported algorithm name: " + a;
};KJUR.crypto.OID = new function () {
  this.oidhex2name = { "2a864886f70d010101": "rsaEncryption", "2a8648ce3d0201": "ecPublicKey", "2a8648ce380401": "dsa", "2a8648ce3d030107": "secp256r1", "2b8104001f": "secp192k1", "2b81040021": "secp224r1", "2b8104000a": "secp256k1", "2b81040023": "secp521r1", "2b81040022": "secp384r1", "2a8648ce380403": "SHA1withDSA", "608648016503040301": "SHA224withDSA", "608648016503040302": "SHA256withDSA" };
}();
if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
  KJUR.crypto = {};
}KJUR.crypto.ECDSA = function (h) {
  var e = "secp256r1";var g = null;var b = null;var f = null;var a = new SecureRandom();var d = null;this.type = "EC";this.isPrivate = false;this.isPublic = false;function c(s, o, r, n) {
    var j = Math.max(o.bitLength(), n.bitLength());var t = s.add2D(r);var q = s.curve.getInfinity();for (var p = j - 1; p >= 0; --p) {
      q = q.twice2D();q.z = BigInteger.ONE;if (o.testBit(p)) {
        if (n.testBit(p)) {
          q = q.add2D(t);
        } else {
          q = q.add2D(s);
        }
      } else {
        if (n.testBit(p)) {
          q = q.add2D(r);
        }
      }
    }return q;
  }this.getBigRandom = function (i) {
    return new BigInteger(i.bitLength(), a).mod(i.subtract(BigInteger.ONE)).add(BigInteger.ONE);
  };this.setNamedCurve = function (i) {
    this.ecparams = KJUR.crypto.ECParameterDB.getByName(i);this.prvKeyHex = null;this.pubKeyHex = null;this.curveName = i;
  };this.setPrivateKeyHex = function (i) {
    this.isPrivate = true;this.prvKeyHex = i;
  };this.setPublicKeyHex = function (i) {
    this.isPublic = true;this.pubKeyHex = i;
  };this.getPublicKeyXYHex = function () {
    var k = this.pubKeyHex;if (k.substr(0, 2) !== "04") {
      throw "this method supports uncompressed format(04) only";
    }var j = this.ecparams.keylen / 4;if (k.length !== 2 + j * 2) {
      throw "malformed public key hex length";
    }var i = {};i.x = k.substr(2, j);i.y = k.substr(2 + j);return i;
  };this.getShortNISTPCurveName = function () {
    var i = this.curveName;if (i === "secp256r1" || i === "NIST P-256" || i === "P-256" || i === "prime256v1") {
      return "P-256";
    }if (i === "secp384r1" || i === "NIST P-384" || i === "P-384") {
      return "P-384";
    }return null;
  };this.generateKeyPairHex = function () {
    var k = this.ecparams.n;var n = this.getBigRandom(k);var l = this.ecparams.G.multiply(n);var q = l.getX().toBigInteger();var o = l.getY().toBigInteger();var i = this.ecparams.keylen / 4;var m = ("0000000000" + n.toString(16)).slice(-i);var r = ("0000000000" + q.toString(16)).slice(-i);var p = ("0000000000" + o.toString(16)).slice(-i);var j = "04" + r + p;this.setPrivateKeyHex(m);this.setPublicKeyHex(j);return { ecprvhex: m, ecpubhex: j };
  };this.signWithMessageHash = function (i) {
    return this.signHex(i, this.prvKeyHex);
  };this.signHex = function (o, j) {
    var t = new BigInteger(j, 16);var l = this.ecparams.n;var q = new BigInteger(o, 16);do {
      var m = this.getBigRandom(l);var u = this.ecparams.G;var p = u.multiply(m);var i = p.getX().toBigInteger().mod(l);
    } while (i.compareTo(BigInteger.ZERO) <= 0);var v = m.modInverse(l).multiply(q.add(t.multiply(i))).mod(l);return KJUR.crypto.ECDSA.biRSSigToASN1Sig(i, v);
  };this.sign = function (m, u) {
    var q = u;var j = this.ecparams.n;var p = BigInteger.fromByteArrayUnsigned(m);do {
      var l = this.getBigRandom(j);var t = this.ecparams.G;var o = t.multiply(l);var i = o.getX().toBigInteger().mod(j);
    } while (i.compareTo(BigInteger.ZERO) <= 0);var v = l.modInverse(j).multiply(p.add(q.multiply(i))).mod(j);return this.serializeSig(i, v);
  };this.verifyWithMessageHash = function (j, i) {
    return this.verifyHex(j, i, this.pubKeyHex);
  };this.verifyHex = function (m, i, p) {
    var l, j;var o = KJUR.crypto.ECDSA.parseSigHex(i);l = o.r;j = o.s;var k;k = ECPointFp.decodeFromHex(this.ecparams.curve, p);var n = new BigInteger(m, 16);return this.verifyRaw(n, l, j, k);
  };this.verify = function (o, p, j) {
    var l, i;if (Bitcoin.Util.isArray(p)) {
      var n = this.parseSig(p);l = n.r;i = n.s;
    } else {
      if ("object" === (typeof p === "undefined" ? "undefined" : _typeof(p)) && p.r && p.s) {
        l = p.r;i = p.s;
      } else {
        throw "Invalid value for signature";
      }
    }var k;if (j instanceof ECPointFp) {
      k = j;
    } else {
      if (Bitcoin.Util.isArray(j)) {
        k = ECPointFp.decodeFrom(this.ecparams.curve, j);
      } else {
        throw "Invalid format for pubkey value, must be byte array or ECPointFp";
      }
    }var m = BigInteger.fromByteArrayUnsigned(o);return this.verifyRaw(m, l, i, k);
  };this.verifyRaw = function (o, i, w, m) {
    var l = this.ecparams.n;var u = this.ecparams.G;if (i.compareTo(BigInteger.ONE) < 0 || i.compareTo(l) >= 0) {
      return false;
    }if (w.compareTo(BigInteger.ONE) < 0 || w.compareTo(l) >= 0) {
      return false;
    }var p = w.modInverse(l);var k = o.multiply(p).mod(l);var j = i.multiply(p).mod(l);var q = u.multiply(k).add(m.multiply(j));var t = q.getX().toBigInteger().mod(l);return t.equals(i);
  };this.serializeSig = function (k, j) {
    var l = k.toByteArraySigned();var i = j.toByteArraySigned();var m = [];m.push(2);m.push(l.length);m = m.concat(l);m.push(2);m.push(i.length);m = m.concat(i);m.unshift(m.length);m.unshift(48);return m;
  };this.parseSig = function (n) {
    var m;if (n[0] != 48) {
      throw new Error("Signature not a valid DERSequence");
    }m = 2;if (n[m] != 2) {
      throw new Error("First element in signature must be a DERInteger");
    }var l = n.slice(m + 2, m + 2 + n[m + 1]);m += 2 + n[m + 1];if (n[m] != 2) {
      throw new Error("Second element in signature must be a DERInteger");
    }var i = n.slice(m + 2, m + 2 + n[m + 1]);m += 2 + n[m + 1];var k = BigInteger.fromByteArrayUnsigned(l);var j = BigInteger.fromByteArrayUnsigned(i);return { r: k, s: j };
  };this.parseSigCompact = function (m) {
    if (m.length !== 65) {
      throw "Signature has the wrong length";
    }var j = m[0] - 27;if (j < 0 || j > 7) {
      throw "Invalid signature type";
    }var o = this.ecparams.n;var l = BigInteger.fromByteArrayUnsigned(m.slice(1, 33)).mod(o);var k = BigInteger.fromByteArrayUnsigned(m.slice(33, 65)).mod(o);return { r: l, s: k, i: j };
  };this.readPKCS5PrvKeyHex = function (l) {
    var n = ASN1HEX;var m = KJUR.crypto.ECDSA.getName;var p = n.getVbyList;if (n.isASN1HEX(l) === false) {
      throw "not ASN.1 hex string";
    }var i, k, o;try {
      i = p(l, 0, [2, 0], "06");k = p(l, 0, [1], "04");try {
        o = p(l, 0, [3, 0], "03").substr(2);
      } catch (j) {}
    } catch (j) {
      throw "malformed PKCS#1/5 plain ECC private key";
    }this.curveName = m(i);if (this.curveName === undefined) {
      throw "unsupported curve name";
    }this.setNamedCurve(this.curveName);this.setPublicKeyHex(o);this.setPrivateKeyHex(k);this.isPublic = false;
  };this.readPKCS8PrvKeyHex = function (l) {
    var q = ASN1HEX;var i = KJUR.crypto.ECDSA.getName;var n = q.getVbyList;if (q.isASN1HEX(l) === false) {
      throw "not ASN.1 hex string";
    }var j, p, m, k;try {
      j = n(l, 0, [1, 0], "06");p = n(l, 0, [1, 1], "06");m = n(l, 0, [2, 0, 1], "04");try {
        k = n(l, 0, [2, 0, 2, 0], "03").substr(2);
      } catch (o) {}
    } catch (o) {
      throw "malformed PKCS#8 plain ECC private key";
    }this.curveName = i(p);if (this.curveName === undefined) {
      throw "unsupported curve name";
    }this.setNamedCurve(this.curveName);this.setPublicKeyHex(k);this.setPrivateKeyHex(m);this.isPublic = false;
  };this.readPKCS8PubKeyHex = function (l) {
    var n = ASN1HEX;var m = KJUR.crypto.ECDSA.getName;var p = n.getVbyList;if (n.isASN1HEX(l) === false) {
      throw "not ASN.1 hex string";
    }var k, i, o;try {
      k = p(l, 0, [0, 0], "06");i = p(l, 0, [0, 1], "06");o = p(l, 0, [1], "03").substr(2);
    } catch (j) {
      throw "malformed PKCS#8 ECC public key";
    }this.curveName = m(i);if (this.curveName === null) {
      throw "unsupported curve name";
    }this.setNamedCurve(this.curveName);this.setPublicKeyHex(o);
  };this.readCertPubKeyHex = function (k, p) {
    if (p !== 5) {
      p = 6;
    }var m = ASN1HEX;var l = KJUR.crypto.ECDSA.getName;var o = m.getVbyList;if (m.isASN1HEX(k) === false) {
      throw "not ASN.1 hex string";
    }var i, n;try {
      i = o(k, 0, [0, p, 0, 1], "06");n = o(k, 0, [0, p, 1], "03").substr(2);
    } catch (j) {
      throw "malformed X.509 certificate ECC public key";
    }this.curveName = l(i);if (this.curveName === null) {
      throw "unsupported curve name";
    }this.setNamedCurve(this.curveName);this.setPublicKeyHex(n);
  };if (h !== undefined) {
    if (h.curve !== undefined) {
      this.curveName = h.curve;
    }
  }if (this.curveName === undefined) {
    this.curveName = e;
  }this.setNamedCurve(this.curveName);if (h !== undefined) {
    if (h.prv !== undefined) {
      this.setPrivateKeyHex(h.prv);
    }if (h.pub !== undefined) {
      this.setPublicKeyHex(h.pub);
    }
  }
};KJUR.crypto.ECDSA.parseSigHex = function (a) {
  var b = KJUR.crypto.ECDSA.parseSigHexInHexRS(a);var d = new BigInteger(b.r, 16);var c = new BigInteger(b.s, 16);return { r: d, s: c };
};KJUR.crypto.ECDSA.parseSigHexInHexRS = function (f) {
  var j = ASN1HEX;var i = j.getChildIdx;var g = j.getV;if (f.substr(0, 2) != "30") {
    throw "signature is not a ASN.1 sequence";
  }var h = i(f, 0);if (h.length != 2) {
    throw "number of signature ASN.1 sequence elements seem wrong";
  }var e = h[0];var d = h[1];if (f.substr(e, 2) != "02") {
    throw "1st item of sequene of signature is not ASN.1 integer";
  }if (f.substr(d, 2) != "02") {
    throw "2nd item of sequene of signature is not ASN.1 integer";
  }var c = g(f, e);var b = g(f, d);return { r: c, s: b };
};KJUR.crypto.ECDSA.asn1SigToConcatSig = function (c) {
  var d = KJUR.crypto.ECDSA.parseSigHexInHexRS(c);var b = d.r;var a = d.s;if (b.substr(0, 2) == "00" && b.length % 32 == 2) {
    b = b.substr(2);
  }if (a.substr(0, 2) == "00" && a.length % 32 == 2) {
    a = a.substr(2);
  }if (b.length % 32 == 30) {
    b = "00" + b;
  }if (a.length % 32 == 30) {
    a = "00" + a;
  }if (b.length % 32 != 0) {
    throw "unknown ECDSA sig r length error";
  }if (a.length % 32 != 0) {
    throw "unknown ECDSA sig s length error";
  }return b + a;
};KJUR.crypto.ECDSA.concatSigToASN1Sig = function (a) {
  if (a.length / 2 * 8 % (16 * 8) != 0) {
    throw "unknown ECDSA concatinated r-s sig  length error";
  }var c = a.substr(0, a.length / 2);var b = a.substr(a.length / 2);return KJUR.crypto.ECDSA.hexRSSigToASN1Sig(c, b);
};KJUR.crypto.ECDSA.hexRSSigToASN1Sig = function (b, a) {
  var d = new BigInteger(b, 16);var c = new BigInteger(a, 16);return KJUR.crypto.ECDSA.biRSSigToASN1Sig(d, c);
};KJUR.crypto.ECDSA.biRSSigToASN1Sig = function (f, d) {
  var c = KJUR.asn1;var b = new c.DERInteger({ bigint: f });var a = new c.DERInteger({ bigint: d });var e = new c.DERSequence({ array: [b, a] });return e.getEncodedHex();
};KJUR.crypto.ECDSA.getName = function (a) {
  if (a === "2a8648ce3d030107") {
    return "secp256r1";
  }if (a === "2b8104000a") {
    return "secp256k1";
  }if (a === "2b81040022") {
    return "secp384r1";
  }if ("|secp256r1|NIST P-256|P-256|prime256v1|".indexOf(a) !== -1) {
    return "secp256r1";
  }if ("|secp256k1|".indexOf(a) !== -1) {
    return "secp256k1";
  }if ("|secp384r1|NIST P-384|P-384|".indexOf(a) !== -1) {
    return "secp384r1";
  }return null;
};
if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.crypto == "undefined" || !KJUR.crypto) {
  KJUR.crypto = {};
}KJUR.crypto.ECParameterDB = new function () {
  var b = {};var c = {};function a(d) {
    return new BigInteger(d, 16);
  }this.getByName = function (e) {
    var d = e;if (typeof c[d] != "undefined") {
      d = c[e];
    }if (typeof b[d] != "undefined") {
      return b[d];
    }throw "unregistered EC curve name: " + d;
  };this.regist = function (A, l, o, g, m, e, j, f, k, u, d, x) {
    b[A] = {};var s = a(o);var z = a(g);var y = a(m);var t = a(e);var w = a(j);var r = new ECCurveFp(s, z, y);var q = r.decodePointHex("04" + f + k);b[A]["name"] = A;b[A]["keylen"] = l;b[A]["curve"] = r;b[A]["G"] = q;b[A]["n"] = t;b[A]["h"] = w;b[A]["oid"] = d;b[A]["info"] = x;for (var v = 0; v < u.length; v++) {
      c[u[v]] = A;
    }
  };
}();KJUR.crypto.ECParameterDB.regist("secp128r1", 128, "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC", "E87579C11079F43DD824993C2CEE5ED3", "FFFFFFFE0000000075A30D1B9038A115", "1", "161FF7528B899B2D0C28607CA52C5B86", "CF5AC8395BAFEB13C02DA292DDED7A83", [], "", "secp128r1 : SECG curve over a 128 bit prime field");KJUR.crypto.ECParameterDB.regist("secp160k1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73", "0", "7", "0100000000000000000001B8FA16DFAB9ACA16B6B3", "1", "3B4C382CE37AA192A4019E763036F4F5DD4D7EBB", "938CF935318FDCED6BC28286531733C3F03C4FEE", [], "", "secp160k1 : SECG curve over a 160 bit prime field");KJUR.crypto.ECParameterDB.regist("secp160r1", 160, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC", "1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45", "0100000000000000000001F4C8F927AED3CA752257", "1", "4A96B5688EF573284664698968C38BB913CBFC82", "23A628553168947D59DCC912042351377AC5FB32", [], "", "secp160r1 : SECG curve over a 160 bit prime field");KJUR.crypto.ECParameterDB.regist("secp192k1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37", "0", "3", "FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D", "1", "DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D", "9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D", []);KJUR.crypto.ECParameterDB.regist("secp192r1", 192, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC", "64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1", "FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831", "1", "188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012", "07192B95FFC8DA78631011ED6B24CDD573F977A11E794811", []);KJUR.crypto.ECParameterDB.regist("secp224r1", 224, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE", "B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4", "FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D", "1", "B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21", "BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34", []);KJUR.crypto.ECParameterDB.regist("secp256k1", 256, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F", "0", "7", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", "1", "79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798", "483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8", []);KJUR.crypto.ECParameterDB.regist("secp256r1", 256, "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF", "FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC", "5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B", "FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551", "1", "6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296", "4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5", ["NIST P-256", "P-256", "prime256v1"]);KJUR.crypto.ECParameterDB.regist("secp384r1", 384, "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC", "B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF", "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973", "1", "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7", "3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f", ["NIST P-384", "P-384"]);KJUR.crypto.ECParameterDB.regist("secp521r1", 521, "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC", "051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00", "1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409", "1", "C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66", "011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650", ["NIST P-521", "P-521"]);
var KEYUTIL = function () {
  var d = function d(p, r, q) {
    return k(CryptoJS.AES, p, r, q);
  };var e = function e(p, r, q) {
    return k(CryptoJS.TripleDES, p, r, q);
  };var a = function a(p, r, q) {
    return k(CryptoJS.DES, p, r, q);
  };var k = function k(s, x, u, q) {
    var r = CryptoJS.enc.Hex.parse(x);var w = CryptoJS.enc.Hex.parse(u);var p = CryptoJS.enc.Hex.parse(q);var t = {};t.key = w;t.iv = p;t.ciphertext = r;var v = s.decrypt(t, w, { iv: p });return CryptoJS.enc.Hex.stringify(v);
  };var l = function l(p, r, q) {
    return g(CryptoJS.AES, p, r, q);
  };var o = function o(p, r, q) {
    return g(CryptoJS.TripleDES, p, r, q);
  };var f = function f(p, r, q) {
    return g(CryptoJS.DES, p, r, q);
  };var g = function g(t, y, v, q) {
    var s = CryptoJS.enc.Hex.parse(y);var x = CryptoJS.enc.Hex.parse(v);var p = CryptoJS.enc.Hex.parse(q);var w = t.encrypt(s, x, { iv: p });var r = CryptoJS.enc.Hex.parse(w.toString());var u = CryptoJS.enc.Base64.stringify(r);return u;
  };var i = { "AES-256-CBC": { proc: d, eproc: l, keylen: 32, ivlen: 16 }, "AES-192-CBC": { proc: d, eproc: l, keylen: 24, ivlen: 16 }, "AES-128-CBC": { proc: d, eproc: l, keylen: 16, ivlen: 16 }, "DES-EDE3-CBC": { proc: e, eproc: o, keylen: 24, ivlen: 8 }, "DES-CBC": { proc: a, eproc: f, keylen: 8, ivlen: 8 } };var c = function c(p) {
    return i[p]["proc"];
  };var m = function m(p) {
    var r = CryptoJS.lib.WordArray.random(p);var q = CryptoJS.enc.Hex.stringify(r);return q;
  };var n = function n(v) {
    var w = {};var q = v.match(new RegExp("DEK-Info: ([^,]+),([0-9A-Fa-f]+)", "m"));if (q) {
      w.cipher = q[1];w.ivsalt = q[2];
    }var p = v.match(new RegExp("-----BEGIN ([A-Z]+) PRIVATE KEY-----"));if (p) {
      w.type = p[1];
    }var u = -1;var x = 0;if (v.indexOf("\r\n\r\n") != -1) {
      u = v.indexOf("\r\n\r\n");x = 2;
    }if (v.indexOf("\n\n") != -1) {
      u = v.indexOf("\n\n");x = 1;
    }var t = v.indexOf("-----END");if (u != -1 && t != -1) {
      var r = v.substring(u + x * 2, t - x);r = r.replace(/\s+/g, "");w.data = r;
    }return w;
  };var j = function j(q, y, p) {
    var v = p.substring(0, 16);var t = CryptoJS.enc.Hex.parse(v);var r = CryptoJS.enc.Utf8.parse(y);var u = i[q]["keylen"] + i[q]["ivlen"];var x = "";var w = null;for (;;) {
      var s = CryptoJS.algo.MD5.create();if (w != null) {
        s.update(w);
      }s.update(r);s.update(t);w = s.finalize();x = x + CryptoJS.enc.Hex.stringify(w);if (x.length >= u * 2) {
        break;
      }
    }var z = {};z.keyhex = x.substr(0, i[q]["keylen"] * 2);z.ivhex = x.substr(i[q]["keylen"] * 2, i[q]["ivlen"] * 2);return z;
  };var b = function b(p, v, r, w) {
    var s = CryptoJS.enc.Base64.parse(p);var q = CryptoJS.enc.Hex.stringify(s);var u = i[v]["proc"];var t = u(q, r, w);return t;
  };var h = function h(p, s, q, u) {
    var r = i[s]["eproc"];var t = r(p, q, u);return t;
  };return { version: "1.0.0", parsePKCS5PEM: function parsePKCS5PEM(p) {
      return n(p);
    }, getKeyAndUnusedIvByPasscodeAndIvsalt: function getKeyAndUnusedIvByPasscodeAndIvsalt(q, p, r) {
      return j(q, p, r);
    }, decryptKeyB64: function decryptKeyB64(p, r, q, s) {
      return b(p, r, q, s);
    }, getDecryptedKeyHex: function getDecryptedKeyHex(y, x) {
      var q = n(y);var t = q.type;var r = q.cipher;var p = q.ivsalt;var s = q.data;var w = j(r, x, p);var v = w.keyhex;var u = b(s, r, v, p);return u;
    }, getEncryptedPKCS5PEMFromPrvKeyHex: function getEncryptedPKCS5PEMFromPrvKeyHex(x, s, A, t, r) {
      var p = "";if (typeof t == "undefined" || t == null) {
        t = "AES-256-CBC";
      }if (typeof i[t] == "undefined") {
        throw "KEYUTIL unsupported algorithm: " + t;
      }if (typeof r == "undefined" || r == null) {
        var v = i[t]["ivlen"];var u = m(v);r = u.toUpperCase();
      }var z = j(t, A, r);var y = z.keyhex;var w = h(s, t, y, r);var q = w.replace(/(.{64})/g, "$1\r\n");var p = "-----BEGIN " + x + " PRIVATE KEY-----\r\n";p += "Proc-Type: 4,ENCRYPTED\r\n";p += "DEK-Info: " + t + "," + r + "\r\n";p += "\r\n";p += q;p += "\r\n-----END " + x + " PRIVATE KEY-----\r\n";return p;
    }, parseHexOfEncryptedPKCS8: function parseHexOfEncryptedPKCS8(y) {
      var B = ASN1HEX;var z = B.getChildIdx;var w = B.getV;var t = {};var r = z(y, 0);if (r.length != 2) {
        throw "malformed format: SEQUENCE(0).items != 2: " + r.length;
      }t.ciphertext = w(y, r[1]);var A = z(y, r[0]);if (A.length != 2) {
        throw "malformed format: SEQUENCE(0.0).items != 2: " + A.length;
      }if (w(y, A[0]) != "2a864886f70d01050d") {
        throw "this only supports pkcs5PBES2";
      }var p = z(y, A[1]);if (A.length != 2) {
        throw "malformed format: SEQUENCE(0.0.1).items != 2: " + p.length;
      }var q = z(y, p[1]);if (q.length != 2) {
        throw "malformed format: SEQUENCE(0.0.1.1).items != 2: " + q.length;
      }if (w(y, q[0]) != "2a864886f70d0307") {
        throw "this only supports TripleDES";
      }t.encryptionSchemeAlg = "TripleDES";t.encryptionSchemeIV = w(y, q[1]);var s = z(y, p[0]);if (s.length != 2) {
        throw "malformed format: SEQUENCE(0.0.1.0).items != 2: " + s.length;
      }if (w(y, s[0]) != "2a864886f70d01050c") {
        throw "this only supports pkcs5PBKDF2";
      }var x = z(y, s[1]);if (x.length < 2) {
        throw "malformed format: SEQUENCE(0.0.1.0.1).items < 2: " + x.length;
      }t.pbkdf2Salt = w(y, x[0]);var u = w(y, x[1]);try {
        t.pbkdf2Iter = parseInt(u, 16);
      } catch (v) {
        throw "malformed format pbkdf2Iter: " + u;
      }return t;
    }, getPBKDF2KeyHexFromParam: function getPBKDF2KeyHexFromParam(u, p) {
      var t = CryptoJS.enc.Hex.parse(u.pbkdf2Salt);var q = u.pbkdf2Iter;var s = CryptoJS.PBKDF2(p, t, { keySize: 192 / 32, iterations: q });var r = CryptoJS.enc.Hex.stringify(s);return r;
    }, _getPlainPKCS8HexFromEncryptedPKCS8PEM: function _getPlainPKCS8HexFromEncryptedPKCS8PEM(x, y) {
      var r = pemtohex(x, "ENCRYPTED PRIVATE KEY");var p = this.parseHexOfEncryptedPKCS8(r);var u = KEYUTIL.getPBKDF2KeyHexFromParam(p, y);var v = {};v.ciphertext = CryptoJS.enc.Hex.parse(p.ciphertext);var t = CryptoJS.enc.Hex.parse(u);var s = CryptoJS.enc.Hex.parse(p.encryptionSchemeIV);var w = CryptoJS.TripleDES.decrypt(v, t, { iv: s });var q = CryptoJS.enc.Hex.stringify(w);return q;
    }, getKeyFromEncryptedPKCS8PEM: function getKeyFromEncryptedPKCS8PEM(s, q) {
      var p = this._getPlainPKCS8HexFromEncryptedPKCS8PEM(s, q);var r = this.getKeyFromPlainPrivatePKCS8Hex(p);return r;
    }, parsePlainPrivatePKCS8Hex: function parsePlainPrivatePKCS8Hex(s) {
      var v = ASN1HEX;var u = v.getChildIdx;var t = v.getV;var q = {};q.algparam = null;if (s.substr(0, 2) != "30") {
        throw "malformed plain PKCS8 private key(code:001)";
      }var r = u(s, 0);if (r.length != 3) {
        throw "malformed plain PKCS8 private key(code:002)";
      }if (s.substr(r[1], 2) != "30") {
        throw "malformed PKCS8 private key(code:003)";
      }var p = u(s, r[1]);if (p.length != 2) {
        throw "malformed PKCS8 private key(code:004)";
      }if (s.substr(p[0], 2) != "06") {
        throw "malformed PKCS8 private key(code:005)";
      }q.algoid = t(s, p[0]);if (s.substr(p[1], 2) == "06") {
        q.algparam = t(s, p[1]);
      }if (s.substr(r[2], 2) != "04") {
        throw "malformed PKCS8 private key(code:006)";
      }q.keyidx = v.getVidx(s, r[2]);return q;
    }, getKeyFromPlainPrivatePKCS8PEM: function getKeyFromPlainPrivatePKCS8PEM(q) {
      var p = pemtohex(q, "PRIVATE KEY");var r = this.getKeyFromPlainPrivatePKCS8Hex(p);return r;
    }, getKeyFromPlainPrivatePKCS8Hex: function getKeyFromPlainPrivatePKCS8Hex(p) {
      var q = this.parsePlainPrivatePKCS8Hex(p);var r;if (q.algoid == "2a864886f70d010101") {
        r = new RSAKey();
      } else {
        if (q.algoid == "2a8648ce380401") {
          r = new KJUR.crypto.DSA();
        } else {
          if (q.algoid == "2a8648ce3d0201") {
            r = new KJUR.crypto.ECDSA();
          } else {
            throw "unsupported private key algorithm";
          }
        }
      }r.readPKCS8PrvKeyHex(p);return r;
    }, _getKeyFromPublicPKCS8Hex: function _getKeyFromPublicPKCS8Hex(q) {
      var p;var r = ASN1HEX.getVbyList(q, 0, [0, 0], "06");if (r === "2a864886f70d010101") {
        p = new RSAKey();
      } else {
        if (r === "2a8648ce380401") {
          p = new KJUR.crypto.DSA();
        } else {
          if (r === "2a8648ce3d0201") {
            p = new KJUR.crypto.ECDSA();
          } else {
            throw "unsupported PKCS#8 public key hex";
          }
        }
      }p.readPKCS8PubKeyHex(q);return p;
    }, parsePublicRawRSAKeyHex: function parsePublicRawRSAKeyHex(r) {
      var u = ASN1HEX;var t = u.getChildIdx;var s = u.getV;var p = {};if (r.substr(0, 2) != "30") {
        throw "malformed RSA key(code:001)";
      }var q = t(r, 0);if (q.length != 2) {
        throw "malformed RSA key(code:002)";
      }if (r.substr(q[0], 2) != "02") {
        throw "malformed RSA key(code:003)";
      }p.n = s(r, q[0]);if (r.substr(q[1], 2) != "02") {
        throw "malformed RSA key(code:004)";
      }p.e = s(r, q[1]);return p;
    }, parsePublicPKCS8Hex: function parsePublicPKCS8Hex(t) {
      var v = ASN1HEX;var u = v.getChildIdx;var s = v.getV;var q = {};q.algparam = null;var r = u(t, 0);if (r.length != 2) {
        throw "outer DERSequence shall have 2 elements: " + r.length;
      }var w = r[0];if (t.substr(w, 2) != "30") {
        throw "malformed PKCS8 public key(code:001)";
      }var p = u(t, w);if (p.length != 2) {
        throw "malformed PKCS8 public key(code:002)";
      }if (t.substr(p[0], 2) != "06") {
        throw "malformed PKCS8 public key(code:003)";
      }q.algoid = s(t, p[0]);if (t.substr(p[1], 2) == "06") {
        q.algparam = s(t, p[1]);
      } else {
        if (t.substr(p[1], 2) == "30") {
          q.algparam = {};q.algparam.p = v.getVbyList(t, p[1], [0], "02");q.algparam.q = v.getVbyList(t, p[1], [1], "02");q.algparam.g = v.getVbyList(t, p[1], [2], "02");
        }
      }if (t.substr(r[1], 2) != "03") {
        throw "malformed PKCS8 public key(code:004)";
      }q.key = s(t, r[1]).substr(2);return q;
    } };
}();KEYUTIL.getKey = function (l, k, n) {
  var G = ASN1HEX,
      L = G.getChildIdx,
      v = G.getV,
      d = G.getVbyList,
      c = KJUR.crypto,
      i = c.ECDSA,
      C = c.DSA,
      w = RSAKey,
      M = pemtohex,
      F = KEYUTIL;if (typeof w != "undefined" && l instanceof w) {
    return l;
  }if (typeof i != "undefined" && l instanceof i) {
    return l;
  }if (typeof C != "undefined" && l instanceof C) {
    return l;
  }if (l.curve !== undefined && l.xy !== undefined && l.d === undefined) {
    return new i({ pub: l.xy, curve: l.curve });
  }if (l.curve !== undefined && l.d !== undefined) {
    return new i({ prv: l.d, curve: l.curve });
  }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d === undefined) {
    var P = new w();P.setPublic(l.n, l.e);return P;
  }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p !== undefined && l.q !== undefined && l.dp !== undefined && l.dq !== undefined && l.co !== undefined && l.qi === undefined) {
    var P = new w();P.setPrivateEx(l.n, l.e, l.d, l.p, l.q, l.dp, l.dq, l.co);return P;
  }if (l.kty === undefined && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p === undefined) {
    var P = new w();P.setPrivate(l.n, l.e, l.d);return P;
  }if (l.p !== undefined && l.q !== undefined && l.g !== undefined && l.y !== undefined && l.x === undefined) {
    var P = new C();P.setPublic(l.p, l.q, l.g, l.y);return P;
  }if (l.p !== undefined && l.q !== undefined && l.g !== undefined && l.y !== undefined && l.x !== undefined) {
    var P = new C();P.setPrivate(l.p, l.q, l.g, l.y, l.x);return P;
  }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d === undefined) {
    var P = new w();P.setPublic(b64utohex(l.n), b64utohex(l.e));return P;
  }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d !== undefined && l.p !== undefined && l.q !== undefined && l.dp !== undefined && l.dq !== undefined && l.qi !== undefined) {
    var P = new w();P.setPrivateEx(b64utohex(l.n), b64utohex(l.e), b64utohex(l.d), b64utohex(l.p), b64utohex(l.q), b64utohex(l.dp), b64utohex(l.dq), b64utohex(l.qi));return P;
  }if (l.kty === "RSA" && l.n !== undefined && l.e !== undefined && l.d !== undefined) {
    var P = new w();P.setPrivate(b64utohex(l.n), b64utohex(l.e), b64utohex(l.d));return P;
  }if (l.kty === "EC" && l.crv !== undefined && l.x !== undefined && l.y !== undefined && l.d === undefined) {
    var j = new i({ curve: l.crv });var t = j.ecparams.keylen / 4;var B = ("0000000000" + b64utohex(l.x)).slice(-t);var z = ("0000000000" + b64utohex(l.y)).slice(-t);var u = "04" + B + z;j.setPublicKeyHex(u);return j;
  }if (l.kty === "EC" && l.crv !== undefined && l.x !== undefined && l.y !== undefined && l.d !== undefined) {
    var j = new i({ curve: l.crv });var t = j.ecparams.keylen / 4;var B = ("0000000000" + b64utohex(l.x)).slice(-t);var z = ("0000000000" + b64utohex(l.y)).slice(-t);var u = "04" + B + z;var b = ("0000000000" + b64utohex(l.d)).slice(-t);j.setPublicKeyHex(u);j.setPrivateKeyHex(b);return j;
  }if (n === "pkcs5prv") {
    var J = l,
        G = ASN1HEX,
        N,
        P;N = L(J, 0);if (N.length === 9) {
      P = new w();P.readPKCS5PrvKeyHex(J);
    } else {
      if (N.length === 6) {
        P = new C();P.readPKCS5PrvKeyHex(J);
      } else {
        if (N.length > 2 && J.substr(N[1], 2) === "04") {
          P = new i();P.readPKCS5PrvKeyHex(J);
        } else {
          throw "unsupported PKCS#1/5 hexadecimal key";
        }
      }
    }return P;
  }if (n === "pkcs8prv") {
    var P = F.getKeyFromPlainPrivatePKCS8Hex(l);return P;
  }if (n === "pkcs8pub") {
    return F._getKeyFromPublicPKCS8Hex(l);
  }if (n === "x509pub") {
    return X509.getPublicKeyFromCertHex(l);
  }if (l.indexOf("-END CERTIFICATE-", 0) != -1 || l.indexOf("-END X509 CERTIFICATE-", 0) != -1 || l.indexOf("-END TRUSTED CERTIFICATE-", 0) != -1) {
    return X509.getPublicKeyFromCertPEM(l);
  }if (l.indexOf("-END PUBLIC KEY-") != -1) {
    var O = pemtohex(l, "PUBLIC KEY");return F._getKeyFromPublicPKCS8Hex(O);
  }if (l.indexOf("-END RSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") == -1) {
    var m = M(l, "RSA PRIVATE KEY");return F.getKey(m, null, "pkcs5prv");
  }if (l.indexOf("-END DSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") == -1) {
    var I = M(l, "DSA PRIVATE KEY");var E = d(I, 0, [1], "02");var D = d(I, 0, [2], "02");var K = d(I, 0, [3], "02");var r = d(I, 0, [4], "02");var s = d(I, 0, [5], "02");var P = new C();P.setPrivate(new BigInteger(E, 16), new BigInteger(D, 16), new BigInteger(K, 16), new BigInteger(r, 16), new BigInteger(s, 16));return P;
  }if (l.indexOf("-END PRIVATE KEY-") != -1) {
    return F.getKeyFromPlainPrivatePKCS8PEM(l);
  }if (l.indexOf("-END RSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
    var o = F.getDecryptedKeyHex(l, k);var H = new RSAKey();H.readPKCS5PrvKeyHex(o);return H;
  }if (l.indexOf("-END EC PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
    var I = F.getDecryptedKeyHex(l, k);var P = d(I, 0, [1], "04");var f = d(I, 0, [2, 0], "06");var A = d(I, 0, [3, 0], "03").substr(2);var e = "";if (KJUR.crypto.OID.oidhex2name[f] !== undefined) {
      e = KJUR.crypto.OID.oidhex2name[f];
    } else {
      throw "undefined OID(hex) in KJUR.crypto.OID: " + f;
    }var j = new i({ curve: e });j.setPublicKeyHex(A);j.setPrivateKeyHex(P);j.isPublic = false;return j;
  }if (l.indexOf("-END DSA PRIVATE KEY-") != -1 && l.indexOf("4,ENCRYPTED") != -1) {
    var I = F.getDecryptedKeyHex(l, k);var E = d(I, 0, [1], "02");var D = d(I, 0, [2], "02");var K = d(I, 0, [3], "02");var r = d(I, 0, [4], "02");var s = d(I, 0, [5], "02");var P = new C();P.setPrivate(new BigInteger(E, 16), new BigInteger(D, 16), new BigInteger(K, 16), new BigInteger(r, 16), new BigInteger(s, 16));return P;
  }if (l.indexOf("-END ENCRYPTED PRIVATE KEY-") != -1) {
    return F.getKeyFromEncryptedPKCS8PEM(l, k);
  }throw "not supported argument";
};KEYUTIL.generateKeypair = function (a, c) {
  if (a == "RSA") {
    var b = c;var h = new RSAKey();h.generate(b, "10001");h.isPrivate = true;h.isPublic = true;var f = new RSAKey();var e = h.n.toString(16);var i = h.e.toString(16);f.setPublic(e, i);f.isPrivate = false;f.isPublic = true;var k = {};k.prvKeyObj = h;k.pubKeyObj = f;return k;
  } else {
    if (a == "EC") {
      var d = c;var g = new KJUR.crypto.ECDSA({ curve: d });var j = g.generateKeyPairHex();var h = new KJUR.crypto.ECDSA({ curve: d });h.setPublicKeyHex(j.ecpubhex);h.setPrivateKeyHex(j.ecprvhex);h.isPrivate = true;h.isPublic = false;var f = new KJUR.crypto.ECDSA({ curve: d });f.setPublicKeyHex(j.ecpubhex);f.isPrivate = false;f.isPublic = true;var k = {};k.prvKeyObj = h;k.pubKeyObj = f;return k;
    } else {
      throw "unknown algorithm: " + a;
    }
  }
};KEYUTIL.getPEM = function (b, D, y, m, q, j) {
  var F = KJUR,
      k = F.asn1,
      z = k.DERObjectIdentifier,
      f = k.DERInteger,
      l = k.ASN1Util.newObject,
      a = k.x509,
      C = a.SubjectPublicKeyInfo,
      e = F.crypto,
      u = e.DSA,
      r = e.ECDSA,
      n = RSAKey;function A(s) {
    var G = l({ seq: [{ "int": 0 }, { "int": { bigint: s.n } }, { "int": s.e }, { "int": { bigint: s.d } }, { "int": { bigint: s.p } }, { "int": { bigint: s.q } }, { "int": { bigint: s.dmp1 } }, { "int": { bigint: s.dmq1 } }, { "int": { bigint: s.coeff } }] });return G;
  }function B(G) {
    var s = l({ seq: [{ "int": 1 }, { octstr: { hex: G.prvKeyHex } }, { tag: ["a0", true, { oid: { name: G.curveName } }] }, { tag: ["a1", true, { bitstr: { hex: "00" + G.pubKeyHex } }] }] });return s;
  }function x(s) {
    var G = l({ seq: [{ "int": 0 }, { "int": { bigint: s.p } }, { "int": { bigint: s.q } }, { "int": { bigint: s.g } }, { "int": { bigint: s.y } }, { "int": { bigint: s.x } }] });return G;
  }if ((n !== undefined && b instanceof n || u !== undefined && b instanceof u || r !== undefined && b instanceof r) && b.isPublic == true && (D === undefined || D == "PKCS8PUB")) {
    var E = new C(b);var w = E.getEncodedHex();return hextopem(w, "PUBLIC KEY");
  }if (D == "PKCS1PRV" && n !== undefined && b instanceof n && (y === undefined || y == null) && b.isPrivate == true) {
    var E = A(b);var w = E.getEncodedHex();return hextopem(w, "RSA PRIVATE KEY");
  }if (D == "PKCS1PRV" && r !== undefined && b instanceof r && (y === undefined || y == null) && b.isPrivate == true) {
    var i = new z({ name: b.curveName });var v = i.getEncodedHex();var h = B(b);var t = h.getEncodedHex();var p = "";p += hextopem(v, "EC PARAMETERS");p += hextopem(t, "EC PRIVATE KEY");return p;
  }if (D == "PKCS1PRV" && u !== undefined && b instanceof u && (y === undefined || y == null) && b.isPrivate == true) {
    var E = x(b);var w = E.getEncodedHex();return hextopem(w, "DSA PRIVATE KEY");
  }if (D == "PKCS5PRV" && n !== undefined && b instanceof n && y !== undefined && y != null && b.isPrivate == true) {
    var E = A(b);var w = E.getEncodedHex();if (m === undefined) {
      m = "DES-EDE3-CBC";
    }return this.getEncryptedPKCS5PEMFromPrvKeyHex("RSA", w, y, m, j);
  }if (D == "PKCS5PRV" && r !== undefined && b instanceof r && y !== undefined && y != null && b.isPrivate == true) {
    var E = B(b);var w = E.getEncodedHex();if (m === undefined) {
      m = "DES-EDE3-CBC";
    }return this.getEncryptedPKCS5PEMFromPrvKeyHex("EC", w, y, m, j);
  }if (D == "PKCS5PRV" && u !== undefined && b instanceof u && y !== undefined && y != null && b.isPrivate == true) {
    var E = x(b);var w = E.getEncodedHex();if (m === undefined) {
      m = "DES-EDE3-CBC";
    }return this.getEncryptedPKCS5PEMFromPrvKeyHex("DSA", w, y, m, j);
  }var o = function o(G, s) {
    var I = c(G, s);var H = new l({ seq: [{ seq: [{ oid: { name: "pkcs5PBES2" } }, { seq: [{ seq: [{ oid: { name: "pkcs5PBKDF2" } }, { seq: [{ octstr: { hex: I.pbkdf2Salt } }, { "int": I.pbkdf2Iter }] }] }, { seq: [{ oid: { name: "des-EDE3-CBC" } }, { octstr: { hex: I.encryptionSchemeIV } }] }] }] }, { octstr: { hex: I.ciphertext } }] });return H.getEncodedHex();
  };var c = function c(N, O) {
    var H = 100;var M = CryptoJS.lib.WordArray.random(8);var L = "DES-EDE3-CBC";var s = CryptoJS.lib.WordArray.random(8);var I = CryptoJS.PBKDF2(O, M, { keySize: 192 / 32, iterations: H });var J = CryptoJS.enc.Hex.parse(N);var K = CryptoJS.TripleDES.encrypt(J, I, { iv: s }) + "";var G = {};G.ciphertext = K;G.pbkdf2Salt = CryptoJS.enc.Hex.stringify(M);G.pbkdf2Iter = H;G.encryptionSchemeAlg = L;G.encryptionSchemeIV = CryptoJS.enc.Hex.stringify(s);return G;
  };if (D == "PKCS8PRV" && n != undefined && b instanceof n && b.isPrivate == true) {
    var g = A(b);var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "rsaEncryption" } }, { "null": true }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
      return hextopem(w, "PRIVATE KEY");
    } else {
      var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
    }
  }if (D == "PKCS8PRV" && r !== undefined && b instanceof r && b.isPrivate == true) {
    var g = new l({ seq: [{ "int": 1 }, { octstr: { hex: b.prvKeyHex } }, { tag: ["a1", true, { bitstr: { hex: "00" + b.pubKeyHex } }] }] });var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "ecPublicKey" } }, { oid: { name: b.curveName } }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
      return hextopem(w, "PRIVATE KEY");
    } else {
      var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
    }
  }if (D == "PKCS8PRV" && u !== undefined && b instanceof u && b.isPrivate == true) {
    var g = new f({ bigint: b.x });var d = g.getEncodedHex();var E = l({ seq: [{ "int": 0 }, { seq: [{ oid: { name: "dsa" } }, { seq: [{ "int": { bigint: b.p } }, { "int": { bigint: b.q } }, { "int": { bigint: b.g } }] }] }, { octstr: { hex: d } }] });var w = E.getEncodedHex();if (y === undefined || y == null) {
      return hextopem(w, "PRIVATE KEY");
    } else {
      var t = o(w, y);return hextopem(t, "ENCRYPTED PRIVATE KEY");
    }
  }throw "unsupported object nor format";
};KEYUTIL.getKeyFromCSRPEM = function (b) {
  var a = pemtohex(b, "CERTIFICATE REQUEST");var c = KEYUTIL.getKeyFromCSRHex(a);return c;
};KEYUTIL.getKeyFromCSRHex = function (a) {
  var c = KEYUTIL.parseCSRHex(a);var b = KEYUTIL.getKey(c.p8pubkeyhex, null, "pkcs8pub");return b;
};KEYUTIL.parseCSRHex = function (d) {
  var i = ASN1HEX;var f = i.getChildIdx;var c = i.getTLV;var b = {};var g = d;if (g.substr(0, 2) != "30") {
    throw "malformed CSR(code:001)";
  }var e = f(g, 0);if (e.length < 1) {
    throw "malformed CSR(code:002)";
  }if (g.substr(e[0], 2) != "30") {
    throw "malformed CSR(code:003)";
  }var a = f(g, e[0]);if (a.length < 3) {
    throw "malformed CSR(code:004)";
  }b.p8pubkeyhex = c(g, a[2]);return b;
};KEYUTIL.getJWKFromKey = function (d) {
  var b = {};if (d instanceof RSAKey && d.isPrivate) {
    b.kty = "RSA";b.n = hextob64u(d.n.toString(16));b.e = hextob64u(d.e.toString(16));b.d = hextob64u(d.d.toString(16));b.p = hextob64u(d.p.toString(16));b.q = hextob64u(d.q.toString(16));b.dp = hextob64u(d.dmp1.toString(16));b.dq = hextob64u(d.dmq1.toString(16));b.qi = hextob64u(d.coeff.toString(16));return b;
  } else {
    if (d instanceof RSAKey && d.isPublic) {
      b.kty = "RSA";b.n = hextob64u(d.n.toString(16));b.e = hextob64u(d.e.toString(16));return b;
    } else {
      if (d instanceof KJUR.crypto.ECDSA && d.isPrivate) {
        var a = d.getShortNISTPCurveName();if (a !== "P-256" && a !== "P-384") {
          throw "unsupported curve name for JWT: " + a;
        }var c = d.getPublicKeyXYHex();b.kty = "EC";b.crv = a;b.x = hextob64u(c.x);b.y = hextob64u(c.y);b.d = hextob64u(d.prvKeyHex);return b;
      } else {
        if (d instanceof KJUR.crypto.ECDSA && d.isPublic) {
          var a = d.getShortNISTPCurveName();if (a !== "P-256" && a !== "P-384") {
            throw "unsupported curve name for JWT: " + a;
          }var c = d.getPublicKeyXYHex();b.kty = "EC";b.crv = a;b.x = hextob64u(c.x);b.y = hextob64u(c.y);return b;
        }
      }
    }
  }throw "not supported key object";
};
RSAKey.getPosArrayOfChildrenFromHex = function (a) {
  return ASN1HEX.getChildIdx(a, 0);
};RSAKey.getHexValueArrayOfChildrenFromHex = function (f) {
  var n = ASN1HEX;var i = n.getV;var k = RSAKey.getPosArrayOfChildrenFromHex(f);var e = i(f, k[0]);var j = i(f, k[1]);var b = i(f, k[2]);var c = i(f, k[3]);var h = i(f, k[4]);var g = i(f, k[5]);var m = i(f, k[6]);var l = i(f, k[7]);var d = i(f, k[8]);var k = new Array();k.push(e, j, b, c, h, g, m, l, d);return k;
};RSAKey.prototype.readPrivateKeyFromPEMString = function (d) {
  var c = pemtohex(d);var b = RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8]);
};RSAKey.prototype.readPKCS5PrvKeyHex = function (c) {
  var b = RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1], b[2], b[3], b[4], b[5], b[6], b[7], b[8]);
};RSAKey.prototype.readPKCS8PrvKeyHex = function (e) {
  var c, j, l, b, a, f, d, k;var m = ASN1HEX;var g = m.getVbyList;if (m.isASN1HEX(e) === false) {
    throw "not ASN.1 hex string";
  }try {
    c = g(e, 0, [2, 0, 1], "02");j = g(e, 0, [2, 0, 2], "02");l = g(e, 0, [2, 0, 3], "02");b = g(e, 0, [2, 0, 4], "02");a = g(e, 0, [2, 0, 5], "02");f = g(e, 0, [2, 0, 6], "02");d = g(e, 0, [2, 0, 7], "02");k = g(e, 0, [2, 0, 8], "02");
  } catch (i) {
    throw "malformed PKCS#8 plain RSA private key";
  }this.setPrivateEx(c, j, l, b, a, f, d, k);
};RSAKey.prototype.readPKCS5PubKeyHex = function (c) {
  var e = ASN1HEX;var b = e.getV;if (e.isASN1HEX(c) === false) {
    throw "keyHex is not ASN.1 hex string";
  }var a = e.getChildIdx(c, 0);if (a.length !== 2 || c.substr(a[0], 2) !== "02" || c.substr(a[1], 2) !== "02") {
    throw "wrong hex for PKCS#5 public key";
  }var f = b(c, a[0]);var d = b(c, a[1]);this.setPublic(f, d);
};RSAKey.prototype.readPKCS8PubKeyHex = function (b) {
  var c = ASN1HEX;if (c.isASN1HEX(b) === false) {
    throw "not ASN.1 hex string";
  }if (c.getTLVbyList(b, 0, [0, 0]) !== "06092a864886f70d010101") {
    throw "not PKCS8 RSA public key";
  }var a = c.getTLVbyList(b, 0, [1, 0]);this.readPKCS5PubKeyHex(a);
};RSAKey.prototype.readCertPubKeyHex = function (b, d) {
  var a, c;a = new X509();a.readCertHex(b);c = a.getPublicKeyHex();this.readPKCS8PubKeyHex(c);
};
var _RE_HEXDECONLY = new RegExp("");_RE_HEXDECONLY.compile("[^0-9a-f]", "gi");function _rsasign_getHexPaddedDigestInfoForString(d, e, a) {
  var b = function b(f) {
    return KJUR.crypto.Util.hashString(f, a);
  };var c = b(d);return KJUR.crypto.Util.getPaddedDigestInfoHex(c, a, e);
}function _zeroPaddingOfSignature(e, d) {
  var c = "";var a = d / 4 - e.length;for (var b = 0; b < a; b++) {
    c = c + "0";
  }return c + e;
}RSAKey.prototype.sign = function (d, a) {
  var b = function b(e) {
    return KJUR.crypto.Util.hashString(e, a);
  };var c = b(d);return this.signWithMessageHash(c, a);
};RSAKey.prototype.signWithMessageHash = function (e, c) {
  var f = KJUR.crypto.Util.getPaddedDigestInfoHex(e, c, this.n.bitLength());var b = parseBigInt(f, 16);var d = this.doPrivate(b);var a = d.toString(16);return _zeroPaddingOfSignature(a, this.n.bitLength());
};function pss_mgf1_str(c, a, e) {
  var b = "",
      d = 0;while (b.length < a) {
    b += hextorstr(e(rstrtohex(c + String.fromCharCode.apply(String, [(d & 4278190080) >> 24, (d & 16711680) >> 16, (d & 65280) >> 8, d & 255]))));d += 1;
  }return b;
}RSAKey.prototype.signPSS = function (e, a, d) {
  var c = function c(f) {
    return KJUR.crypto.Util.hashHex(f, a);
  };var b = c(rstrtohex(e));if (d === undefined) {
    d = -1;
  }return this.signWithMessageHashPSS(b, a, d);
};RSAKey.prototype.signWithMessageHashPSS = function (l, a, k) {
  var b = hextorstr(l);var g = b.length;var m = this.n.bitLength() - 1;var c = Math.ceil(m / 8);var d;var o = function o(i) {
    return KJUR.crypto.Util.hashHex(i, a);
  };if (k === -1 || k === undefined) {
    k = g;
  } else {
    if (k === -2) {
      k = c - g - 2;
    } else {
      if (k < -2) {
        throw "invalid salt length";
      }
    }
  }if (c < g + k + 2) {
    throw "data too long";
  }var f = "";if (k > 0) {
    f = new Array(k);new SecureRandom().nextBytes(f);f = String.fromCharCode.apply(String, f);
  }var n = hextorstr(o(rstrtohex("\x00\x00\x00\x00\x00\x00\x00\x00" + b + f)));var j = [];for (d = 0; d < c - k - g - 2; d += 1) {
    j[d] = 0;
  }var e = String.fromCharCode.apply(String, j) + "\x01" + f;var h = pss_mgf1_str(n, e.length, o);var q = [];for (d = 0; d < e.length; d += 1) {
    q[d] = e.charCodeAt(d) ^ h.charCodeAt(d);
  }var p = 65280 >> 8 * c - m & 255;q[0] &= ~p;for (d = 0; d < g; d++) {
    q.push(n.charCodeAt(d));
  }q.push(188);return _zeroPaddingOfSignature(this.doPrivate(new BigInteger(q)).toString(16), this.n.bitLength());
};function _rsasign_getDecryptSignatureBI(a, d, c) {
  var b = new RSAKey();b.setPublic(d, c);var e = b.doPublic(a);return e;
}function _rsasign_getHexDigestInfoFromSig(a, c, b) {
  var e = _rsasign_getDecryptSignatureBI(a, c, b);var d = e.toString(16).replace(/^1f+00/, "");return d;
}function _rsasign_getAlgNameAndHashFromHexDisgestInfo(f) {
  for (var e in KJUR.crypto.Util.DIGESTINFOHEAD) {
    var d = KJUR.crypto.Util.DIGESTINFOHEAD[e];var b = d.length;if (f.substring(0, b) == d) {
      var c = [e, f.substring(b)];return c;
    }
  }return [];
}RSAKey.prototype.verify = function (f, j) {
  j = j.replace(_RE_HEXDECONLY, "");j = j.replace(/[ \n]+/g, "");var b = parseBigInt(j, 16);if (b.bitLength() > this.n.bitLength()) {
    return 0;
  }var i = this.doPublic(b);var e = i.toString(16).replace(/^1f+00/, "");var g = _rsasign_getAlgNameAndHashFromHexDisgestInfo(e);if (g.length == 0) {
    return false;
  }var d = g[0];var h = g[1];var a = function a(k) {
    return KJUR.crypto.Util.hashString(k, d);
  };var c = a(f);return h == c;
};RSAKey.prototype.verifyWithMessageHash = function (e, a) {
  a = a.replace(_RE_HEXDECONLY, "");a = a.replace(/[ \n]+/g, "");var b = parseBigInt(a, 16);if (b.bitLength() > this.n.bitLength()) {
    return 0;
  }var h = this.doPublic(b);var g = h.toString(16).replace(/^1f+00/, "");var c = _rsasign_getAlgNameAndHashFromHexDisgestInfo(g);if (c.length == 0) {
    return false;
  }var d = c[0];var f = c[1];return f == e;
};RSAKey.prototype.verifyPSS = function (c, b, a, f) {
  var e = function e(g) {
    return KJUR.crypto.Util.hashHex(g, a);
  };var d = e(rstrtohex(c));if (f === undefined) {
    f = -1;
  }return this.verifyWithMessageHashPSS(d, b, a, f);
};RSAKey.prototype.verifyWithMessageHashPSS = function (f, s, l, c) {
  var k = new BigInteger(s, 16);if (k.bitLength() > this.n.bitLength()) {
    return false;
  }var r = function r(i) {
    return KJUR.crypto.Util.hashHex(i, l);
  };var j = hextorstr(f);var h = j.length;var g = this.n.bitLength() - 1;var m = Math.ceil(g / 8);var q;if (c === -1 || c === undefined) {
    c = h;
  } else {
    if (c === -2) {
      c = m - h - 2;
    } else {
      if (c < -2) {
        throw "invalid salt length";
      }
    }
  }if (m < h + c + 2) {
    throw "data too long";
  }var a = this.doPublic(k).toByteArray();for (q = 0; q < a.length; q += 1) {
    a[q] &= 255;
  }while (a.length < m) {
    a.unshift(0);
  }if (a[m - 1] !== 188) {
    throw "encoded message does not end in 0xbc";
  }a = String.fromCharCode.apply(String, a);var d = a.substr(0, m - h - 1);var e = a.substr(d.length, h);var p = 65280 >> 8 * m - g & 255;if ((d.charCodeAt(0) & p) !== 0) {
    throw "bits beyond keysize not zero";
  }var n = pss_mgf1_str(e, d.length, r);var o = [];for (q = 0; q < d.length; q += 1) {
    o[q] = d.charCodeAt(q) ^ n.charCodeAt(q);
  }o[0] &= ~p;var b = m - h - c - 2;for (q = 0; q < b; q += 1) {
    if (o[q] !== 0) {
      throw "leftmost octets not zero";
    }
  }if (o[b] !== 1) {
    throw "0x01 marker not found";
  }return e === hextorstr(r(rstrtohex("\x00\x00\x00\x00\x00\x00\x00\x00" + j + String.fromCharCode.apply(String, o.slice(-c)))));
};RSAKey.SALT_LEN_HLEN = -1;RSAKey.SALT_LEN_MAX = -2;RSAKey.SALT_LEN_RECOVER = -2;
function X509() {
  var k = ASN1HEX,
      j = k.getChildIdx,
      h = k.getV,
      b = k.getTLV,
      f = k.getVbyList,
      c = k.getTLVbyList,
      g = k.getIdxbyList,
      d = k.getVidx,
      i = k.oidname,
      a = X509,
      e = pemtohex;this.hex = null;this.version = 0;this.foffset = 0;this.aExtInfo = null;this.getVersion = function () {
    if (this.hex === null || this.version !== 0) {
      return this.version;
    }if (c(this.hex, 0, [0, 0]) !== "a003020102") {
      this.version = 1;this.foffset = -1;return 1;
    }this.version = 3;return 3;
  };this.getSerialNumberHex = function () {
    return f(this.hex, 0, [0, 1 + this.foffset], "02");
  };this.getSignatureAlgorithmField = function () {
    return i(f(this.hex, 0, [0, 2 + this.foffset, 0], "06"));
  };this.getIssuerHex = function () {
    return c(this.hex, 0, [0, 3 + this.foffset], "30");
  };this.getIssuerString = function () {
    return a.hex2dn(this.getIssuerHex());
  };this.getSubjectHex = function () {
    return c(this.hex, 0, [0, 5 + this.foffset], "30");
  };this.getSubjectString = function () {
    return a.hex2dn(this.getSubjectHex());
  };this.getNotBefore = function () {
    var l = f(this.hex, 0, [0, 4 + this.foffset, 0]);l = l.replace(/(..)/g, "%$1");l = decodeURIComponent(l);return l;
  };this.getNotAfter = function () {
    var l = f(this.hex, 0, [0, 4 + this.foffset, 1]);l = l.replace(/(..)/g, "%$1");l = decodeURIComponent(l);return l;
  };this.getPublicKeyHex = function () {
    return k.getTLVbyList(this.hex, 0, [0, 6 + this.foffset], "30");
  };this.getPublicKeyIdx = function () {
    return g(this.hex, 0, [0, 6 + this.foffset], "30");
  };this.getPublicKeyContentIdx = function () {
    var l = this.getPublicKeyIdx();return g(this.hex, l, [1, 0], "30");
  };this.getPublicKey = function () {
    return KEYUTIL.getKey(this.getPublicKeyHex(), null, "pkcs8pub");
  };this.getSignatureAlgorithmName = function () {
    return i(f(this.hex, 0, [1, 0], "06"));
  };this.getSignatureValueHex = function () {
    return f(this.hex, 0, [2], "03", true);
  };this.verifySignature = function (n) {
    var o = this.getSignatureAlgorithmName();var l = this.getSignatureValueHex();var m = c(this.hex, 0, [0], "30");var p = new KJUR.crypto.Signature({ alg: o });p.init(n);p.updateHex(m);return p.verify(l);
  };this.parseExt = function () {
    if (this.version !== 3) {
      return -1;
    }var p = g(this.hex, 0, [0, 7, 0], "30");var m = j(this.hex, p);this.aExtInfo = new Array();for (var n = 0; n < m.length; n++) {
      var q = {};q.critical = false;var l = j(this.hex, m[n]);var r = 0;if (l.length === 3) {
        q.critical = true;r = 1;
      }q.oid = k.hextooidstr(f(this.hex, m[n], [0], "06"));var o = g(this.hex, m[n], [1 + r]);q.vidx = d(this.hex, o);this.aExtInfo.push(q);
    }
  };this.getExtInfo = function (n) {
    var l = this.aExtInfo;var o = n;if (!n.match(/^[0-9.]+$/)) {
      o = KJUR.asn1.x509.OID.name2oid(n);
    }if (o === "") {
      return undefined;
    }for (var m = 0; m < l.length; m++) {
      if (l[m].oid === o) {
        return l[m];
      }
    }return undefined;
  };this.getExtBasicConstraints = function () {
    var n = this.getExtInfo("basicConstraints");if (n === undefined) {
      return n;
    }var l = h(this.hex, n.vidx);if (l === "") {
      return {};
    }if (l === "0101ff") {
      return { cA: true };
    }if (l.substr(0, 8) === "0101ff02") {
      var o = h(l, 6);var m = parseInt(o, 16);return { cA: true, pathLen: m };
    }throw "basicConstraints parse error";
  };this.getExtKeyUsageBin = function () {
    var o = this.getExtInfo("keyUsage");if (o === undefined) {
      return "";
    }var m = h(this.hex, o.vidx);if (m.length % 2 != 0 || m.length <= 2) {
      throw "malformed key usage value";
    }var l = parseInt(m.substr(0, 2));var n = parseInt(m.substr(2), 16).toString(2);return n.substr(0, n.length - l);
  };this.getExtKeyUsageString = function () {
    var n = this.getExtKeyUsageBin();var l = new Array();for (var m = 0; m < n.length; m++) {
      if (n.substr(m, 1) == "1") {
        l.push(X509.KEYUSAGE_NAME[m]);
      }
    }return l.join(",");
  };this.getExtSubjectKeyIdentifier = function () {
    var l = this.getExtInfo("subjectKeyIdentifier");if (l === undefined) {
      return l;
    }return h(this.hex, l.vidx);
  };this.getExtAuthorityKeyIdentifier = function () {
    var p = this.getExtInfo("authorityKeyIdentifier");if (p === undefined) {
      return p;
    }var l = {};var o = b(this.hex, p.vidx);var m = j(o, 0);for (var n = 0; n < m.length; n++) {
      if (o.substr(m[n], 2) === "80") {
        l.kid = h(o, m[n]);
      }
    }return l;
  };this.getExtExtKeyUsageName = function () {
    var p = this.getExtInfo("extKeyUsage");if (p === undefined) {
      return p;
    }var l = new Array();var o = b(this.hex, p.vidx);if (o === "") {
      return l;
    }var m = j(o, 0);for (var n = 0; n < m.length; n++) {
      l.push(i(h(o, m[n])));
    }return l;
  };this.getExtSubjectAltName = function () {
    var m = this.getExtSubjectAltName2();var l = new Array();for (var n = 0; n < m.length; n++) {
      if (m[n][0] === "DNS") {
        l.push(m[n][1]);
      }
    }return l;
  };this.getExtSubjectAltName2 = function () {
    var p, s, r;var q = this.getExtInfo("subjectAltName");if (q === undefined) {
      return q;
    }var l = new Array();var o = b(this.hex, q.vidx);var m = j(o, 0);for (var n = 0; n < m.length; n++) {
      r = o.substr(m[n], 2);p = h(o, m[n]);if (r === "81") {
        s = hextoutf8(p);l.push(["MAIL", s]);
      }if (r === "82") {
        s = hextoutf8(p);l.push(["DNS", s]);
      }if (r === "84") {
        s = X509.hex2dn(p, 0);l.push(["DN", s]);
      }if (r === "86") {
        s = hextoutf8(p);l.push(["URI", s]);
      }if (r === "87") {
        s = hextoip(p);l.push(["IP", s]);
      }
    }return l;
  };this.getExtCRLDistributionPointsURI = function () {
    var q = this.getExtInfo("cRLDistributionPoints");if (q === undefined) {
      return q;
    }var l = new Array();var m = j(this.hex, q.vidx);for (var o = 0; o < m.length; o++) {
      try {
        var r = f(this.hex, m[o], [0, 0, 0], "86");var p = hextoutf8(r);l.push(p);
      } catch (n) {}
    }return l;
  };this.getExtAIAInfo = function () {
    var p = this.getExtInfo("authorityInfoAccess");if (p === undefined) {
      return p;
    }var l = { ocsp: [], caissuer: [] };var m = j(this.hex, p.vidx);for (var n = 0; n < m.length; n++) {
      var q = f(this.hex, m[n], [0], "06");var o = f(this.hex, m[n], [1], "86");if (q === "2b06010505073001") {
        l.ocsp.push(hextoutf8(o));
      }if (q === "2b06010505073002") {
        l.caissuer.push(hextoutf8(o));
      }
    }return l;
  };this.getExtCertificatePolicies = function () {
    var o = this.getExtInfo("certificatePolicies");if (o === undefined) {
      return o;
    }var l = b(this.hex, o.vidx);var u = [];var s = j(l, 0);for (var r = 0; r < s.length; r++) {
      var t = {};var n = j(l, s[r]);t.id = i(h(l, n[0]));if (n.length === 2) {
        var m = j(l, n[1]);for (var q = 0; q < m.length; q++) {
          var p = f(l, m[q], [0], "06");if (p === "2b06010505070201") {
            t.cps = hextoutf8(f(l, m[q], [1]));
          } else {
            if (p === "2b06010505070202") {
              t.unotice = hextoutf8(f(l, m[q], [1, 0]));
            }
          }
        }
      }u.push(t);
    }return u;
  };this.readCertPEM = function (l) {
    this.readCertHex(e(l));
  };this.readCertHex = function (l) {
    this.hex = l;this.getVersion();try {
      g(this.hex, 0, [0, 7], "a3");this.parseExt();
    } catch (m) {}
  };this.getInfo = function () {
    var m = X509;var B, u, z;B = "Basic Fields\n";B += "  serial number: " + this.getSerialNumberHex() + "\n";B += "  signature algorithm: " + this.getSignatureAlgorithmField() + "\n";B += "  issuer: " + this.getIssuerString() + "\n";B += "  notBefore: " + this.getNotBefore() + "\n";B += "  notAfter: " + this.getNotAfter() + "\n";B += "  subject: " + this.getSubjectString() + "\n";B += "  subject public key info: \n";u = this.getPublicKey();B += "    key algorithm: " + u.type + "\n";if (u.type === "RSA") {
      B += "    n=" + hextoposhex(u.n.toString(16)).substr(0, 16) + "...\n";B += "    e=" + hextoposhex(u.e.toString(16)) + "\n";
    }z = this.aExtInfo;if (z !== undefined && z !== null) {
      B += "X509v3 Extensions:\n";for (var r = 0; r < z.length; r++) {
        var n = z[r];var A = KJUR.asn1.x509.OID.oid2name(n.oid);if (A === "") {
          A = n.oid;
        }var x = "";if (n.critical === true) {
          x = "CRITICAL";
        }B += "  " + A + " " + x + ":\n";if (A === "basicConstraints") {
          var v = this.getExtBasicConstraints();if (v.cA === undefined) {
            B += "    {}\n";
          } else {
            B += "    cA=true";if (v.pathLen !== undefined) {
              B += ", pathLen=" + v.pathLen;
            }B += "\n";
          }
        } else {
          if (A === "keyUsage") {
            B += "    " + this.getExtKeyUsageString() + "\n";
          } else {
            if (A === "subjectKeyIdentifier") {
              B += "    " + this.getExtSubjectKeyIdentifier() + "\n";
            } else {
              if (A === "authorityKeyIdentifier") {
                var l = this.getExtAuthorityKeyIdentifier();if (l.kid !== undefined) {
                  B += "    kid=" + l.kid + "\n";
                }
              } else {
                if (A === "extKeyUsage") {
                  var w = this.getExtExtKeyUsageName();B += "    " + w.join(", ") + "\n";
                } else {
                  if (A === "subjectAltName") {
                    var t = this.getExtSubjectAltName2();B += "    " + t + "\n";
                  } else {
                    if (A === "cRLDistributionPoints") {
                      var y = this.getExtCRLDistributionPointsURI();B += "    " + y + "\n";
                    } else {
                      if (A === "authorityInfoAccess") {
                        var p = this.getExtAIAInfo();if (p.ocsp !== undefined) {
                          B += "    ocsp: " + p.ocsp.join(",") + "\n";
                        }if (p.caissuer !== undefined) {
                          B += "    caissuer: " + p.caissuer.join(",") + "\n";
                        }
                      } else {
                        if (A === "certificatePolicies") {
                          var o = this.getExtCertificatePolicies();for (var q = 0; q < o.length; q++) {
                            if (o[q].id !== undefined) {
                              B += "    policy oid: " + o[q].id + "\n";
                            }if (o[q].cps !== undefined) {
                              B += "    cps: " + o[q].cps + "\n";
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }B += "signature algorithm: " + this.getSignatureAlgorithmName() + "\n";B += "signature: " + this.getSignatureValueHex().substr(0, 16) + "...\n";return B;
  };
}X509.hex2dn = function (f, b) {
  if (b === undefined) {
    b = 0;
  }if (f.substr(b, 2) !== "30") {
    throw "malformed DN";
  }var c = new Array();var d = ASN1HEX.getChildIdx(f, b);for (var e = 0; e < d.length; e++) {
    c.push(X509.hex2rdn(f, d[e]));
  }c = c.map(function (a) {
    return a.replace("/", "\\/");
  });return "/" + c.join("/");
};X509.hex2rdn = function (f, b) {
  if (b === undefined) {
    b = 0;
  }if (f.substr(b, 2) !== "31") {
    throw "malformed RDN";
  }var c = new Array();var d = ASN1HEX.getChildIdx(f, b);for (var e = 0; e < d.length; e++) {
    c.push(X509.hex2attrTypeValue(f, d[e]));
  }c = c.map(function (a) {
    return a.replace("+", "\\+");
  });return c.join("+");
};X509.hex2attrTypeValue = function (d, i) {
  var j = ASN1HEX;var h = j.getV;if (i === undefined) {
    i = 0;
  }if (d.substr(i, 2) !== "30") {
    throw "malformed attribute type and value";
  }var g = j.getChildIdx(d, i);if (g.length !== 2 || d.substr(g[0], 2) !== "06") {
    "malformed attribute type and value";
  }var b = h(d, g[0]);var f = KJUR.asn1.ASN1Util.oidHexToInt(b);var e = KJUR.asn1.x509.OID.oid2atype(f);var a = h(d, g[1]);var c = hextorstr(a);return e + "=" + c;
};X509.getPublicKeyFromCertHex = function (b) {
  var a = new X509();a.readCertHex(b);return a.getPublicKey();
};X509.getPublicKeyFromCertPEM = function (b) {
  var a = new X509();a.readCertPEM(b);return a.getPublicKey();
};X509.getPublicKeyInfoPropOfCertPEM = function (c) {
  var e = ASN1HEX;var g = e.getVbyList;var b = {};var a, f, d;b.algparam = null;a = new X509();a.readCertPEM(c);f = a.getPublicKeyHex();b.keyhex = g(f, 0, [1], "03").substr(2);b.algoid = g(f, 0, [0, 0], "06");if (b.algoid === "2a8648ce3d0201") {
    b.algparam = g(f, 0, [0, 1], "06");
  }return b;
};X509.KEYUSAGE_NAME = ["digitalSignature", "nonRepudiation", "keyEncipherment", "dataEncipherment", "keyAgreement", "keyCertSign", "cRLSign", "encipherOnly", "decipherOnly"];
if (typeof KJUR == "undefined" || !KJUR) {
  exports.KJUR = KJUR = {};
}if (typeof KJUR.jws == "undefined" || !KJUR.jws) {
  KJUR.jws = {};
}KJUR.jws.JWS = function () {
  var b = KJUR,
      a = b.jws.JWS,
      c = a.isSafeJSONString;this.parseJWS = function (g, j) {
    if (this.parsedJWS !== undefined && (j || this.parsedJWS.sigvalH !== undefined)) {
      return;
    }var i = g.match(/^([^.]+)\.([^.]+)\.([^.]+)$/);if (i == null) {
      throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
    }var k = i[1];var e = i[2];var l = i[3];var n = k + "." + e;this.parsedJWS = {};this.parsedJWS.headB64U = k;this.parsedJWS.payloadB64U = e;this.parsedJWS.sigvalB64U = l;this.parsedJWS.si = n;if (!j) {
      var h = b64utohex(l);var f = parseBigInt(h, 16);this.parsedJWS.sigvalH = h;this.parsedJWS.sigvalBI = f;
    }var d = b64utoutf8(k);var m = b64utoutf8(e);this.parsedJWS.headS = d;this.parsedJWS.payloadS = m;if (!c(d, this.parsedJWS, "headP")) {
      throw "malformed JSON string for JWS Head: " + d;
    }
  };
};KJUR.jws.JWS.sign = function (i, v, y, z, a) {
  var w = KJUR,
      m = w.jws,
      q = m.JWS,
      g = q.readSafeJSONString,
      p = q.isSafeJSONString,
      d = w.crypto,
      k = d.ECDSA,
      o = d.Mac,
      c = d.Signature,
      t = JSON;var s, j, n;if (typeof v != "string" && (typeof v === "undefined" ? "undefined" : _typeof(v)) != "object") {
    throw "spHeader must be JSON string or object: " + v;
  }if ((typeof v === "undefined" ? "undefined" : _typeof(v)) == "object") {
    j = v;s = t.stringify(j);
  }if (typeof v == "string") {
    s = v;if (!p(s)) {
      throw "JWS Head is not safe JSON string: " + s;
    }j = g(s);
  }n = y;if ((typeof y === "undefined" ? "undefined" : _typeof(y)) == "object") {
    n = t.stringify(y);
  }if ((i == "" || i == null) && j.alg !== undefined) {
    i = j.alg;
  }if (i != "" && i != null && j.alg === undefined) {
    j.alg = i;s = t.stringify(j);
  }if (i !== j.alg) {
    throw "alg and sHeader.alg doesn't match: " + i + "!=" + j.alg;
  }var r = null;if (q.jwsalg2sigalg[i] === undefined) {
    throw "unsupported alg name: " + i;
  } else {
    r = q.jwsalg2sigalg[i];
  }var e = utf8tob64u(s);var l = utf8tob64u(n);var b = e + "." + l;var x = "";if (r.substr(0, 4) == "Hmac") {
    if (z === undefined) {
      throw "mac key shall be specified for HS* alg";
    }var h = new o({ alg: r, prov: "cryptojs", pass: z });h.updateString(b);x = h.doFinal();
  } else {
    if (r.indexOf("withECDSA") != -1) {
      var f = new c({ alg: r });f.init(z, a);f.updateString(b);hASN1Sig = f.sign();x = KJUR.crypto.ECDSA.asn1SigToConcatSig(hASN1Sig);
    } else {
      if (r != "none") {
        var f = new c({ alg: r });f.init(z, a);f.updateString(b);x = f.sign();
      }
    }
  }var u = hextob64u(x);return b + "." + u;
};KJUR.jws.JWS.verify = function (w, B, n) {
  var x = KJUR,
      q = x.jws,
      t = q.JWS,
      i = t.readSafeJSONString,
      e = x.crypto,
      p = e.ECDSA,
      s = e.Mac,
      d = e.Signature,
      m;if ((typeof RSAKey === "undefined" ? "undefined" : _typeof(RSAKey)) !== undefined) {
    m = RSAKey;
  }var y = w.split(".");if (y.length !== 3) {
    return false;
  }var f = y[0];var r = y[1];var c = f + "." + r;var A = b64utohex(y[2]);var l = i(b64utoutf8(y[0]));var k = null;var z = null;if (l.alg === undefined) {
    throw "algorithm not specified in header";
  } else {
    k = l.alg;z = k.substr(0, 2);
  }if (n != null && Object.prototype.toString.call(n) === "[object Array]" && n.length > 0) {
    var b = ":" + n.join(":") + ":";if (b.indexOf(":" + k + ":") == -1) {
      throw "algorithm '" + k + "' not accepted in the list";
    }
  }if (k != "none" && B === null) {
    throw "key shall be specified to verify.";
  }if (typeof B == "string" && B.indexOf("-----BEGIN ") != -1) {
    B = KEYUTIL.getKey(B);
  }if (z == "RS" || z == "PS") {
    if (!(B instanceof m)) {
      throw "key shall be a RSAKey obj for RS* and PS* algs";
    }
  }if (z == "ES") {
    if (!(B instanceof p)) {
      throw "key shall be a ECDSA obj for ES* algs";
    }
  }if (k == "none") {}var u = null;if (t.jwsalg2sigalg[l.alg] === undefined) {
    throw "unsupported alg name: " + k;
  } else {
    u = t.jwsalg2sigalg[k];
  }if (u == "none") {
    throw "not supported";
  } else {
    if (u.substr(0, 4) == "Hmac") {
      var o = null;if (B === undefined) {
        throw "hexadecimal key shall be specified for HMAC";
      }var j = new s({ alg: u, pass: B });j.updateString(c);o = j.doFinal();return A == o;
    } else {
      if (u.indexOf("withECDSA") != -1) {
        var h = null;try {
          h = p.concatSigToASN1Sig(A);
        } catch (v) {
          return false;
        }var g = new d({ alg: u });g.init(B);g.updateString(c);return g.verify(h);
      } else {
        var g = new d({ alg: u });g.init(B);g.updateString(c);return g.verify(A);
      }
    }
  }
};KJUR.jws.JWS.parse = function (g) {
  var c = g.split(".");var b = {};var f, e, d;if (c.length != 2 && c.length != 3) {
    throw "malformed sJWS: wrong number of '.' splitted elements";
  }f = c[0];e = c[1];if (c.length == 3) {
    d = c[2];
  }b.headerObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(f));b.payloadObj = KJUR.jws.JWS.readSafeJSONString(b64utoutf8(e));b.headerPP = JSON.stringify(b.headerObj, null, "  ");if (b.payloadObj == null) {
    b.payloadPP = b64utoutf8(e);
  } else {
    b.payloadPP = JSON.stringify(b.payloadObj, null, "  ");
  }if (d !== undefined) {
    b.sigHex = b64utohex(d);
  }return b;
};KJUR.jws.JWS.verifyJWT = function (e, l, r) {
  var d = KJUR,
      j = d.jws,
      o = j.JWS,
      n = o.readSafeJSONString,
      p = o.inArray,
      f = o.includedArray;var k = e.split(".");var c = k[0];var i = k[1];var q = c + "." + i;var m = b64utohex(k[2]);var h = n(b64utoutf8(c));var g = n(b64utoutf8(i));if (h.alg === undefined) {
    return false;
  }if (r.alg === undefined) {
    throw "acceptField.alg shall be specified";
  }if (!p(h.alg, r.alg)) {
    return false;
  }if (g.iss !== undefined && _typeof(r.iss) === "object") {
    if (!p(g.iss, r.iss)) {
      return false;
    }
  }if (g.sub !== undefined && _typeof(r.sub) === "object") {
    if (!p(g.sub, r.sub)) {
      return false;
    }
  }if (g.aud !== undefined && _typeof(r.aud) === "object") {
    if (typeof g.aud == "string") {
      if (!p(g.aud, r.aud)) {
        return false;
      }
    } else {
      if (_typeof(g.aud) == "object") {
        if (!f(g.aud, r.aud)) {
          return false;
        }
      }
    }
  }var b = j.IntDate.getNow();if (r.verifyAt !== undefined && typeof r.verifyAt === "number") {
    b = r.verifyAt;
  }if (r.gracePeriod === undefined || typeof r.gracePeriod !== "number") {
    r.gracePeriod = 0;
  }if (g.exp !== undefined && typeof g.exp == "number") {
    if (g.exp + r.gracePeriod < b) {
      return false;
    }
  }if (g.nbf !== undefined && typeof g.nbf == "number") {
    if (b < g.nbf - r.gracePeriod) {
      return false;
    }
  }if (g.iat !== undefined && typeof g.iat == "number") {
    if (b < g.iat - r.gracePeriod) {
      return false;
    }
  }if (g.jti !== undefined && r.jti !== undefined) {
    if (g.jti !== r.jti) {
      return false;
    }
  }if (!o.verify(e, l, r.alg)) {
    return false;
  }return true;
};KJUR.jws.JWS.includedArray = function (b, a) {
  var c = KJUR.jws.JWS.inArray;if (b === null) {
    return false;
  }if ((typeof b === "undefined" ? "undefined" : _typeof(b)) !== "object") {
    return false;
  }if (typeof b.length !== "number") {
    return false;
  }for (var d = 0; d < b.length; d++) {
    if (!c(b[d], a)) {
      return false;
    }
  }return true;
};KJUR.jws.JWS.inArray = function (d, b) {
  if (b === null) {
    return false;
  }if ((typeof b === "undefined" ? "undefined" : _typeof(b)) !== "object") {
    return false;
  }if (typeof b.length !== "number") {
    return false;
  }for (var c = 0; c < b.length; c++) {
    if (b[c] == d) {
      return true;
    }
  }return false;
};KJUR.jws.JWS.jwsalg2sigalg = { HS256: "HmacSHA256", HS384: "HmacSHA384", HS512: "HmacSHA512", RS256: "SHA256withRSA", RS384: "SHA384withRSA", RS512: "SHA512withRSA", ES256: "SHA256withECDSA", ES384: "SHA384withECDSA", PS256: "SHA256withRSAandMGF1", PS384: "SHA384withRSAandMGF1", PS512: "SHA512withRSAandMGF1", none: "none" };KJUR.jws.JWS.isSafeJSONString = function (c, b, d) {
  var e = null;try {
    e = jsonParse(c);if ((typeof e === "undefined" ? "undefined" : _typeof(e)) != "object") {
      return 0;
    }if (e.constructor === Array) {
      return 0;
    }if (b) {
      b[d] = e;
    }return 1;
  } catch (a) {
    return 0;
  }
};KJUR.jws.JWS.readSafeJSONString = function (b) {
  var c = null;try {
    c = jsonParse(b);if ((typeof c === "undefined" ? "undefined" : _typeof(c)) != "object") {
      return null;
    }if (c.constructor === Array) {
      return null;
    }return c;
  } catch (a) {
    return null;
  }
};KJUR.jws.JWS.getEncodedSignatureValueFromJWS = function (b) {
  var a = b.match(/^[^.]+\.[^.]+\.([^.]+)$/);if (a == null) {
    throw "JWS signature is not a form of 'Head.Payload.SigValue'.";
  }return a[1];
};KJUR.jws.JWS.getJWKthumbprint = function (d) {
  if (d.kty !== "RSA" && d.kty !== "EC" && d.kty !== "oct") {
    throw "unsupported algorithm for JWK Thumprint";
  }var a = "{";if (d.kty === "RSA") {
    if (typeof d.n != "string" || typeof d.e != "string") {
      throw "wrong n and e value for RSA key";
    }a += '"e":"' + d.e + '",';a += '"kty":"' + d.kty + '",';a += '"n":"' + d.n + '"}';
  } else {
    if (d.kty === "EC") {
      if (typeof d.crv != "string" || typeof d.x != "string" || typeof d.y != "string") {
        throw "wrong crv, x and y value for EC key";
      }a += '"crv":"' + d.crv + '",';a += '"kty":"' + d.kty + '",';a += '"x":"' + d.x + '",';a += '"y":"' + d.y + '"}';
    } else {
      if (d.kty === "oct") {
        if (typeof d.k != "string") {
          throw "wrong k value for oct(symmetric) key";
        }a += '"kty":"' + d.kty + '",';a += '"k":"' + d.k + '"}';
      }
    }
  }var b = rstrtohex(a);var c = KJUR.crypto.Util.hashHex(b, "sha256");var e = hextob64u(c);return e;
};KJUR.jws.IntDate = {};KJUR.jws.IntDate.get = function (c) {
  var b = KJUR.jws.IntDate,
      d = b.getNow,
      a = b.getZulu;if (c == "now") {
    return d();
  } else {
    if (c == "now + 1hour") {
      return d() + 60 * 60;
    } else {
      if (c == "now + 1day") {
        return d() + 60 * 60 * 24;
      } else {
        if (c == "now + 1month") {
          return d() + 60 * 60 * 24 * 30;
        } else {
          if (c == "now + 1year") {
            return d() + 60 * 60 * 24 * 365;
          } else {
            if (c.match(/Z$/)) {
              return a(c);
            } else {
              if (c.match(/^[0-9]+$/)) {
                return parseInt(c);
              }
            }
          }
        }
      }
    }
  }throw "unsupported format: " + c;
};KJUR.jws.IntDate.getZulu = function (a) {
  return zulutosec(a);
};KJUR.jws.IntDate.getNow = function () {
  var a = ~~(new Date() / 1000);return a;
};KJUR.jws.IntDate.intDate2UTCString = function (a) {
  var b = new Date(a * 1000);return b.toUTCString();
};KJUR.jws.IntDate.intDate2Zulu = function (e) {
  var i = new Date(e * 1000),
      h = ("0000" + i.getUTCFullYear()).slice(-4),
      g = ("00" + (i.getUTCMonth() + 1)).slice(-2),
      b = ("00" + i.getUTCDate()).slice(-2),
      a = ("00" + i.getUTCHours()).slice(-2),
      c = ("00" + i.getUTCMinutes()).slice(-2),
      f = ("00" + i.getUTCSeconds()).slice(-2);return h + g + b + a + c + f + "Z";
};
exports.SecureRandom = SecureRandom;
exports.rng_seed_time = rng_seed_time;
exports.BigInteger = BigInteger;
exports.RSAKey = RSAKey;
var EDSA = KJUR.crypto.EDSA;
exports.EDSA = EDSA;
var DSA = KJUR.crypto.DSA;
exports.DSA = DSA;
var Signature = KJUR.crypto.Signature;
exports.Signature = Signature;
var MessageDigest = KJUR.crypto.MessageDigest;
exports.MessageDigest = MessageDigest;
var Mac = KJUR.crypto.Mac;
exports.Mac = Mac;
var Cipher = KJUR.crypto.Cipher;
exports.Cipher = Cipher;
exports.KEYUTIL = KEYUTIL;
exports.ASN1HEX = ASN1HEX;
exports.X509 = X509;
exports.CryptoJS = CryptoJS;

// ext/base64.js

exports.b64tohex = b64tohex;
exports.b64toBA = b64toBA;

// base64x.js

exports.stoBA = stoBA;
exports.BAtos = BAtos;
exports.BAtohex = BAtohex;
exports.stohex = stohex;
exports.stob64 = stob64;
exports.stob64u = stob64u;
exports.b64utos = b64utos;
exports.b64tob64u = b64tob64u;
exports.b64utob64 = b64utob64;
exports.hex2b64 = hex2b64;
exports.hextob64u = hextob64u;
exports.b64utohex = b64utohex;
exports.utf8tob64u = utf8tob64u;
exports.b64utoutf8 = b64utoutf8;
exports.utf8tob64 = utf8tob64;
exports.b64toutf8 = b64toutf8;
exports.utf8tohex = utf8tohex;
exports.hextoutf8 = hextoutf8;
exports.hextorstr = hextorstr;
exports.rstrtohex = rstrtohex;
exports.hextob64 = hextob64;
exports.hextob64nl = hextob64nl;
exports.b64nltohex = b64nltohex;
exports.hextopem = hextopem;
exports.pemtohex = pemtohex;
exports.hextoArrayBuffer = hextoArrayBuffer;
exports.ArrayBuffertohex = ArrayBuffertohex;
exports.zulutomsec = zulutomsec;
exports.zulutosec = zulutosec;
exports.zulutodate = zulutodate;
exports.datetozulu = datetozulu;
exports.uricmptohex = uricmptohex;
exports.hextouricmp = hextouricmp;
exports.ipv6tohex = ipv6tohex;
exports.hextoipv6 = hextoipv6;
exports.hextoip = hextoip;
exports.iptohex = iptohex;
exports.encodeURIComponentAll = encodeURIComponentAll;
exports.newline_toUnix = newline_toUnix;
exports.newline_toDos = newline_toDos;
exports.hextoposhex = hextoposhex;
exports.intarystrtohex = intarystrtohex;
exports.strdiffidx = strdiffidx;

// name spaces

exports.KJUR = KJUR;

var _crypto = KJUR.crypto;
exports.crypto = _crypto;
var _KJUR = KJUR;
var asn1 = _KJUR.asn1;
exports.asn1 = asn1;
var _KJUR2 = KJUR;
var jws = _KJUR2.jws;
exports.jws = jws;
var _KJUR3 = KJUR;
var lang = _KJUR3.lang;
exports.lang = lang;
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node_modules/buffer/index.js */ "./node_modules/buffer/index.js").Buffer))

/***/ }),

/***/ "./node_modules/babel-polyfill/lib/index.js":
/*!**************************************************!*\
  !*** ./node_modules/babel-polyfill/lib/index.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {

__webpack_require__(/*! core-js/shim */ "./node_modules/core-js/shim.js");

__webpack_require__(/*! regenerator-runtime/runtime */ "./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js");

__webpack_require__(/*! core-js/fn/regexp/escape */ "./node_modules/core-js/fn/regexp/escape.js");

if (global._babelPolyfill) {
  throw new Error("only one instance of babel-polyfill is allowed");
}
global._babelPolyfill = true;

var DEFINE_PROPERTY = "defineProperty";
function define(O, key, value) {
  O[key] || Object[DEFINE_PROPERTY](O, key, {
    writable: true,
    configurable: true,
    value: value
  });
}

define(String.prototype, "padLeft", "".padStart);
define(String.prototype, "padRight", "".padEnd);

"pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill".split(",").forEach(function (key) {
  [][key] && define(Array, key, Function.call.bind([][key]));
});
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js":
/*!*********************************************************************************!*\
  !*** ./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js ***!
  \*********************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

/* WEBPACK VAR INJECTION */(function(global) {/**
 * Copyright (c) 2014, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * https://raw.github.com/facebook/regenerator/master/LICENSE file. An
 * additional grant of patent rights can be found in the PATENTS file in
 * the same directory.
 */

!(function(global) {
  "use strict";

  var Op = Object.prototype;
  var hasOwn = Op.hasOwnProperty;
  var undefined; // More compressible than void 0.
  var $Symbol = typeof Symbol === "function" ? Symbol : {};
  var iteratorSymbol = $Symbol.iterator || "@@iterator";
  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

  var inModule = typeof module === "object";
  var runtime = global.regeneratorRuntime;
  if (runtime) {
    if (inModule) {
      // If regeneratorRuntime is defined globally and we're in a module,
      // make the exports object identical to regeneratorRuntime.
      module.exports = runtime;
    }
    // Don't bother evaluating the rest of this file if the runtime was
    // already defined globally.
    return;
  }

  // Define the runtime globally (as expected by generated code) as either
  // module.exports (if we're in a module) or a new, empty object.
  runtime = global.regeneratorRuntime = inModule ? module.exports : {};

  function wrap(innerFn, outerFn, self, tryLocsList) {
    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
    var generator = Object.create(protoGenerator.prototype);
    var context = new Context(tryLocsList || []);

    // The ._invoke method unifies the implementations of the .next,
    // .throw, and .return methods.
    generator._invoke = makeInvokeMethod(innerFn, self, context);

    return generator;
  }
  runtime.wrap = wrap;

  // Try/catch helper to minimize deoptimizations. Returns a completion
  // record like context.tryEntries[i].completion. This interface could
  // have been (and was previously) designed to take a closure to be
  // invoked without arguments, but in all the cases we care about we
  // already have an existing method we want to call, so there's no need
  // to create a new function object. We can even get away with assuming
  // the method takes exactly one argument, since that happens to be true
  // in every case, so we don't have to touch the arguments object. The
  // only additional allocation required is the completion record, which
  // has a stable shape and so hopefully should be cheap to allocate.
  function tryCatch(fn, obj, arg) {
    try {
      return { type: "normal", arg: fn.call(obj, arg) };
    } catch (err) {
      return { type: "throw", arg: err };
    }
  }

  var GenStateSuspendedStart = "suspendedStart";
  var GenStateSuspendedYield = "suspendedYield";
  var GenStateExecuting = "executing";
  var GenStateCompleted = "completed";

  // Returning this object from the innerFn has the same effect as
  // breaking out of the dispatch switch statement.
  var ContinueSentinel = {};

  // Dummy constructor functions that we use as the .constructor and
  // .constructor.prototype properties for functions that return Generator
  // objects. For full spec compliance, you may wish to configure your
  // minifier not to mangle the names of these two functions.
  function Generator() {}
  function GeneratorFunction() {}
  function GeneratorFunctionPrototype() {}

  // This is a polyfill for %IteratorPrototype% for environments that
  // don't natively support it.
  var IteratorPrototype = {};
  IteratorPrototype[iteratorSymbol] = function () {
    return this;
  };

  var getProto = Object.getPrototypeOf;
  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
  if (NativeIteratorPrototype &&
      NativeIteratorPrototype !== Op &&
      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
    // This environment has a native %IteratorPrototype%; use it instead
    // of the polyfill.
    IteratorPrototype = NativeIteratorPrototype;
  }

  var Gp = GeneratorFunctionPrototype.prototype =
    Generator.prototype = Object.create(IteratorPrototype);
  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
  GeneratorFunctionPrototype.constructor = GeneratorFunction;
  GeneratorFunctionPrototype[toStringTagSymbol] =
    GeneratorFunction.displayName = "GeneratorFunction";

  // Helper for defining the .next, .throw, and .return methods of the
  // Iterator interface in terms of a single ._invoke method.
  function defineIteratorMethods(prototype) {
    ["next", "throw", "return"].forEach(function(method) {
      prototype[method] = function(arg) {
        return this._invoke(method, arg);
      };
    });
  }

  runtime.isGeneratorFunction = function(genFun) {
    var ctor = typeof genFun === "function" && genFun.constructor;
    return ctor
      ? ctor === GeneratorFunction ||
        // For the native GeneratorFunction constructor, the best we can
        // do is to check its .name property.
        (ctor.displayName || ctor.name) === "GeneratorFunction"
      : false;
  };

  runtime.mark = function(genFun) {
    if (Object.setPrototypeOf) {
      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
    } else {
      genFun.__proto__ = GeneratorFunctionPrototype;
      if (!(toStringTagSymbol in genFun)) {
        genFun[toStringTagSymbol] = "GeneratorFunction";
      }
    }
    genFun.prototype = Object.create(Gp);
    return genFun;
  };

  // Within the body of any async function, `await x` is transformed to
  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
  // `hasOwn.call(value, "__await")` to determine if the yielded value is
  // meant to be awaited.
  runtime.awrap = function(arg) {
    return { __await: arg };
  };

  function AsyncIterator(generator) {
    function invoke(method, arg, resolve, reject) {
      var record = tryCatch(generator[method], generator, arg);
      if (record.type === "throw") {
        reject(record.arg);
      } else {
        var result = record.arg;
        var value = result.value;
        if (value &&
            typeof value === "object" &&
            hasOwn.call(value, "__await")) {
          return Promise.resolve(value.__await).then(function(value) {
            invoke("next", value, resolve, reject);
          }, function(err) {
            invoke("throw", err, resolve, reject);
          });
        }

        return Promise.resolve(value).then(function(unwrapped) {
          // When a yielded Promise is resolved, its final value becomes
          // the .value of the Promise<{value,done}> result for the
          // current iteration. If the Promise is rejected, however, the
          // result for this iteration will be rejected with the same
          // reason. Note that rejections of yielded Promises are not
          // thrown back into the generator function, as is the case
          // when an awaited Promise is rejected. This difference in
          // behavior between yield and await is important, because it
          // allows the consumer to decide what to do with the yielded
          // rejection (swallow it and continue, manually .throw it back
          // into the generator, abandon iteration, whatever). With
          // await, by contrast, there is no opportunity to examine the
          // rejection reason outside the generator function, so the
          // only option is to throw it from the await expression, and
          // let the generator function handle the exception.
          result.value = unwrapped;
          resolve(result);
        }, reject);
      }
    }

    if (typeof global.process === "object" && global.process.domain) {
      invoke = global.process.domain.bind(invoke);
    }

    var previousPromise;

    function enqueue(method, arg) {
      function callInvokeWithMethodAndArg() {
        return new Promise(function(resolve, reject) {
          invoke(method, arg, resolve, reject);
        });
      }

      return previousPromise =
        // If enqueue has been called before, then we want to wait until
        // all previous Promises have been resolved before calling invoke,
        // so that results are always delivered in the correct order. If
        // enqueue has not been called before, then it is important to
        // call invoke immediately, without waiting on a callback to fire,
        // so that the async generator function has the opportunity to do
        // any necessary setup in a predictable way. This predictability
        // is why the Promise constructor synchronously invokes its
        // executor callback, and why async functions synchronously
        // execute code before the first await. Since we implement simple
        // async functions in terms of async generators, it is especially
        // important to get this right, even though it requires care.
        previousPromise ? previousPromise.then(
          callInvokeWithMethodAndArg,
          // Avoid propagating failures to Promises returned by later
          // invocations of the iterator.
          callInvokeWithMethodAndArg
        ) : callInvokeWithMethodAndArg();
    }

    // Define the unified helper method that is used to implement .next,
    // .throw, and .return (see defineIteratorMethods).
    this._invoke = enqueue;
  }

  defineIteratorMethods(AsyncIterator.prototype);
  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
    return this;
  };
  runtime.AsyncIterator = AsyncIterator;

  // Note that simple async functions are implemented on top of
  // AsyncIterator objects; they just return a Promise for the value of
  // the final result produced by the iterator.
  runtime.async = function(innerFn, outerFn, self, tryLocsList) {
    var iter = new AsyncIterator(
      wrap(innerFn, outerFn, self, tryLocsList)
    );

    return runtime.isGeneratorFunction(outerFn)
      ? iter // If outerFn is a generator, return the full iterator.
      : iter.next().then(function(result) {
          return result.done ? result.value : iter.next();
        });
  };

  function makeInvokeMethod(innerFn, self, context) {
    var state = GenStateSuspendedStart;

    return function invoke(method, arg) {
      if (state === GenStateExecuting) {
        throw new Error("Generator is already running");
      }

      if (state === GenStateCompleted) {
        if (method === "throw") {
          throw arg;
        }

        // Be forgiving, per 25.3.3.3.3 of the spec:
        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
        return doneResult();
      }

      context.method = method;
      context.arg = arg;

      while (true) {
        var delegate = context.delegate;
        if (delegate) {
          var delegateResult = maybeInvokeDelegate(delegate, context);
          if (delegateResult) {
            if (delegateResult === ContinueSentinel) continue;
            return delegateResult;
          }
        }

        if (context.method === "next") {
          // Setting context._sent for legacy support of Babel's
          // function.sent implementation.
          context.sent = context._sent = context.arg;

        } else if (context.method === "throw") {
          if (state === GenStateSuspendedStart) {
            state = GenStateCompleted;
            throw context.arg;
          }

          context.dispatchException(context.arg);

        } else if (context.method === "return") {
          context.abrupt("return", context.arg);
        }

        state = GenStateExecuting;

        var record = tryCatch(innerFn, self, context);
        if (record.type === "normal") {
          // If an exception is thrown from innerFn, we leave state ===
          // GenStateExecuting and loop back for another invocation.
          state = context.done
            ? GenStateCompleted
            : GenStateSuspendedYield;

          if (record.arg === ContinueSentinel) {
            continue;
          }

          return {
            value: record.arg,
            done: context.done
          };

        } else if (record.type === "throw") {
          state = GenStateCompleted;
          // Dispatch the exception by looping back around to the
          // context.dispatchException(context.arg) call above.
          context.method = "throw";
          context.arg = record.arg;
        }
      }
    };
  }

  // Call delegate.iterator[context.method](context.arg) and handle the
  // result, either by returning a { value, done } result from the
  // delegate iterator, or by modifying context.method and context.arg,
  // setting context.delegate to null, and returning the ContinueSentinel.
  function maybeInvokeDelegate(delegate, context) {
    var method = delegate.iterator[context.method];
    if (method === undefined) {
      // A .throw or .return when the delegate iterator has no .throw
      // method always terminates the yield* loop.
      context.delegate = null;

      if (context.method === "throw") {
        if (delegate.iterator.return) {
          // If the delegate iterator has a return method, give it a
          // chance to clean up.
          context.method = "return";
          context.arg = undefined;
          maybeInvokeDelegate(delegate, context);

          if (context.method === "throw") {
            // If maybeInvokeDelegate(context) changed context.method from
            // "return" to "throw", let that override the TypeError below.
            return ContinueSentinel;
          }
        }

        context.method = "throw";
        context.arg = new TypeError(
          "The iterator does not provide a 'throw' method");
      }

      return ContinueSentinel;
    }

    var record = tryCatch(method, delegate.iterator, context.arg);

    if (record.type === "throw") {
      context.method = "throw";
      context.arg = record.arg;
      context.delegate = null;
      return ContinueSentinel;
    }

    var info = record.arg;

    if (! info) {
      context.method = "throw";
      context.arg = new TypeError("iterator result is not an object");
      context.delegate = null;
      return ContinueSentinel;
    }

    if (info.done) {
      // Assign the result of the finished delegate to the temporary
      // variable specified by delegate.resultName (see delegateYield).
      context[delegate.resultName] = info.value;

      // Resume execution at the desired location (see delegateYield).
      context.next = delegate.nextLoc;

      // If context.method was "throw" but the delegate handled the
      // exception, let the outer generator proceed normally. If
      // context.method was "next", forget context.arg since it has been
      // "consumed" by the delegate iterator. If context.method was
      // "return", allow the original .return call to continue in the
      // outer generator.
      if (context.method !== "return") {
        context.method = "next";
        context.arg = undefined;
      }

    } else {
      // Re-yield the result returned by the delegate method.
      return info;
    }

    // The delegate iterator is finished, so forget it and continue with
    // the outer generator.
    context.delegate = null;
    return ContinueSentinel;
  }

  // Define Generator.prototype.{next,throw,return} in terms of the
  // unified ._invoke helper method.
  defineIteratorMethods(Gp);

  Gp[toStringTagSymbol] = "Generator";

  // A Generator should always return itself as the iterator object when the
  // @@iterator function is called on it. Some browsers' implementations of the
  // iterator prototype chain incorrectly implement this, causing the Generator
  // object to not be returned from this call. This ensures that doesn't happen.
  // See https://github.com/facebook/regenerator/issues/274 for more details.
  Gp[iteratorSymbol] = function() {
    return this;
  };

  Gp.toString = function() {
    return "[object Generator]";
  };

  function pushTryEntry(locs) {
    var entry = { tryLoc: locs[0] };

    if (1 in locs) {
      entry.catchLoc = locs[1];
    }

    if (2 in locs) {
      entry.finallyLoc = locs[2];
      entry.afterLoc = locs[3];
    }

    this.tryEntries.push(entry);
  }

  function resetTryEntry(entry) {
    var record = entry.completion || {};
    record.type = "normal";
    delete record.arg;
    entry.completion = record;
  }

  function Context(tryLocsList) {
    // The root entry object (effectively a try statement without a catch
    // or a finally block) gives us a place to store values thrown from
    // locations where there is no enclosing try statement.
    this.tryEntries = [{ tryLoc: "root" }];
    tryLocsList.forEach(pushTryEntry, this);
    this.reset(true);
  }

  runtime.keys = function(object) {
    var keys = [];
    for (var key in object) {
      keys.push(key);
    }
    keys.reverse();

    // Rather than returning an object with a next method, we keep
    // things simple and return the next function itself.
    return function next() {
      while (keys.length) {
        var key = keys.pop();
        if (key in object) {
          next.value = key;
          next.done = false;
          return next;
        }
      }

      // To avoid creating an additional object, we just hang the .value
      // and .done properties off the next function object itself. This
      // also ensures that the minifier will not anonymize the function.
      next.done = true;
      return next;
    };
  };

  function values(iterable) {
    if (iterable) {
      var iteratorMethod = iterable[iteratorSymbol];
      if (iteratorMethod) {
        return iteratorMethod.call(iterable);
      }

      if (typeof iterable.next === "function") {
        return iterable;
      }

      if (!isNaN(iterable.length)) {
        var i = -1, next = function next() {
          while (++i < iterable.length) {
            if (hasOwn.call(iterable, i)) {
              next.value = iterable[i];
              next.done = false;
              return next;
            }
          }

          next.value = undefined;
          next.done = true;

          return next;
        };

        return next.next = next;
      }
    }

    // Return an iterator with no values.
    return { next: doneResult };
  }
  runtime.values = values;

  function doneResult() {
    return { value: undefined, done: true };
  }

  Context.prototype = {
    constructor: Context,

    reset: function(skipTempReset) {
      this.prev = 0;
      this.next = 0;
      // Resetting context._sent for legacy support of Babel's
      // function.sent implementation.
      this.sent = this._sent = undefined;
      this.done = false;
      this.delegate = null;

      this.method = "next";
      this.arg = undefined;

      this.tryEntries.forEach(resetTryEntry);

      if (!skipTempReset) {
        for (var name in this) {
          // Not sure about the optimal order of these conditions:
          if (name.charAt(0) === "t" &&
              hasOwn.call(this, name) &&
              !isNaN(+name.slice(1))) {
            this[name] = undefined;
          }
        }
      }
    },

    stop: function() {
      this.done = true;

      var rootEntry = this.tryEntries[0];
      var rootRecord = rootEntry.completion;
      if (rootRecord.type === "throw") {
        throw rootRecord.arg;
      }

      return this.rval;
    },

    dispatchException: function(exception) {
      if (this.done) {
        throw exception;
      }

      var context = this;
      function handle(loc, caught) {
        record.type = "throw";
        record.arg = exception;
        context.next = loc;

        if (caught) {
          // If the dispatched exception was caught by a catch block,
          // then let that catch block handle the exception normally.
          context.method = "next";
          context.arg = undefined;
        }

        return !! caught;
      }

      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        var record = entry.completion;

        if (entry.tryLoc === "root") {
          // Exception thrown outside of any try block that could handle
          // it, so set the completion value of the entire function to
          // throw the exception.
          return handle("end");
        }

        if (entry.tryLoc <= this.prev) {
          var hasCatch = hasOwn.call(entry, "catchLoc");
          var hasFinally = hasOwn.call(entry, "finallyLoc");

          if (hasCatch && hasFinally) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            } else if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else if (hasCatch) {
            if (this.prev < entry.catchLoc) {
              return handle(entry.catchLoc, true);
            }

          } else if (hasFinally) {
            if (this.prev < entry.finallyLoc) {
              return handle(entry.finallyLoc);
            }

          } else {
            throw new Error("try statement without catch or finally");
          }
        }
      }
    },

    abrupt: function(type, arg) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc <= this.prev &&
            hasOwn.call(entry, "finallyLoc") &&
            this.prev < entry.finallyLoc) {
          var finallyEntry = entry;
          break;
        }
      }

      if (finallyEntry &&
          (type === "break" ||
           type === "continue") &&
          finallyEntry.tryLoc <= arg &&
          arg <= finallyEntry.finallyLoc) {
        // Ignore the finally entry if control is not jumping to a
        // location outside the try/catch block.
        finallyEntry = null;
      }

      var record = finallyEntry ? finallyEntry.completion : {};
      record.type = type;
      record.arg = arg;

      if (finallyEntry) {
        this.method = "next";
        this.next = finallyEntry.finallyLoc;
        return ContinueSentinel;
      }

      return this.complete(record);
    },

    complete: function(record, afterLoc) {
      if (record.type === "throw") {
        throw record.arg;
      }

      if (record.type === "break" ||
          record.type === "continue") {
        this.next = record.arg;
      } else if (record.type === "return") {
        this.rval = this.arg = record.arg;
        this.method = "return";
        this.next = "end";
      } else if (record.type === "normal" && afterLoc) {
        this.next = afterLoc;
      }

      return ContinueSentinel;
    },

    finish: function(finallyLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.finallyLoc === finallyLoc) {
          this.complete(entry.completion, entry.afterLoc);
          resetTryEntry(entry);
          return ContinueSentinel;
        }
      }
    },

    "catch": function(tryLoc) {
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
        var entry = this.tryEntries[i];
        if (entry.tryLoc === tryLoc) {
          var record = entry.completion;
          if (record.type === "throw") {
            var thrown = record.arg;
            resetTryEntry(entry);
          }
          return thrown;
        }
      }

      // The context.catch method must only be called with a location
      // argument that corresponds to a known catch block.
      throw new Error("illegal catch attempt");
    },

    delegateYield: function(iterable, resultName, nextLoc) {
      this.delegate = {
        iterator: values(iterable),
        resultName: resultName,
        nextLoc: nextLoc
      };

      if (this.method === "next") {
        // Deliberately forget the last sent value so that we don't
        // accidentally pass it on to the delegate.
        this.arg = undefined;
      }

      return ContinueSentinel;
    }
  };
})(
  // Among the various tricks for obtaining a reference to the global
  // object, this seems to be the most reliable technique that does not
  // use indirect eval (which violates Content Security Policy).
  typeof global === "object" ? global :
  typeof window === "object" ? window :
  typeof self === "object" ? self : this
);

/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/base64-js/index.js":
/*!*****************************************!*\
  !*** ./node_modules/base64-js/index.js ***!
  \*****************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


exports.byteLength = byteLength
exports.toByteArray = toByteArray
exports.fromByteArray = fromByteArray

var lookup = []
var revLookup = []
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array

var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
for (var i = 0, len = code.length; i < len; ++i) {
  lookup[i] = code[i]
  revLookup[code.charCodeAt(i)] = i
}

// Support decoding URL-safe base64 strings, as Node.js does.
// See: https://en.wikipedia.org/wiki/Base64#URL_applications
revLookup['-'.charCodeAt(0)] = 62
revLookup['_'.charCodeAt(0)] = 63

function getLens (b64) {
  var len = b64.length

  if (len % 4 > 0) {
    throw new Error('Invalid string. Length must be a multiple of 4')
  }

  // Trim off extra bytes after placeholder bytes are found
  // See: https://github.com/beatgammit/base64-js/issues/42
  var validLen = b64.indexOf('=')
  if (validLen === -1) validLen = len

  var placeHoldersLen = validLen === len
    ? 0
    : 4 - (validLen % 4)

  return [validLen, placeHoldersLen]
}

// base64 is 4/3 + up to two characters of the original data
function byteLength (b64) {
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function _byteLength (b64, validLen, placeHoldersLen) {
  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
}

function toByteArray (b64) {
  var tmp
  var lens = getLens(b64)
  var validLen = lens[0]
  var placeHoldersLen = lens[1]

  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))

  var curByte = 0

  // if there are placeholders, only get up to the last complete 4 chars
  var len = placeHoldersLen > 0
    ? validLen - 4
    : validLen

  for (var i = 0; i < len; i += 4) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 18) |
      (revLookup[b64.charCodeAt(i + 1)] << 12) |
      (revLookup[b64.charCodeAt(i + 2)] << 6) |
      revLookup[b64.charCodeAt(i + 3)]
    arr[curByte++] = (tmp >> 16) & 0xFF
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 2) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 2) |
      (revLookup[b64.charCodeAt(i + 1)] >> 4)
    arr[curByte++] = tmp & 0xFF
  }

  if (placeHoldersLen === 1) {
    tmp =
      (revLookup[b64.charCodeAt(i)] << 10) |
      (revLookup[b64.charCodeAt(i + 1)] << 4) |
      (revLookup[b64.charCodeAt(i + 2)] >> 2)
    arr[curByte++] = (tmp >> 8) & 0xFF
    arr[curByte++] = tmp & 0xFF
  }

  return arr
}

function tripletToBase64 (num) {
  return lookup[num >> 18 & 0x3F] +
    lookup[num >> 12 & 0x3F] +
    lookup[num >> 6 & 0x3F] +
    lookup[num & 0x3F]
}

function encodeChunk (uint8, start, end) {
  var tmp
  var output = []
  for (var i = start; i < end; i += 3) {
    tmp =
      ((uint8[i] << 16) & 0xFF0000) +
      ((uint8[i + 1] << 8) & 0xFF00) +
      (uint8[i + 2] & 0xFF)
    output.push(tripletToBase64(tmp))
  }
  return output.join('')
}

function fromByteArray (uint8) {
  var tmp
  var len = uint8.length
  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
  var parts = []
  var maxChunkLength = 16383 // must be multiple of 3

  // go through the array every three bytes, we'll deal with trailing stuff later
  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
    parts.push(encodeChunk(
      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
    ))
  }

  // pad the end with zeros, but make sure to not forget the extra bytes
  if (extraBytes === 1) {
    tmp = uint8[len - 1]
    parts.push(
      lookup[tmp >> 2] +
      lookup[(tmp << 4) & 0x3F] +
      '=='
    )
  } else if (extraBytes === 2) {
    tmp = (uint8[len - 2] << 8) + uint8[len - 1]
    parts.push(
      lookup[tmp >> 10] +
      lookup[(tmp >> 4) & 0x3F] +
      lookup[(tmp << 2) & 0x3F] +
      '='
    )
  }

  return parts.join('')
}


/***/ }),

/***/ "./node_modules/buffer/index.js":
/*!**************************************!*\
  !*** ./node_modules/buffer/index.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
/* WEBPACK VAR INJECTION */(function(global) {/*!
 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh  
 * @license  MIT
 */
/* eslint-disable no-proto */



var base64 = __webpack_require__(/*! base64-js */ "./node_modules/base64-js/index.js")
var ieee754 = __webpack_require__(/*! ieee754 */ "./node_modules/ieee754/index.js")
var isArray = __webpack_require__(/*! isarray */ "./node_modules/buffer/node_modules/isarray/index.js")

exports.Buffer = Buffer
exports.SlowBuffer = SlowBuffer
exports.INSPECT_MAX_BYTES = 50

/**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Use Object implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * Due to various browser bugs, sometimes the Object implementation will be used even
 * when the browser supports typed arrays.
 *
 * Note:
 *
 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 *
 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
 *
 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
 *     incorrect length in some situations.

 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
 * get the Object implementation, which is slower but behaves correctly.
 */
Buffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined
  ? global.TYPED_ARRAY_SUPPORT
  : typedArraySupport()

/*
 * Export kMaxLength after typed array support is determined.
 */
exports.kMaxLength = kMaxLength()

function typedArraySupport () {
  try {
    var arr = new Uint8Array(1)
    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}
    return arr.foo() === 42 && // typed array instances can be augmented
        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`
        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`
  } catch (e) {
    return false
  }
}

function kMaxLength () {
  return Buffer.TYPED_ARRAY_SUPPORT
    ? 0x7fffffff
    : 0x3fffffff
}

function createBuffer (that, length) {
  if (kMaxLength() < length) {
    throw new RangeError('Invalid typed array length')
  }
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = new Uint8Array(length)
    that.__proto__ = Buffer.prototype
  } else {
    // Fallback: Return an object instance of the Buffer class
    if (that === null) {
      that = new Buffer(length)
    }
    that.length = length
  }

  return that
}

/**
 * The Buffer constructor returns instances of `Uint8Array` that have their
 * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
 * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
 * and the `Uint8Array` methods. Square bracket notation works as expected -- it
 * returns a single octet.
 *
 * The `Uint8Array` prototype remains unmodified.
 */

function Buffer (arg, encodingOrOffset, length) {
  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
    return new Buffer(arg, encodingOrOffset, length)
  }

  // Common case.
  if (typeof arg === 'number') {
    if (typeof encodingOrOffset === 'string') {
      throw new Error(
        'If encoding is specified then the first argument must be a string'
      )
    }
    return allocUnsafe(this, arg)
  }
  return from(this, arg, encodingOrOffset, length)
}

Buffer.poolSize = 8192 // not used by this implementation

// TODO: Legacy, not needed anymore. Remove in next major version.
Buffer._augment = function (arr) {
  arr.__proto__ = Buffer.prototype
  return arr
}

function from (that, value, encodingOrOffset, length) {
  if (typeof value === 'number') {
    throw new TypeError('"value" argument must not be a number')
  }

  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
    return fromArrayBuffer(that, value, encodingOrOffset, length)
  }

  if (typeof value === 'string') {
    return fromString(that, value, encodingOrOffset)
  }

  return fromObject(that, value)
}

/**
 * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
 * if value is a number.
 * Buffer.from(str[, encoding])
 * Buffer.from(array)
 * Buffer.from(buffer)
 * Buffer.from(arrayBuffer[, byteOffset[, length]])
 **/
Buffer.from = function (value, encodingOrOffset, length) {
  return from(null, value, encodingOrOffset, length)
}

if (Buffer.TYPED_ARRAY_SUPPORT) {
  Buffer.prototype.__proto__ = Uint8Array.prototype
  Buffer.__proto__ = Uint8Array
  if (typeof Symbol !== 'undefined' && Symbol.species &&
      Buffer[Symbol.species] === Buffer) {
    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true
    })
  }
}

function assertSize (size) {
  if (typeof size !== 'number') {
    throw new TypeError('"size" argument must be a number')
  } else if (size < 0) {
    throw new RangeError('"size" argument must not be negative')
  }
}

function alloc (that, size, fill, encoding) {
  assertSize(size)
  if (size <= 0) {
    return createBuffer(that, size)
  }
  if (fill !== undefined) {
    // Only pay attention to encoding if it's a string. This
    // prevents accidentally sending in a number that would
    // be interpretted as a start offset.
    return typeof encoding === 'string'
      ? createBuffer(that, size).fill(fill, encoding)
      : createBuffer(that, size).fill(fill)
  }
  return createBuffer(that, size)
}

/**
 * Creates a new filled Buffer instance.
 * alloc(size[, fill[, encoding]])
 **/
Buffer.alloc = function (size, fill, encoding) {
  return alloc(null, size, fill, encoding)
}

function allocUnsafe (that, size) {
  assertSize(size)
  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)
  if (!Buffer.TYPED_ARRAY_SUPPORT) {
    for (var i = 0; i < size; ++i) {
      that[i] = 0
    }
  }
  return that
}

/**
 * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
 * */
Buffer.allocUnsafe = function (size) {
  return allocUnsafe(null, size)
}
/**
 * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
 */
Buffer.allocUnsafeSlow = function (size) {
  return allocUnsafe(null, size)
}

function fromString (that, string, encoding) {
  if (typeof encoding !== 'string' || encoding === '') {
    encoding = 'utf8'
  }

  if (!Buffer.isEncoding(encoding)) {
    throw new TypeError('"encoding" must be a valid string encoding')
  }

  var length = byteLength(string, encoding) | 0
  that = createBuffer(that, length)

  var actual = that.write(string, encoding)

  if (actual !== length) {
    // Writing a hex string, for example, that contains invalid characters will
    // cause everything after the first invalid character to be ignored. (e.g.
    // 'abxxcd' will be treated as 'ab')
    that = that.slice(0, actual)
  }

  return that
}

function fromArrayLike (that, array) {
  var length = array.length < 0 ? 0 : checked(array.length) | 0
  that = createBuffer(that, length)
  for (var i = 0; i < length; i += 1) {
    that[i] = array[i] & 255
  }
  return that
}

function fromArrayBuffer (that, array, byteOffset, length) {
  array.byteLength // this throws if `array` is not a valid ArrayBuffer

  if (byteOffset < 0 || array.byteLength < byteOffset) {
    throw new RangeError('\'offset\' is out of bounds')
  }

  if (array.byteLength < byteOffset + (length || 0)) {
    throw new RangeError('\'length\' is out of bounds')
  }

  if (byteOffset === undefined && length === undefined) {
    array = new Uint8Array(array)
  } else if (length === undefined) {
    array = new Uint8Array(array, byteOffset)
  } else {
    array = new Uint8Array(array, byteOffset, length)
  }

  if (Buffer.TYPED_ARRAY_SUPPORT) {
    // Return an augmented `Uint8Array` instance, for best performance
    that = array
    that.__proto__ = Buffer.prototype
  } else {
    // Fallback: Return an object instance of the Buffer class
    that = fromArrayLike(that, array)
  }
  return that
}

function fromObject (that, obj) {
  if (Buffer.isBuffer(obj)) {
    var len = checked(obj.length) | 0
    that = createBuffer(that, len)

    if (that.length === 0) {
      return that
    }

    obj.copy(that, 0, 0, len)
    return that
  }

  if (obj) {
    if ((typeof ArrayBuffer !== 'undefined' &&
        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
      if (typeof obj.length !== 'number' || isnan(obj.length)) {
        return createBuffer(that, 0)
      }
      return fromArrayLike(that, obj)
    }

    if (obj.type === 'Buffer' && isArray(obj.data)) {
      return fromArrayLike(that, obj.data)
    }
  }

  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
}

function checked (length) {
  // Note: cannot use `length < kMaxLength()` here because that fails when
  // length is NaN (which is otherwise coerced to zero.)
  if (length >= kMaxLength()) {
    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                         'size: 0x' + kMaxLength().toString(16) + ' bytes')
  }
  return length | 0
}

function SlowBuffer (length) {
  if (+length != length) { // eslint-disable-line eqeqeq
    length = 0
  }
  return Buffer.alloc(+length)
}

Buffer.isBuffer = function isBuffer (b) {
  return !!(b != null && b._isBuffer)
}

Buffer.compare = function compare (a, b) {
  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
    throw new TypeError('Arguments must be Buffers')
  }

  if (a === b) return 0

  var x = a.length
  var y = b.length

  for (var i = 0, len = Math.min(x, y); i < len; ++i) {
    if (a[i] !== b[i]) {
      x = a[i]
      y = b[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

Buffer.isEncoding = function isEncoding (encoding) {
  switch (String(encoding).toLowerCase()) {
    case 'hex':
    case 'utf8':
    case 'utf-8':
    case 'ascii':
    case 'latin1':
    case 'binary':
    case 'base64':
    case 'ucs2':
    case 'ucs-2':
    case 'utf16le':
    case 'utf-16le':
      return true
    default:
      return false
  }
}

Buffer.concat = function concat (list, length) {
  if (!isArray(list)) {
    throw new TypeError('"list" argument must be an Array of Buffers')
  }

  if (list.length === 0) {
    return Buffer.alloc(0)
  }

  var i
  if (length === undefined) {
    length = 0
    for (i = 0; i < list.length; ++i) {
      length += list[i].length
    }
  }

  var buffer = Buffer.allocUnsafe(length)
  var pos = 0
  for (i = 0; i < list.length; ++i) {
    var buf = list[i]
    if (!Buffer.isBuffer(buf)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
    buf.copy(buffer, pos)
    pos += buf.length
  }
  return buffer
}

function byteLength (string, encoding) {
  if (Buffer.isBuffer(string)) {
    return string.length
  }
  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
    return string.byteLength
  }
  if (typeof string !== 'string') {
    string = '' + string
  }

  var len = string.length
  if (len === 0) return 0

  // Use a for loop to avoid recursion
  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'ascii':
      case 'latin1':
      case 'binary':
        return len
      case 'utf8':
      case 'utf-8':
      case undefined:
        return utf8ToBytes(string).length
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return len * 2
      case 'hex':
        return len >>> 1
      case 'base64':
        return base64ToBytes(string).length
      default:
        if (loweredCase) return utf8ToBytes(string).length // assume utf8
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}
Buffer.byteLength = byteLength

function slowToString (encoding, start, end) {
  var loweredCase = false

  // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
  // property of a typed array.

  // This behaves neither like String nor Uint8Array in that we set start/end
  // to their upper/lower bounds if the value passed is out of range.
  // undefined is handled specially as per ECMA-262 6th Edition,
  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
  if (start === undefined || start < 0) {
    start = 0
  }
  // Return early if start > this.length. Done here to prevent potential uint32
  // coercion fail below.
  if (start > this.length) {
    return ''
  }

  if (end === undefined || end > this.length) {
    end = this.length
  }

  if (end <= 0) {
    return ''
  }

  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
  end >>>= 0
  start >>>= 0

  if (end <= start) {
    return ''
  }

  if (!encoding) encoding = 'utf8'

  while (true) {
    switch (encoding) {
      case 'hex':
        return hexSlice(this, start, end)

      case 'utf8':
      case 'utf-8':
        return utf8Slice(this, start, end)

      case 'ascii':
        return asciiSlice(this, start, end)

      case 'latin1':
      case 'binary':
        return latin1Slice(this, start, end)

      case 'base64':
        return base64Slice(this, start, end)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return utf16leSlice(this, start, end)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = (encoding + '').toLowerCase()
        loweredCase = true
    }
  }
}

// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
// Buffer instances.
Buffer.prototype._isBuffer = true

function swap (b, n, m) {
  var i = b[n]
  b[n] = b[m]
  b[m] = i
}

Buffer.prototype.swap16 = function swap16 () {
  var len = this.length
  if (len % 2 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 16-bits')
  }
  for (var i = 0; i < len; i += 2) {
    swap(this, i, i + 1)
  }
  return this
}

Buffer.prototype.swap32 = function swap32 () {
  var len = this.length
  if (len % 4 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 32-bits')
  }
  for (var i = 0; i < len; i += 4) {
    swap(this, i, i + 3)
    swap(this, i + 1, i + 2)
  }
  return this
}

Buffer.prototype.swap64 = function swap64 () {
  var len = this.length
  if (len % 8 !== 0) {
    throw new RangeError('Buffer size must be a multiple of 64-bits')
  }
  for (var i = 0; i < len; i += 8) {
    swap(this, i, i + 7)
    swap(this, i + 1, i + 6)
    swap(this, i + 2, i + 5)
    swap(this, i + 3, i + 4)
  }
  return this
}

Buffer.prototype.toString = function toString () {
  var length = this.length | 0
  if (length === 0) return ''
  if (arguments.length === 0) return utf8Slice(this, 0, length)
  return slowToString.apply(this, arguments)
}

Buffer.prototype.equals = function equals (b) {
  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
  if (this === b) return true
  return Buffer.compare(this, b) === 0
}

Buffer.prototype.inspect = function inspect () {
  var str = ''
  var max = exports.INSPECT_MAX_BYTES
  if (this.length > 0) {
    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')
    if (this.length > max) str += ' ... '
  }
  return ''
}

Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
  if (!Buffer.isBuffer(target)) {
    throw new TypeError('Argument must be a Buffer')
  }

  if (start === undefined) {
    start = 0
  }
  if (end === undefined) {
    end = target ? target.length : 0
  }
  if (thisStart === undefined) {
    thisStart = 0
  }
  if (thisEnd === undefined) {
    thisEnd = this.length
  }

  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
    throw new RangeError('out of range index')
  }

  if (thisStart >= thisEnd && start >= end) {
    return 0
  }
  if (thisStart >= thisEnd) {
    return -1
  }
  if (start >= end) {
    return 1
  }

  start >>>= 0
  end >>>= 0
  thisStart >>>= 0
  thisEnd >>>= 0

  if (this === target) return 0

  var x = thisEnd - thisStart
  var y = end - start
  var len = Math.min(x, y)

  var thisCopy = this.slice(thisStart, thisEnd)
  var targetCopy = target.slice(start, end)

  for (var i = 0; i < len; ++i) {
    if (thisCopy[i] !== targetCopy[i]) {
      x = thisCopy[i]
      y = targetCopy[i]
      break
    }
  }

  if (x < y) return -1
  if (y < x) return 1
  return 0
}

// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
//
// Arguments:
// - buffer - a Buffer to search
// - val - a string, Buffer, or number
// - byteOffset - an index into `buffer`; will be clamped to an int32
// - encoding - an optional encoding, relevant is val is a string
// - dir - true for indexOf, false for lastIndexOf
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
  // Empty buffer means no match
  if (buffer.length === 0) return -1

  // Normalize byteOffset
  if (typeof byteOffset === 'string') {
    encoding = byteOffset
    byteOffset = 0
  } else if (byteOffset > 0x7fffffff) {
    byteOffset = 0x7fffffff
  } else if (byteOffset < -0x80000000) {
    byteOffset = -0x80000000
  }
  byteOffset = +byteOffset  // Coerce to Number.
  if (isNaN(byteOffset)) {
    // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
    byteOffset = dir ? 0 : (buffer.length - 1)
  }

  // Normalize byteOffset: negative offsets start from the end of the buffer
  if (byteOffset < 0) byteOffset = buffer.length + byteOffset
  if (byteOffset >= buffer.length) {
    if (dir) return -1
    else byteOffset = buffer.length - 1
  } else if (byteOffset < 0) {
    if (dir) byteOffset = 0
    else return -1
  }

  // Normalize val
  if (typeof val === 'string') {
    val = Buffer.from(val, encoding)
  }

  // Finally, search either indexOf (if dir is true) or lastIndexOf
  if (Buffer.isBuffer(val)) {
    // Special case: looking for empty string/buffer always fails
    if (val.length === 0) {
      return -1
    }
    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
  } else if (typeof val === 'number') {
    val = val & 0xFF // Search for a byte value [0-255]
    if (Buffer.TYPED_ARRAY_SUPPORT &&
        typeof Uint8Array.prototype.indexOf === 'function') {
      if (dir) {
        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
      } else {
        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
      }
    }
    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
  }

  throw new TypeError('val must be string, number or Buffer')
}

function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
  var indexSize = 1
  var arrLength = arr.length
  var valLength = val.length

  if (encoding !== undefined) {
    encoding = String(encoding).toLowerCase()
    if (encoding === 'ucs2' || encoding === 'ucs-2' ||
        encoding === 'utf16le' || encoding === 'utf-16le') {
      if (arr.length < 2 || val.length < 2) {
        return -1
      }
      indexSize = 2
      arrLength /= 2
      valLength /= 2
      byteOffset /= 2
    }
  }

  function read (buf, i) {
    if (indexSize === 1) {
      return buf[i]
    } else {
      return buf.readUInt16BE(i * indexSize)
    }
  }

  var i
  if (dir) {
    var foundIndex = -1
    for (i = byteOffset; i < arrLength; i++) {
      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
        if (foundIndex === -1) foundIndex = i
        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
      } else {
        if (foundIndex !== -1) i -= i - foundIndex
        foundIndex = -1
      }
    }
  } else {
    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
    for (i = byteOffset; i >= 0; i--) {
      var found = true
      for (var j = 0; j < valLength; j++) {
        if (read(arr, i + j) !== read(val, j)) {
          found = false
          break
        }
      }
      if (found) return i
    }
  }

  return -1
}

Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
  return this.indexOf(val, byteOffset, encoding) !== -1
}

Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
}

Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
}

function hexWrite (buf, string, offset, length) {
  offset = Number(offset) || 0
  var remaining = buf.length - offset
  if (!length) {
    length = remaining
  } else {
    length = Number(length)
    if (length > remaining) {
      length = remaining
    }
  }

  // must be an even number of digits
  var strLen = string.length
  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')

  if (length > strLen / 2) {
    length = strLen / 2
  }
  for (var i = 0; i < length; ++i) {
    var parsed = parseInt(string.substr(i * 2, 2), 16)
    if (isNaN(parsed)) return i
    buf[offset + i] = parsed
  }
  return i
}

function utf8Write (buf, string, offset, length) {
  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
}

function asciiWrite (buf, string, offset, length) {
  return blitBuffer(asciiToBytes(string), buf, offset, length)
}

function latin1Write (buf, string, offset, length) {
  return asciiWrite(buf, string, offset, length)
}

function base64Write (buf, string, offset, length) {
  return blitBuffer(base64ToBytes(string), buf, offset, length)
}

function ucs2Write (buf, string, offset, length) {
  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
}

Buffer.prototype.write = function write (string, offset, length, encoding) {
  // Buffer#write(string)
  if (offset === undefined) {
    encoding = 'utf8'
    length = this.length
    offset = 0
  // Buffer#write(string, encoding)
  } else if (length === undefined && typeof offset === 'string') {
    encoding = offset
    length = this.length
    offset = 0
  // Buffer#write(string, offset[, length][, encoding])
  } else if (isFinite(offset)) {
    offset = offset | 0
    if (isFinite(length)) {
      length = length | 0
      if (encoding === undefined) encoding = 'utf8'
    } else {
      encoding = length
      length = undefined
    }
  // legacy write(string, encoding, offset, length) - remove in v0.13
  } else {
    throw new Error(
      'Buffer.write(string, encoding, offset[, length]) is no longer supported'
    )
  }

  var remaining = this.length - offset
  if (length === undefined || length > remaining) length = remaining

  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
    throw new RangeError('Attempt to write outside buffer bounds')
  }

  if (!encoding) encoding = 'utf8'

  var loweredCase = false
  for (;;) {
    switch (encoding) {
      case 'hex':
        return hexWrite(this, string, offset, length)

      case 'utf8':
      case 'utf-8':
        return utf8Write(this, string, offset, length)

      case 'ascii':
        return asciiWrite(this, string, offset, length)

      case 'latin1':
      case 'binary':
        return latin1Write(this, string, offset, length)

      case 'base64':
        // Warning: maxLength not taken into account in base64Write
        return base64Write(this, string, offset, length)

      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return ucs2Write(this, string, offset, length)

      default:
        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
        encoding = ('' + encoding).toLowerCase()
        loweredCase = true
    }
  }
}

Buffer.prototype.toJSON = function toJSON () {
  return {
    type: 'Buffer',
    data: Array.prototype.slice.call(this._arr || this, 0)
  }
}

function base64Slice (buf, start, end) {
  if (start === 0 && end === buf.length) {
    return base64.fromByteArray(buf)
  } else {
    return base64.fromByteArray(buf.slice(start, end))
  }
}

function utf8Slice (buf, start, end) {
  end = Math.min(buf.length, end)
  var res = []

  var i = start
  while (i < end) {
    var firstByte = buf[i]
    var codePoint = null
    var bytesPerSequence = (firstByte > 0xEF) ? 4
      : (firstByte > 0xDF) ? 3
      : (firstByte > 0xBF) ? 2
      : 1

    if (i + bytesPerSequence <= end) {
      var secondByte, thirdByte, fourthByte, tempCodePoint

      switch (bytesPerSequence) {
        case 1:
          if (firstByte < 0x80) {
            codePoint = firstByte
          }
          break
        case 2:
          secondByte = buf[i + 1]
          if ((secondByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
            if (tempCodePoint > 0x7F) {
              codePoint = tempCodePoint
            }
          }
          break
        case 3:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
              codePoint = tempCodePoint
            }
          }
          break
        case 4:
          secondByte = buf[i + 1]
          thirdByte = buf[i + 2]
          fourthByte = buf[i + 3]
          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
              codePoint = tempCodePoint
            }
          }
      }
    }

    if (codePoint === null) {
      // we did not generate a valid codePoint so insert a
      // replacement char (U+FFFD) and advance only 1 byte
      codePoint = 0xFFFD
      bytesPerSequence = 1
    } else if (codePoint > 0xFFFF) {
      // encode to utf16 (surrogate pair dance)
      codePoint -= 0x10000
      res.push(codePoint >>> 10 & 0x3FF | 0xD800)
      codePoint = 0xDC00 | codePoint & 0x3FF
    }

    res.push(codePoint)
    i += bytesPerSequence
  }

  return decodeCodePointsArray(res)
}

// Based on http://stackoverflow.com/a/22747272/680742, the browser with
// the lowest limit is Chrome, with 0x10000 args.
// We go 1 magnitude less, for safety
var MAX_ARGUMENTS_LENGTH = 0x1000

function decodeCodePointsArray (codePoints) {
  var len = codePoints.length
  if (len <= MAX_ARGUMENTS_LENGTH) {
    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
  }

  // Decode in chunks to avoid "call stack size exceeded".
  var res = ''
  var i = 0
  while (i < len) {
    res += String.fromCharCode.apply(
      String,
      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
    )
  }
  return res
}

function asciiSlice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i] & 0x7F)
  }
  return ret
}

function latin1Slice (buf, start, end) {
  var ret = ''
  end = Math.min(buf.length, end)

  for (var i = start; i < end; ++i) {
    ret += String.fromCharCode(buf[i])
  }
  return ret
}

function hexSlice (buf, start, end) {
  var len = buf.length

  if (!start || start < 0) start = 0
  if (!end || end < 0 || end > len) end = len

  var out = ''
  for (var i = start; i < end; ++i) {
    out += toHex(buf[i])
  }
  return out
}

function utf16leSlice (buf, start, end) {
  var bytes = buf.slice(start, end)
  var res = ''
  for (var i = 0; i < bytes.length; i += 2) {
    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)
  }
  return res
}

Buffer.prototype.slice = function slice (start, end) {
  var len = this.length
  start = ~~start
  end = end === undefined ? len : ~~end

  if (start < 0) {
    start += len
    if (start < 0) start = 0
  } else if (start > len) {
    start = len
  }

  if (end < 0) {
    end += len
    if (end < 0) end = 0
  } else if (end > len) {
    end = len
  }

  if (end < start) end = start

  var newBuf
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    newBuf = this.subarray(start, end)
    newBuf.__proto__ = Buffer.prototype
  } else {
    var sliceLen = end - start
    newBuf = new Buffer(sliceLen, undefined)
    for (var i = 0; i < sliceLen; ++i) {
      newBuf[i] = this[i + start]
    }
  }

  return newBuf
}

/*
 * Need to make sure that buffer isn't trying to write out of bounds.
 */
function checkOffset (offset, ext, length) {
  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
}

Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }

  return val
}

Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    checkOffset(offset, byteLength, this.length)
  }

  var val = this[offset + --byteLength]
  var mul = 1
  while (byteLength > 0 && (mul *= 0x100)) {
    val += this[offset + --byteLength] * mul
  }

  return val
}

Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length)
  return this[offset]
}

Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  return this[offset] | (this[offset + 1] << 8)
}

Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  return (this[offset] << 8) | this[offset + 1]
}

Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

  return ((this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16)) +
      (this[offset + 3] * 0x1000000)
}

Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] * 0x1000000) +
    ((this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    this[offset + 3])
}

Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var val = this[offset]
  var mul = 1
  var i = 0
  while (++i < byteLength && (mul *= 0x100)) {
    val += this[offset + i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) checkOffset(offset, byteLength, this.length)

  var i = byteLength
  var mul = 1
  var val = this[offset + --i]
  while (i > 0 && (mul *= 0x100)) {
    val += this[offset + --i] * mul
  }
  mul *= 0x80

  if (val >= mul) val -= Math.pow(2, 8 * byteLength)

  return val
}

Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 1, this.length)
  if (!(this[offset] & 0x80)) return (this[offset])
  return ((0xff - this[offset] + 1) * -1)
}

Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset] | (this[offset + 1] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 2, this.length)
  var val = this[offset + 1] | (this[offset] << 8)
  return (val & 0x8000) ? val | 0xFFFF0000 : val
}

Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset]) |
    (this[offset + 1] << 8) |
    (this[offset + 2] << 16) |
    (this[offset + 3] << 24)
}

Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)

  return (this[offset] << 24) |
    (this[offset + 1] << 16) |
    (this[offset + 2] << 8) |
    (this[offset + 3])
}

Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, true, 23, 4)
}

Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 4, this.length)
  return ieee754.read(this, offset, false, 23, 4)
}

Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, true, 52, 8)
}

Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
  if (!noAssert) checkOffset(offset, 8, this.length)
  return ieee754.read(this, offset, false, 52, 8)
}

function checkInt (buf, value, offset, ext, max, min) {
  if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
  if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
}

Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var mul = 1
  var i = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  byteLength = byteLength | 0
  if (!noAssert) {
    var maxBytes = Math.pow(2, 8 * byteLength) - 1
    checkInt(this, value, offset, byteLength, maxBytes, 0)
  }

  var i = byteLength - 1
  var mul = 1
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    this[offset + i] = (value / mul) & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  this[offset] = (value & 0xff)
  return offset + 1
}

function objectWriteUInt16 (buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffff + value + 1
  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
      (littleEndian ? i : 1 - i) * 8
  }
}

Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectWriteUInt16(this, value, offset, true)
  }
  return offset + 2
}

Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectWriteUInt16(this, value, offset, false)
  }
  return offset + 2
}

function objectWriteUInt32 (buf, value, offset, littleEndian) {
  if (value < 0) value = 0xffffffff + value + 1
  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff
  }
}

Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset + 3] = (value >>> 24)
    this[offset + 2] = (value >>> 16)
    this[offset + 1] = (value >>> 8)
    this[offset] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, true)
  }
  return offset + 4
}

Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, false)
  }
  return offset + 4
}

Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = 0
  var mul = 1
  var sub = 0
  this[offset] = value & 0xFF
  while (++i < byteLength && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) {
    var limit = Math.pow(2, 8 * byteLength - 1)

    checkInt(this, value, offset, byteLength, limit - 1, -limit)
  }

  var i = byteLength - 1
  var mul = 1
  var sub = 0
  this[offset + i] = value & 0xFF
  while (--i >= 0 && (mul *= 0x100)) {
    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
      sub = 1
    }
    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
  }

  return offset + byteLength
}

Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)
  if (value < 0) value = 0xff + value + 1
  this[offset] = (value & 0xff)
  return offset + 1
}

Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
  } else {
    objectWriteUInt16(this, value, offset, true)
  }
  return offset + 2
}

Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
  } else {
    objectWriteUInt16(this, value, offset, false)
  }
  return offset + 2
}

Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    this[offset + 2] = (value >>> 16)
    this[offset + 3] = (value >>> 24)
  } else {
    objectWriteUInt32(this, value, offset, true)
  }
  return offset + 4
}

Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
  value = +value
  offset = offset | 0
  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
  if (value < 0) value = 0xffffffff + value + 1
  if (Buffer.TYPED_ARRAY_SUPPORT) {
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
  } else {
    objectWriteUInt32(this, value, offset, false)
  }
  return offset + 4
}

function checkIEEE754 (buf, value, offset, ext, max, min) {
  if (offset + ext > buf.length) throw new RangeError('Index out of range')
  if (offset < 0) throw new RangeError('Index out of range')
}

function writeFloat (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
  }
  ieee754.write(buf, value, offset, littleEndian, 23, 4)
  return offset + 4
}

Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
  return writeFloat(this, value, offset, true, noAssert)
}

Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
  return writeFloat(this, value, offset, false, noAssert)
}

function writeDouble (buf, value, offset, littleEndian, noAssert) {
  if (!noAssert) {
    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
  }
  ieee754.write(buf, value, offset, littleEndian, 52, 8)
  return offset + 8
}

Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
  return writeDouble(this, value, offset, true, noAssert)
}

Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
  return writeDouble(this, value, offset, false, noAssert)
}

// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
  if (!start) start = 0
  if (!end && end !== 0) end = this.length
  if (targetStart >= target.length) targetStart = target.length
  if (!targetStart) targetStart = 0
  if (end > 0 && end < start) end = start

  // Copy 0 bytes; we're done
  if (end === start) return 0
  if (target.length === 0 || this.length === 0) return 0

  // Fatal error conditions
  if (targetStart < 0) {
    throw new RangeError('targetStart out of bounds')
  }
  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
  if (end < 0) throw new RangeError('sourceEnd out of bounds')

  // Are we oob?
  if (end > this.length) end = this.length
  if (target.length - targetStart < end - start) {
    end = target.length - targetStart + start
  }

  var len = end - start
  var i

  if (this === target && start < targetStart && targetStart < end) {
    // descending copy from end
    for (i = len - 1; i >= 0; --i) {
      target[i + targetStart] = this[i + start]
    }
  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
    // ascending copy from start
    for (i = 0; i < len; ++i) {
      target[i + targetStart] = this[i + start]
    }
  } else {
    Uint8Array.prototype.set.call(
      target,
      this.subarray(start, start + len),
      targetStart
    )
  }

  return len
}

// Usage:
//    buffer.fill(number[, offset[, end]])
//    buffer.fill(buffer[, offset[, end]])
//    buffer.fill(string[, offset[, end]][, encoding])
Buffer.prototype.fill = function fill (val, start, end, encoding) {
  // Handle string cases:
  if (typeof val === 'string') {
    if (typeof start === 'string') {
      encoding = start
      start = 0
      end = this.length
    } else if (typeof end === 'string') {
      encoding = end
      end = this.length
    }
    if (val.length === 1) {
      var code = val.charCodeAt(0)
      if (code < 256) {
        val = code
      }
    }
    if (encoding !== undefined && typeof encoding !== 'string') {
      throw new TypeError('encoding must be a string')
    }
    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  } else if (typeof val === 'number') {
    val = val & 255
  }

  // Invalid ranges are not set to a default, so can range check early.
  if (start < 0 || this.length < start || this.length < end) {
    throw new RangeError('Out of range index')
  }

  if (end <= start) {
    return this
  }

  start = start >>> 0
  end = end === undefined ? this.length : end >>> 0

  if (!val) val = 0

  var i
  if (typeof val === 'number') {
    for (i = start; i < end; ++i) {
      this[i] = val
    }
  } else {
    var bytes = Buffer.isBuffer(val)
      ? val
      : utf8ToBytes(new Buffer(val, encoding).toString())
    var len = bytes.length
    for (i = 0; i < end - start; ++i) {
      this[i + start] = bytes[i % len]
    }
  }

  return this
}

// HELPER FUNCTIONS
// ================

var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g

function base64clean (str) {
  // Node strips out invalid characters like \n and \t from the string, base64-js does not
  str = stringtrim(str).replace(INVALID_BASE64_RE, '')
  // Node converts strings with length < 2 to ''
  if (str.length < 2) return ''
  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
  while (str.length % 4 !== 0) {
    str = str + '='
  }
  return str
}

function stringtrim (str) {
  if (str.trim) return str.trim()
  return str.replace(/^\s+|\s+$/g, '')
}

function toHex (n) {
  if (n < 16) return '0' + n.toString(16)
  return n.toString(16)
}

function utf8ToBytes (string, units) {
  units = units || Infinity
  var codePoint
  var length = string.length
  var leadSurrogate = null
  var bytes = []

  for (var i = 0; i < length; ++i) {
    codePoint = string.charCodeAt(i)

    // is surrogate component
    if (codePoint > 0xD7FF && codePoint < 0xE000) {
      // last char was a lead
      if (!leadSurrogate) {
        // no lead yet
        if (codePoint > 0xDBFF) {
          // unexpected trail
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        } else if (i + 1 === length) {
          // unpaired lead
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          continue
        }

        // valid lead
        leadSurrogate = codePoint

        continue
      }

      // 2 leads in a row
      if (codePoint < 0xDC00) {
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
        leadSurrogate = codePoint
        continue
      }

      // valid surrogate pair
      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
    } else if (leadSurrogate) {
      // valid bmp char, but last char was a lead
      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
    }

    leadSurrogate = null

    // encode utf8
    if (codePoint < 0x80) {
      if ((units -= 1) < 0) break
      bytes.push(codePoint)
    } else if (codePoint < 0x800) {
      if ((units -= 2) < 0) break
      bytes.push(
        codePoint >> 0x6 | 0xC0,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x10000) {
      if ((units -= 3) < 0) break
      bytes.push(
        codePoint >> 0xC | 0xE0,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else if (codePoint < 0x110000) {
      if ((units -= 4) < 0) break
      bytes.push(
        codePoint >> 0x12 | 0xF0,
        codePoint >> 0xC & 0x3F | 0x80,
        codePoint >> 0x6 & 0x3F | 0x80,
        codePoint & 0x3F | 0x80
      )
    } else {
      throw new Error('Invalid code point')
    }
  }

  return bytes
}

function asciiToBytes (str) {
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    // Node's code seems to be doing this and not & 0x7F..
    byteArray.push(str.charCodeAt(i) & 0xFF)
  }
  return byteArray
}

function utf16leToBytes (str, units) {
  var c, hi, lo
  var byteArray = []
  for (var i = 0; i < str.length; ++i) {
    if ((units -= 2) < 0) break

    c = str.charCodeAt(i)
    hi = c >> 8
    lo = c % 256
    byteArray.push(lo)
    byteArray.push(hi)
  }

  return byteArray
}

function base64ToBytes (str) {
  return base64.toByteArray(base64clean(str))
}

function blitBuffer (src, dst, offset, length) {
  for (var i = 0; i < length; ++i) {
    if ((i + offset >= dst.length) || (i >= src.length)) break
    dst[i + offset] = src[i]
  }
  return i
}

function isnan (val) {
  return val !== val // eslint-disable-line no-self-compare
}

/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")))

/***/ }),

/***/ "./node_modules/buffer/node_modules/isarray/index.js":
/*!***********************************************************!*\
  !*** ./node_modules/buffer/node_modules/isarray/index.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = Array.isArray || function (arr) {
  return toString.call(arr) == '[object Array]';
};


/***/ }),

/***/ "./node_modules/core-js/fn/regexp/escape.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/fn/regexp/escape.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ../../modules/core.regexp.escape */ "./node_modules/core-js/modules/core.regexp.escape.js");
module.exports = __webpack_require__(/*! ../../modules/_core */ "./node_modules/core-js/modules/_core.js").RegExp.escape;


/***/ }),

/***/ "./node_modules/core-js/modules/_a-function.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_a-function.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (it) {
  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_a-number-value.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/_a-number-value.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
module.exports = function (it, msg) {
  if (typeof it != 'number' && cof(it) != 'Number') throw TypeError(msg);
  return +it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_add-to-unscopables.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_add-to-unscopables.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.31 Array.prototype[@@unscopables]
var UNSCOPABLES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('unscopables');
var ArrayProto = Array.prototype;
if (ArrayProto[UNSCOPABLES] == undefined) __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js")(ArrayProto, UNSCOPABLES, {});
module.exports = function (key) {
  ArrayProto[UNSCOPABLES][key] = true;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_advance-string-index.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/_advance-string-index.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var at = __webpack_require__(/*! ./_string-at */ "./node_modules/core-js/modules/_string-at.js")(true);

 // `AdvanceStringIndex` abstract operation
// https://tc39.github.io/ecma262/#sec-advancestringindex
module.exports = function (S, index, unicode) {
  return index + (unicode ? at(S, index).length : 1);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_an-instance.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_an-instance.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (it, Constructor, name, forbiddenField) {
  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {
    throw TypeError(name + ': incorrect invocation!');
  } return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_an-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_an-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
module.exports = function (it) {
  if (!isObject(it)) throw TypeError(it + ' is not an object!');
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-copy-within.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-copy-within.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)

var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");

module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {
  var O = toObject(this);
  var len = toLength(O.length);
  var to = toAbsoluteIndex(target, len);
  var from = toAbsoluteIndex(start, len);
  var end = arguments.length > 2 ? arguments[2] : undefined;
  var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);
  var inc = 1;
  if (from < to && to < from + count) {
    inc = -1;
    from += count - 1;
    to += count - 1;
  }
  while (count-- > 0) {
    if (from in O) O[to] = O[from];
    else delete O[to];
    to += inc;
    from += inc;
  } return O;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-fill.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_array-fill.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)

var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
module.exports = function fill(value /* , start = 0, end = @length */) {
  var O = toObject(this);
  var length = toLength(O.length);
  var aLen = arguments.length;
  var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);
  var end = aLen > 2 ? arguments[2] : undefined;
  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
  while (endPos > index) O[index++] = value;
  return O;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-from-iterable.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-from-iterable.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");

module.exports = function (iter, ITERATOR) {
  var result = [];
  forOf(iter, false, result.push, result, ITERATOR);
  return result;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-includes.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/_array-includes.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// false -> Array#indexOf
// true  -> Array#includes
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
module.exports = function (IS_INCLUDES) {
  return function ($this, el, fromIndex) {
    var O = toIObject($this);
    var length = toLength(O.length);
    var index = toAbsoluteIndex(fromIndex, length);
    var value;
    // Array#includes uses SameValueZero equality algorithm
    // eslint-disable-next-line no-self-compare
    if (IS_INCLUDES && el != el) while (length > index) {
      value = O[index++];
      // eslint-disable-next-line no-self-compare
      if (value != value) return true;
    // Array#indexOf ignores holes, Array#includes - not
    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {
      if (O[index] === el) return IS_INCLUDES || index || 0;
    } return !IS_INCLUDES && -1;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-methods.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_array-methods.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 0 -> Array#forEach
// 1 -> Array#map
// 2 -> Array#filter
// 3 -> Array#some
// 4 -> Array#every
// 5 -> Array#find
// 6 -> Array#findIndex
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var asc = __webpack_require__(/*! ./_array-species-create */ "./node_modules/core-js/modules/_array-species-create.js");
module.exports = function (TYPE, $create) {
  var IS_MAP = TYPE == 1;
  var IS_FILTER = TYPE == 2;
  var IS_SOME = TYPE == 3;
  var IS_EVERY = TYPE == 4;
  var IS_FIND_INDEX = TYPE == 6;
  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
  var create = $create || asc;
  return function ($this, callbackfn, that) {
    var O = toObject($this);
    var self = IObject(O);
    var f = ctx(callbackfn, that, 3);
    var length = toLength(self.length);
    var index = 0;
    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
    var val, res;
    for (;length > index; index++) if (NO_HOLES || index in self) {
      val = self[index];
      res = f(val, index, O);
      if (TYPE) {
        if (IS_MAP) result[index] = res;   // map
        else if (res) switch (TYPE) {
          case 3: return true;             // some
          case 5: return val;              // find
          case 6: return index;            // findIndex
          case 2: result.push(val);        // filter
        } else if (IS_EVERY) return false; // every
      }
    }
    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-reduce.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/_array-reduce.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");

module.exports = function (that, callbackfn, aLen, memo, isRight) {
  aFunction(callbackfn);
  var O = toObject(that);
  var self = IObject(O);
  var length = toLength(O.length);
  var index = isRight ? length - 1 : 0;
  var i = isRight ? -1 : 1;
  if (aLen < 2) for (;;) {
    if (index in self) {
      memo = self[index];
      index += i;
      break;
    }
    index += i;
    if (isRight ? index < 0 : length <= index) {
      throw TypeError('Reduce of empty array with no initial value');
    }
  }
  for (;isRight ? index >= 0 : length > index; index += i) if (index in self) {
    memo = callbackfn(memo, self[index], index, O);
  }
  return memo;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-species-constructor.js":
/*!********************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-species-constructor.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/core-js/modules/_is-array.js");
var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('species');

module.exports = function (original) {
  var C;
  if (isArray(original)) {
    C = original.constructor;
    // cross-realm fallback
    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
    if (isObject(C)) {
      C = C[SPECIES];
      if (C === null) C = undefined;
    }
  } return C === undefined ? Array : C;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_array-species-create.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/_array-species-create.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
var speciesConstructor = __webpack_require__(/*! ./_array-species-constructor */ "./node_modules/core-js/modules/_array-species-constructor.js");

module.exports = function (original, length) {
  return new (speciesConstructor(original))(length);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_bind.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_bind.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var invoke = __webpack_require__(/*! ./_invoke */ "./node_modules/core-js/modules/_invoke.js");
var arraySlice = [].slice;
var factories = {};

var construct = function (F, len, args) {
  if (!(len in factories)) {
    for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']';
    // eslint-disable-next-line no-new-func
    factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');
  } return factories[len](F, args);
};

module.exports = Function.bind || function bind(that /* , ...args */) {
  var fn = aFunction(this);
  var partArgs = arraySlice.call(arguments, 1);
  var bound = function (/* args... */) {
    var args = partArgs.concat(arraySlice.call(arguments));
    return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);
  };
  if (isObject(fn.prototype)) bound.prototype = fn.prototype;
  return bound;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_classof.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_classof.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// getting tag from 19.1.3.6 Object.prototype.toString()
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
var TAG = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('toStringTag');
// ES3 wrong here
var ARG = cof(function () { return arguments; }()) == 'Arguments';

// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
  try {
    return it[key];
  } catch (e) { /* empty */ }
};

module.exports = function (it) {
  var O, T, B;
  return it === undefined ? 'Undefined' : it === null ? 'Null'
    // @@toStringTag case
    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T
    // builtinTag case
    : ARG ? cof(O)
    // ES3 arguments fallback
    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_cof.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_cof.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var toString = {}.toString;

module.exports = function (it) {
  return toString.call(it).slice(8, -1);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_collection-strong.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_collection-strong.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var create = __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js");
var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");
var $iterDefine = __webpack_require__(/*! ./_iter-define */ "./node_modules/core-js/modules/_iter-define.js");
var step = __webpack_require__(/*! ./_iter-step */ "./node_modules/core-js/modules/_iter-step.js");
var setSpecies = __webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js");
var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js");
var fastKey = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").fastKey;
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var SIZE = DESCRIPTORS ? '_s' : 'size';

var getEntry = function (that, key) {
  // fast case
  var index = fastKey(key);
  var entry;
  if (index !== 'F') return that._i[index];
  // frozen object case
  for (entry = that._f; entry; entry = entry.n) {
    if (entry.k == key) return entry;
  }
};

module.exports = {
  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
    var C = wrapper(function (that, iterable) {
      anInstance(that, C, NAME, '_i');
      that._t = NAME;         // collection type
      that._i = create(null); // index
      that._f = undefined;    // first entry
      that._l = undefined;    // last entry
      that[SIZE] = 0;         // size
      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
    });
    redefineAll(C.prototype, {
      // 23.1.3.1 Map.prototype.clear()
      // 23.2.3.2 Set.prototype.clear()
      clear: function clear() {
        for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
          entry.r = true;
          if (entry.p) entry.p = entry.p.n = undefined;
          delete data[entry.i];
        }
        that._f = that._l = undefined;
        that[SIZE] = 0;
      },
      // 23.1.3.3 Map.prototype.delete(key)
      // 23.2.3.4 Set.prototype.delete(value)
      'delete': function (key) {
        var that = validate(this, NAME);
        var entry = getEntry(that, key);
        if (entry) {
          var next = entry.n;
          var prev = entry.p;
          delete that._i[entry.i];
          entry.r = true;
          if (prev) prev.n = next;
          if (next) next.p = prev;
          if (that._f == entry) that._f = next;
          if (that._l == entry) that._l = prev;
          that[SIZE]--;
        } return !!entry;
      },
      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
      forEach: function forEach(callbackfn /* , that = undefined */) {
        validate(this, NAME);
        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
        var entry;
        while (entry = entry ? entry.n : this._f) {
          f(entry.v, entry.k, this);
          // revert to the last existing entry
          while (entry && entry.r) entry = entry.p;
        }
      },
      // 23.1.3.7 Map.prototype.has(key)
      // 23.2.3.7 Set.prototype.has(value)
      has: function has(key) {
        return !!getEntry(validate(this, NAME), key);
      }
    });
    if (DESCRIPTORS) dP(C.prototype, 'size', {
      get: function () {
        return validate(this, NAME)[SIZE];
      }
    });
    return C;
  },
  def: function (that, key, value) {
    var entry = getEntry(that, key);
    var prev, index;
    // change existing entry
    if (entry) {
      entry.v = value;
    // create new entry
    } else {
      that._l = entry = {
        i: index = fastKey(key, true), // <- index
        k: key,                        // <- key
        v: value,                      // <- value
        p: prev = that._l,             // <- previous entry
        n: undefined,                  // <- next entry
        r: false                       // <- removed
      };
      if (!that._f) that._f = entry;
      if (prev) prev.n = entry;
      that[SIZE]++;
      // add to index
      if (index !== 'F') that._i[index] = entry;
    } return that;
  },
  getEntry: getEntry,
  setStrong: function (C, NAME, IS_MAP) {
    // add .keys, .values, .entries, [@@iterator]
    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
    $iterDefine(C, NAME, function (iterated, kind) {
      this._t = validate(iterated, NAME); // target
      this._k = kind;                     // kind
      this._l = undefined;                // previous
    }, function () {
      var that = this;
      var kind = that._k;
      var entry = that._l;
      // revert to the last existing entry
      while (entry && entry.r) entry = entry.p;
      // get next entry
      if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
        // or finish the iteration
        that._t = undefined;
        return step(1);
      }
      // return step by kind
      if (kind == 'keys') return step(0, entry.k);
      if (kind == 'values') return step(0, entry.v);
      return step(0, [entry.k, entry.v]);
    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);

    // add [@@species], 23.1.2.2, 23.2.2.2
    setSpecies(NAME);
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_collection-to-json.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_collection-to-json.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/DavidBruant/Map-Set.prototype.toJSON
var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
var from = __webpack_require__(/*! ./_array-from-iterable */ "./node_modules/core-js/modules/_array-from-iterable.js");
module.exports = function (NAME) {
  return function toJSON() {
    if (classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic");
    return from(this);
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_collection-weak.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_collection-weak.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
var getWeak = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").getWeak;
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");
var createArrayMethod = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js");
var $has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var arrayFind = createArrayMethod(5);
var arrayFindIndex = createArrayMethod(6);
var id = 0;

// fallback for uncaught frozen keys
var uncaughtFrozenStore = function (that) {
  return that._l || (that._l = new UncaughtFrozenStore());
};
var UncaughtFrozenStore = function () {
  this.a = [];
};
var findUncaughtFrozen = function (store, key) {
  return arrayFind(store.a, function (it) {
    return it[0] === key;
  });
};
UncaughtFrozenStore.prototype = {
  get: function (key) {
    var entry = findUncaughtFrozen(this, key);
    if (entry) return entry[1];
  },
  has: function (key) {
    return !!findUncaughtFrozen(this, key);
  },
  set: function (key, value) {
    var entry = findUncaughtFrozen(this, key);
    if (entry) entry[1] = value;
    else this.a.push([key, value]);
  },
  'delete': function (key) {
    var index = arrayFindIndex(this.a, function (it) {
      return it[0] === key;
    });
    if (~index) this.a.splice(index, 1);
    return !!~index;
  }
};

module.exports = {
  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
    var C = wrapper(function (that, iterable) {
      anInstance(that, C, NAME, '_i');
      that._t = NAME;      // collection type
      that._i = id++;      // collection id
      that._l = undefined; // leak store for uncaught frozen objects
      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
    });
    redefineAll(C.prototype, {
      // 23.3.3.2 WeakMap.prototype.delete(key)
      // 23.4.3.3 WeakSet.prototype.delete(value)
      'delete': function (key) {
        if (!isObject(key)) return false;
        var data = getWeak(key);
        if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);
        return data && $has(data, this._i) && delete data[this._i];
      },
      // 23.3.3.4 WeakMap.prototype.has(key)
      // 23.4.3.4 WeakSet.prototype.has(value)
      has: function has(key) {
        if (!isObject(key)) return false;
        var data = getWeak(key);
        if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);
        return data && $has(data, this._i);
      }
    });
    return C;
  },
  def: function (that, key, value) {
    var data = getWeak(anObject(key), true);
    if (data === true) uncaughtFrozenStore(that).set(key, value);
    else data[that._i] = value;
    return that;
  },
  ufstore: uncaughtFrozenStore
};


/***/ }),

/***/ "./node_modules/core-js/modules/_collection.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_collection.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
var meta = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var $iterDetect = __webpack_require__(/*! ./_iter-detect */ "./node_modules/core-js/modules/_iter-detect.js");
var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js");
var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/core-js/modules/_inherit-if-required.js");

module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
  var Base = global[NAME];
  var C = Base;
  var ADDER = IS_MAP ? 'set' : 'add';
  var proto = C && C.prototype;
  var O = {};
  var fixMethod = function (KEY) {
    var fn = proto[KEY];
    redefine(proto, KEY,
      KEY == 'delete' ? function (a) {
        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
      } : KEY == 'has' ? function has(a) {
        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
      } : KEY == 'get' ? function get(a) {
        return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
      } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }
        : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }
    );
  };
  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {
    new C().entries().next();
  }))) {
    // create collection constructor
    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
    redefineAll(C.prototype, methods);
    meta.NEED = true;
  } else {
    var instance = new C();
    // early implementations not supports chaining
    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
    // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false
    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });
    // most early implementations doesn't supports iterables, most modern - not close it correctly
    var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new
    // for early implementations -0 and +0 not the same
    var BUGGY_ZERO = !IS_WEAK && fails(function () {
      // V8 ~ Chromium 42- fails only with 5+ elements
      var $instance = new C();
      var index = 5;
      while (index--) $instance[ADDER](index, index);
      return !$instance.has(-0);
    });
    if (!ACCEPT_ITERABLES) {
      C = wrapper(function (target, iterable) {
        anInstance(target, C, NAME);
        var that = inheritIfRequired(new Base(), target, C);
        if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
        return that;
      });
      C.prototype = proto;
      proto.constructor = C;
    }
    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
      fixMethod('delete');
      fixMethod('has');
      IS_MAP && fixMethod('get');
    }
    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
    // weak collections should not contains .clear method
    if (IS_WEAK && proto.clear) delete proto.clear;
  }

  setToStringTag(C, NAME);

  O[NAME] = C;
  $export($export.G + $export.W + $export.F * (C != Base), O);

  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);

  return C;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_core.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_core.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var core = module.exports = { version: '2.6.4' };
if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef


/***/ }),

/***/ "./node_modules/core-js/modules/_create-property.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_create-property.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");

module.exports = function (object, index, value) {
  if (index in object) $defineProperty.f(object, index, createDesc(0, value));
  else object[index] = value;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_ctx.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_ctx.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// optional / simple context binding
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
module.exports = function (fn, that, length) {
  aFunction(fn);
  if (that === undefined) return fn;
  switch (length) {
    case 1: return function (a) {
      return fn.call(that, a);
    };
    case 2: return function (a, b) {
      return fn.call(that, a, b);
    };
    case 3: return function (a, b, c) {
      return fn.call(that, a, b, c);
    };
  }
  return function (/* ...args */) {
    return fn.apply(that, arguments);
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_date-to-iso-string.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_date-to-iso-string.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var getTime = Date.prototype.getTime;
var $toISOString = Date.prototype.toISOString;

var lz = function (num) {
  return num > 9 ? num : '0' + num;
};

// PhantomJS / old WebKit has a broken implementations
module.exports = (fails(function () {
  return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z';
}) || !fails(function () {
  $toISOString.call(new Date(NaN));
})) ? function toISOString() {
  if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value');
  var d = this;
  var y = d.getUTCFullYear();
  var m = d.getUTCMilliseconds();
  var s = y < 0 ? '-' : y > 9999 ? '+' : '';
  return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +
    '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +
    'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +
    ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';
} : $toISOString;


/***/ }),

/***/ "./node_modules/core-js/modules/_date-to-primitive.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_date-to-primitive.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var NUMBER = 'number';

module.exports = function (hint) {
  if (hint !== 'string' && hint !== NUMBER && hint !== 'default') throw TypeError('Incorrect hint');
  return toPrimitive(anObject(this), hint != NUMBER);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_defined.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_defined.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 7.2.1 RequireObjectCoercible(argument)
module.exports = function (it) {
  if (it == undefined) throw TypeError("Can't call method on  " + it);
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_descriptors.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_descriptors.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// Thank's IE8 for his funny defineProperty
module.exports = !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
});


/***/ }),

/***/ "./node_modules/core-js/modules/_dom-create.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_dom-create.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var document = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").document;
// typeof document.createElement is 'object' in old IE
var is = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
  return is ? document.createElement(it) : {};
};


/***/ }),

/***/ "./node_modules/core-js/modules/_enum-bug-keys.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_enum-bug-keys.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// IE 8- don't enum bug keys
module.exports = (
  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'
).split(',');


/***/ }),

/***/ "./node_modules/core-js/modules/_enum-keys.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_enum-keys.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// all enumerable object keys, includes symbols
var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");
var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/core-js/modules/_object-gops.js");
var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/core-js/modules/_object-pie.js");
module.exports = function (it) {
  var result = getKeys(it);
  var getSymbols = gOPS.f;
  if (getSymbols) {
    var symbols = getSymbols(it);
    var isEnum = pIE.f;
    var i = 0;
    var key;
    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);
  } return result;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_export.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_export.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var PROTOTYPE = 'prototype';

var $export = function (type, name, source) {
  var IS_FORCED = type & $export.F;
  var IS_GLOBAL = type & $export.G;
  var IS_STATIC = type & $export.S;
  var IS_PROTO = type & $export.P;
  var IS_BIND = type & $export.B;
  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
  var key, own, out, exp;
  if (IS_GLOBAL) source = name;
  for (key in source) {
    // contains in native
    own = !IS_FORCED && target && target[key] !== undefined;
    // export native or passed
    out = (own ? target : source)[key];
    // bind timers to global for call from export context
    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
    // extend global
    if (target) redefine(target, key, out, type & $export.U);
    // export
    if (exports[key] != out) hide(exports, key, exp);
    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
  }
};
global.core = core;
// type bitmap
$export.F = 1;   // forced
$export.G = 2;   // global
$export.S = 4;   // static
$export.P = 8;   // proto
$export.B = 16;  // bind
$export.W = 32;  // wrap
$export.U = 64;  // safe
$export.R = 128; // real proto method for `library`
module.exports = $export;


/***/ }),

/***/ "./node_modules/core-js/modules/_fails-is-regexp.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_fails-is-regexp.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var MATCH = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('match');
module.exports = function (KEY) {
  var re = /./;
  try {
    '/./'[KEY](re);
  } catch (e) {
    try {
      re[MATCH] = false;
      return !'/./'[KEY](re);
    } catch (f) { /* empty */ }
  } return true;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_fails.js":
/*!************************************************!*\
  !*** ./node_modules/core-js/modules/_fails.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (exec) {
  try {
    return !!exec();
  } catch (e) {
    return true;
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_fix-re-wks.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_fix-re-wks.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

__webpack_require__(/*! ./es6.regexp.exec */ "./node_modules/core-js/modules/es6.regexp.exec.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
var wks = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");
var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/core-js/modules/_regexp-exec.js");

var SPECIES = wks('species');

var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
  // #replace needs built-in support for named groups.
  // #match works fine because it just return the exec results, even if it has
  // a "grops" property.
  var re = /./;
  re.exec = function () {
    var result = [];
    result.groups = { a: '7' };
    return result;
  };
  return ''.replace(re, '$') !== '7';
});

var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {
  // Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
  var re = /(?:)/;
  var originalExec = re.exec;
  re.exec = function () { return originalExec.apply(this, arguments); };
  var result = 'ab'.split(re);
  return result.length === 2 && result[0] === 'a' && result[1] === 'b';
})();

module.exports = function (KEY, length, exec) {
  var SYMBOL = wks(KEY);

  var DELEGATES_TO_SYMBOL = !fails(function () {
    // String methods call symbol-named RegEp methods
    var O = {};
    O[SYMBOL] = function () { return 7; };
    return ''[KEY](O) != 7;
  });

  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {
    // Symbol-named RegExp methods call .exec
    var execCalled = false;
    var re = /a/;
    re.exec = function () { execCalled = true; return null; };
    if (KEY === 'split') {
      // RegExp[@@split] doesn't call the regex's exec method, but first creates
      // a new one. We need to return the patched regex when creating the new one.
      re.constructor = {};
      re.constructor[SPECIES] = function () { return re; };
    }
    re[SYMBOL]('');
    return !execCalled;
  }) : undefined;

  if (
    !DELEGATES_TO_SYMBOL ||
    !DELEGATES_TO_EXEC ||
    (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||
    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)
  ) {
    var nativeRegExpMethod = /./[SYMBOL];
    var fns = exec(
      defined,
      SYMBOL,
      ''[KEY],
      function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) {
        if (regexp.exec === regexpExec) {
          if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
            // The native String method already delegates to @@method (this
            // polyfilled function), leasing to infinite recursion.
            // We avoid it by directly calling the native @@method method.
            return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };
          }
          return { done: true, value: nativeMethod.call(str, regexp, arg2) };
        }
        return { done: false };
      }
    );
    var strfn = fns[0];
    var rxfn = fns[1];

    redefine(String.prototype, KEY, strfn);
    hide(RegExp.prototype, SYMBOL, length == 2
      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)
      // 21.2.5.11 RegExp.prototype[@@split](string, limit)
      ? function (string, arg) { return rxfn.call(string, this, arg); }
      // 21.2.5.6 RegExp.prototype[@@match](string)
      // 21.2.5.9 RegExp.prototype[@@search](string)
      : function (string) { return rxfn.call(string, this); }
    );
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_flags.js":
/*!************************************************!*\
  !*** ./node_modules/core-js/modules/_flags.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 21.2.5.3 get RegExp.prototype.flags
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
module.exports = function () {
  var that = anObject(this);
  var result = '';
  if (that.global) result += 'g';
  if (that.ignoreCase) result += 'i';
  if (that.multiline) result += 'm';
  if (that.unicode) result += 'u';
  if (that.sticky) result += 'y';
  return result;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_flatten-into-array.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_flatten-into-array.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/core-js/modules/_is-array.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var IS_CONCAT_SPREADABLE = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('isConcatSpreadable');

function flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) {
  var targetIndex = start;
  var sourceIndex = 0;
  var mapFn = mapper ? ctx(mapper, thisArg, 3) : false;
  var element, spreadable;

  while (sourceIndex < sourceLen) {
    if (sourceIndex in source) {
      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];

      spreadable = false;
      if (isObject(element)) {
        spreadable = element[IS_CONCAT_SPREADABLE];
        spreadable = spreadable !== undefined ? !!spreadable : isArray(element);
      }

      if (spreadable && depth > 0) {
        targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;
      } else {
        if (targetIndex >= 0x1fffffffffffff) throw TypeError();
        target[targetIndex] = element;
      }

      targetIndex++;
    }
    sourceIndex++;
  }
  return targetIndex;
}

module.exports = flattenIntoArray;


/***/ }),

/***/ "./node_modules/core-js/modules/_for-of.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_for-of.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var call = __webpack_require__(/*! ./_iter-call */ "./node_modules/core-js/modules/_iter-call.js");
var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/core-js/modules/_is-array-iter.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/core-js/modules/core.get-iterator-method.js");
var BREAK = {};
var RETURN = {};
var exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);
  var f = ctx(fn, that, entries ? 2 : 1);
  var index = 0;
  var length, step, iterator, result;
  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
  // fast case for arrays with default iterator
  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
    if (result === BREAK || result === RETURN) return result;
  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
    result = call(iterator, f, step.value, entries);
    if (result === BREAK || result === RETURN) return result;
  }
};
exports.BREAK = BREAK;
exports.RETURN = RETURN;


/***/ }),

/***/ "./node_modules/core-js/modules/_function-to-string.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/_function-to-string.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js")('native-function-to-string', Function.toString);


/***/ }),

/***/ "./node_modules/core-js/modules/_global.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_global.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
var global = module.exports = typeof window != 'undefined' && window.Math == Math
  ? window : typeof self != 'undefined' && self.Math == Math ? self
  // eslint-disable-next-line no-new-func
  : Function('return this')();
if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef


/***/ }),

/***/ "./node_modules/core-js/modules/_has.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_has.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var hasOwnProperty = {}.hasOwnProperty;
module.exports = function (it, key) {
  return hasOwnProperty.call(it, key);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_hide.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_hide.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
module.exports = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? function (object, key, value) {
  return dP.f(object, key, createDesc(1, value));
} : function (object, key, value) {
  object[key] = value;
  return object;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_html.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_html.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var document = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").document;
module.exports = document && document.documentElement;


/***/ }),

/***/ "./node_modules/core-js/modules/_ie8-dom-define.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/_ie8-dom-define.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

module.exports = !__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return Object.defineProperty(__webpack_require__(/*! ./_dom-create */ "./node_modules/core-js/modules/_dom-create.js")('div'), 'a', { get: function () { return 7; } }).a != 7;
});


/***/ }),

/***/ "./node_modules/core-js/modules/_inherit-if-required.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/_inherit-if-required.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var setPrototypeOf = __webpack_require__(/*! ./_set-proto */ "./node_modules/core-js/modules/_set-proto.js").set;
module.exports = function (that, target, C) {
  var S = target.constructor;
  var P;
  if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {
    setPrototypeOf(that, P);
  } return that;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_invoke.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_invoke.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// fast apply, http://jsperf.lnkit.com/fast-apply/5
module.exports = function (fn, args, that) {
  var un = that === undefined;
  switch (args.length) {
    case 0: return un ? fn()
                      : fn.call(that);
    case 1: return un ? fn(args[0])
                      : fn.call(that, args[0]);
    case 2: return un ? fn(args[0], args[1])
                      : fn.call(that, args[0], args[1]);
    case 3: return un ? fn(args[0], args[1], args[2])
                      : fn.call(that, args[0], args[1], args[2]);
    case 4: return un ? fn(args[0], args[1], args[2], args[3])
                      : fn.call(that, args[0], args[1], args[2], args[3]);
  } return fn.apply(that, args);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iobject.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_iobject.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// fallback for non-array-like ES3 and non-enumerable old V8 strings
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
// eslint-disable-next-line no-prototype-builtins
module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
  return cof(it) == 'String' ? it.split('') : Object(it);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-array-iter.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_is-array-iter.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// check on default Array iterator
var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('iterator');
var ArrayProto = Array.prototype;

module.exports = function (it) {
  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-array.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_is-array.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.2 IsArray(argument)
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
module.exports = Array.isArray || function isArray(arg) {
  return cof(arg) == 'Array';
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-integer.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_is-integer.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.3 Number.isInteger(number)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var floor = Math.floor;
module.exports = function isInteger(it) {
  return !isObject(it) && isFinite(it) && floor(it) === it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_is-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (it) {
  return typeof it === 'object' ? it !== null : typeof it === 'function';
};


/***/ }),

/***/ "./node_modules/core-js/modules/_is-regexp.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_is-regexp.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.2.8 IsRegExp(argument)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
var MATCH = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('match');
module.exports = function (it) {
  var isRegExp;
  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iter-call.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_iter-call.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// call something on iterator step with safe closing on error
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
module.exports = function (iterator, fn, value, entries) {
  try {
    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  // 7.4.6 IteratorClose(iterator, completion)
  } catch (e) {
    var ret = iterator['return'];
    if (ret !== undefined) anObject(ret.call(iterator));
    throw e;
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iter-create.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_iter-create.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var create = __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js");
var descriptor = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js");
var IteratorPrototype = {};

// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
__webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js")(IteratorPrototype, __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('iterator'), function () { return this; });

module.exports = function (Constructor, NAME, next) {
  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });
  setToStringTag(Constructor, NAME + ' Iterator');
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iter-define.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_iter-define.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
var $iterCreate = __webpack_require__(/*! ./_iter-create */ "./node_modules/core-js/modules/_iter-create.js");
var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('iterator');
var BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`
var FF_ITERATOR = '@@iterator';
var KEYS = 'keys';
var VALUES = 'values';

var returnThis = function () { return this; };

module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
  $iterCreate(Constructor, NAME, next);
  var getMethod = function (kind) {
    if (!BUGGY && kind in proto) return proto[kind];
    switch (kind) {
      case KEYS: return function keys() { return new Constructor(this, kind); };
      case VALUES: return function values() { return new Constructor(this, kind); };
    } return function entries() { return new Constructor(this, kind); };
  };
  var TAG = NAME + ' Iterator';
  var DEF_VALUES = DEFAULT == VALUES;
  var VALUES_BUG = false;
  var proto = Base.prototype;
  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
  var $default = $native || getMethod(DEFAULT);
  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
  var methods, key, IteratorPrototype;
  // Fix native
  if ($anyNative) {
    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
      // Set @@toStringTag to native iterators
      setToStringTag(IteratorPrototype, TAG, true);
      // fix for some old engines
      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
    }
  }
  // fix Array#{values, @@iterator}.name in V8 / FF
  if (DEF_VALUES && $native && $native.name !== VALUES) {
    VALUES_BUG = true;
    $default = function values() { return $native.call(this); };
  }
  // Define iterator
  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
    hide(proto, ITERATOR, $default);
  }
  // Plug for library
  Iterators[NAME] = $default;
  Iterators[TAG] = returnThis;
  if (DEFAULT) {
    methods = {
      values: DEF_VALUES ? $default : getMethod(VALUES),
      keys: IS_SET ? $default : getMethod(KEYS),
      entries: $entries
    };
    if (FORCED) for (key in methods) {
      if (!(key in proto)) redefine(proto, key, methods[key]);
    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
  }
  return methods;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iter-detect.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_iter-detect.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('iterator');
var SAFE_CLOSING = false;

try {
  var riter = [7][ITERATOR]();
  riter['return'] = function () { SAFE_CLOSING = true; };
  // eslint-disable-next-line no-throw-literal
  Array.from(riter, function () { throw 2; });
} catch (e) { /* empty */ }

module.exports = function (exec, skipClosing) {
  if (!skipClosing && !SAFE_CLOSING) return false;
  var safe = false;
  try {
    var arr = [7];
    var iter = arr[ITERATOR]();
    iter.next = function () { return { done: safe = true }; };
    arr[ITERATOR] = function () { return iter; };
    exec(arr);
  } catch (e) { /* empty */ }
  return safe;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iter-step.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_iter-step.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (done, value) {
  return { value: value, done: !!done };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_iterators.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_iterators.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = {};


/***/ }),

/***/ "./node_modules/core-js/modules/_library.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_library.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = false;


/***/ }),

/***/ "./node_modules/core-js/modules/_math-expm1.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_math-expm1.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 20.2.2.14 Math.expm1(x)
var $expm1 = Math.expm1;
module.exports = (!$expm1
  // Old FF bug
  || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
  // Tor Browser bug
  || $expm1(-2e-17) != -2e-17
) ? function expm1(x) {
  return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;
} : $expm1;


/***/ }),

/***/ "./node_modules/core-js/modules/_math-fround.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_math-fround.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.16 Math.fround(x)
var sign = __webpack_require__(/*! ./_math-sign */ "./node_modules/core-js/modules/_math-sign.js");
var pow = Math.pow;
var EPSILON = pow(2, -52);
var EPSILON32 = pow(2, -23);
var MAX32 = pow(2, 127) * (2 - EPSILON32);
var MIN32 = pow(2, -126);

var roundTiesToEven = function (n) {
  return n + 1 / EPSILON - 1 / EPSILON;
};

module.exports = Math.fround || function fround(x) {
  var $abs = Math.abs(x);
  var $sign = sign(x);
  var a, result;
  if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
  a = (1 + EPSILON32 / EPSILON) * $abs;
  result = a - (a - $abs);
  // eslint-disable-next-line no-self-compare
  if (result > MAX32 || result != result) return $sign * Infinity;
  return $sign * result;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_math-log1p.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_math-log1p.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 20.2.2.20 Math.log1p(x)
module.exports = Math.log1p || function log1p(x) {
  return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_math-scale.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_math-scale.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// https://rwaldron.github.io/proposal-math-extensions/
module.exports = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) {
  if (
    arguments.length === 0
      // eslint-disable-next-line no-self-compare
      || x != x
      // eslint-disable-next-line no-self-compare
      || inLow != inLow
      // eslint-disable-next-line no-self-compare
      || inHigh != inHigh
      // eslint-disable-next-line no-self-compare
      || outLow != outLow
      // eslint-disable-next-line no-self-compare
      || outHigh != outHigh
  ) return NaN;
  if (x === Infinity || x === -Infinity) return x;
  return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_math-sign.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_math-sign.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 20.2.2.28 Math.sign(x)
module.exports = Math.sign || function sign(x) {
  // eslint-disable-next-line no-self-compare
  return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_meta.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_meta.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var META = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js")('meta');
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var setDesc = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var id = 0;
var isExtensible = Object.isExtensible || function () {
  return true;
};
var FREEZE = !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return isExtensible(Object.preventExtensions({}));
});
var setMeta = function (it) {
  setDesc(it, META, { value: {
    i: 'O' + ++id, // object ID
    w: {}          // weak collections IDs
  } });
};
var fastKey = function (it, create) {
  // return primitive with prefix
  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
  if (!has(it, META)) {
    // can't set metadata to uncaught frozen object
    if (!isExtensible(it)) return 'F';
    // not necessary to add metadata
    if (!create) return 'E';
    // add missing metadata
    setMeta(it);
  // return object ID
  } return it[META].i;
};
var getWeak = function (it, create) {
  if (!has(it, META)) {
    // can't set metadata to uncaught frozen object
    if (!isExtensible(it)) return true;
    // not necessary to add metadata
    if (!create) return false;
    // add missing metadata
    setMeta(it);
  // return hash weak collections IDs
  } return it[META].w;
};
// add metadata on freeze-family methods calling
var onFreeze = function (it) {
  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
  return it;
};
var meta = module.exports = {
  KEY: META,
  NEED: false,
  fastKey: fastKey,
  getWeak: getWeak,
  onFreeze: onFreeze
};


/***/ }),

/***/ "./node_modules/core-js/modules/_metadata.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_metadata.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Map = __webpack_require__(/*! ./es6.map */ "./node_modules/core-js/modules/es6.map.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var shared = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js")('metadata');
var store = shared.store || (shared.store = new (__webpack_require__(/*! ./es6.weak-map */ "./node_modules/core-js/modules/es6.weak-map.js"))());

var getOrCreateMetadataMap = function (target, targetKey, create) {
  var targetMetadata = store.get(target);
  if (!targetMetadata) {
    if (!create) return undefined;
    store.set(target, targetMetadata = new Map());
  }
  var keyMetadata = targetMetadata.get(targetKey);
  if (!keyMetadata) {
    if (!create) return undefined;
    targetMetadata.set(targetKey, keyMetadata = new Map());
  } return keyMetadata;
};
var ordinaryHasOwnMetadata = function (MetadataKey, O, P) {
  var metadataMap = getOrCreateMetadataMap(O, P, false);
  return metadataMap === undefined ? false : metadataMap.has(MetadataKey);
};
var ordinaryGetOwnMetadata = function (MetadataKey, O, P) {
  var metadataMap = getOrCreateMetadataMap(O, P, false);
  return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);
};
var ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) {
  getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);
};
var ordinaryOwnMetadataKeys = function (target, targetKey) {
  var metadataMap = getOrCreateMetadataMap(target, targetKey, false);
  var keys = [];
  if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); });
  return keys;
};
var toMetaKey = function (it) {
  return it === undefined || typeof it == 'symbol' ? it : String(it);
};
var exp = function (O) {
  $export($export.S, 'Reflect', O);
};

module.exports = {
  store: store,
  map: getOrCreateMetadataMap,
  has: ordinaryHasOwnMetadata,
  get: ordinaryGetOwnMetadata,
  set: ordinaryDefineOwnMetadata,
  keys: ordinaryOwnMetadataKeys,
  key: toMetaKey,
  exp: exp
};


/***/ }),

/***/ "./node_modules/core-js/modules/_microtask.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_microtask.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var macrotask = __webpack_require__(/*! ./_task */ "./node_modules/core-js/modules/_task.js").set;
var Observer = global.MutationObserver || global.WebKitMutationObserver;
var process = global.process;
var Promise = global.Promise;
var isNode = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js")(process) == 'process';

module.exports = function () {
  var head, last, notify;

  var flush = function () {
    var parent, fn;
    if (isNode && (parent = process.domain)) parent.exit();
    while (head) {
      fn = head.fn;
      head = head.next;
      try {
        fn();
      } catch (e) {
        if (head) notify();
        else last = undefined;
        throw e;
      }
    } last = undefined;
    if (parent) parent.enter();
  };

  // Node.js
  if (isNode) {
    notify = function () {
      process.nextTick(flush);
    };
  // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339
  } else if (Observer && !(global.navigator && global.navigator.standalone)) {
    var toggle = true;
    var node = document.createTextNode('');
    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new
    notify = function () {
      node.data = toggle = !toggle;
    };
  // environments with maybe non-completely correct, but existent Promise
  } else if (Promise && Promise.resolve) {
    // Promise.resolve without an argument throws an error in LG WebOS 2
    var promise = Promise.resolve(undefined);
    notify = function () {
      promise.then(flush);
    };
  // for other environments - macrotask based on:
  // - setImmediate
  // - MessageChannel
  // - window.postMessag
  // - onreadystatechange
  // - setTimeout
  } else {
    notify = function () {
      // strange IE + webpack dev server bug - use .call(global)
      macrotask.call(global, flush);
    };
  }

  return function (fn) {
    var task = { fn: fn, next: undefined };
    if (last) last.next = task;
    if (!head) {
      head = task;
      notify();
    } last = task;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_new-promise-capability.js":
/*!*****************************************************************!*\
  !*** ./node_modules/core-js/modules/_new-promise-capability.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 25.4.1.5 NewPromiseCapability(C)
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");

function PromiseCapability(C) {
  var resolve, reject;
  this.promise = new C(function ($$resolve, $$reject) {
    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
    resolve = $$resolve;
    reject = $$reject;
  });
  this.resolve = aFunction(resolve);
  this.reject = aFunction(reject);
}

module.exports.f = function (C) {
  return new PromiseCapability(C);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-assign.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_object-assign.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 19.1.2.1 Object.assign(target, source, ...)
var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");
var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/core-js/modules/_object-gops.js");
var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/core-js/modules/_object-pie.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js");
var $assign = Object.assign;

// should work with symbols and should have deterministic property order (V8 bug)
module.exports = !$assign || __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  var A = {};
  var B = {};
  // eslint-disable-next-line no-undef
  var S = Symbol();
  var K = 'abcdefghijklmnopqrst';
  A[S] = 7;
  K.split('').forEach(function (k) { B[k] = k; });
  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars
  var T = toObject(target);
  var aLen = arguments.length;
  var index = 1;
  var getSymbols = gOPS.f;
  var isEnum = pIE.f;
  while (aLen > index) {
    var S = IObject(arguments[index++]);
    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
    var length = keys.length;
    var j = 0;
    var key;
    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];
  } return T;
} : $assign;


/***/ }),

/***/ "./node_modules/core-js/modules/_object-create.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_object-create.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var dPs = __webpack_require__(/*! ./_object-dps */ "./node_modules/core-js/modules/_object-dps.js");
var enumBugKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/core-js/modules/_enum-bug-keys.js");
var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/core-js/modules/_shared-key.js")('IE_PROTO');
var Empty = function () { /* empty */ };
var PROTOTYPE = 'prototype';

// Create object with fake `null` prototype: use iframe Object with cleared prototype
var createDict = function () {
  // Thrash, waste and sodomy: IE GC bug
  var iframe = __webpack_require__(/*! ./_dom-create */ "./node_modules/core-js/modules/_dom-create.js")('iframe');
  var i = enumBugKeys.length;
  var lt = '<';
  var gt = '>';
  var iframeDocument;
  iframe.style.display = 'none';
  __webpack_require__(/*! ./_html */ "./node_modules/core-js/modules/_html.js").appendChild(iframe);
  iframe.src = 'javascript:'; // eslint-disable-line no-script-url
  // createDict = iframe.contentWindow.Object;
  // html.removeChild(iframe);
  iframeDocument = iframe.contentWindow.document;
  iframeDocument.open();
  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
  iframeDocument.close();
  createDict = iframeDocument.F;
  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];
  return createDict();
};

module.exports = Object.create || function create(O, Properties) {
  var result;
  if (O !== null) {
    Empty[PROTOTYPE] = anObject(O);
    result = new Empty();
    Empty[PROTOTYPE] = null;
    // add "__proto__" for Object.getPrototypeOf polyfill
    result[IE_PROTO] = O;
  } else result = createDict();
  return Properties === undefined ? result : dPs(result, Properties);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-dp.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-dp.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var IE8_DOM_DEFINE = __webpack_require__(/*! ./_ie8-dom-define */ "./node_modules/core-js/modules/_ie8-dom-define.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var dP = Object.defineProperty;

exports.f = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? Object.defineProperty : function defineProperty(O, P, Attributes) {
  anObject(O);
  P = toPrimitive(P, true);
  anObject(Attributes);
  if (IE8_DOM_DEFINE) try {
    return dP(O, P, Attributes);
  } catch (e) { /* empty */ }
  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
  if ('value' in Attributes) O[P] = Attributes.value;
  return O;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-dps.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-dps.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");

module.exports = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? Object.defineProperties : function defineProperties(O, Properties) {
  anObject(O);
  var keys = getKeys(Properties);
  var length = keys.length;
  var i = 0;
  var P;
  while (length > i) dP.f(O, P = keys[i++], Properties[P]);
  return O;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-forced-pam.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_object-forced-pam.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// Forced replacement prototype accessors methods
module.exports = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js") || !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  var K = Math.random();
  // In FF throws only define methods
  // eslint-disable-next-line no-undef, no-useless-call
  __defineSetter__.call(null, K, function () { /* empty */ });
  delete __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js")[K];
});


/***/ }),

/***/ "./node_modules/core-js/modules/_object-gopd.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_object-gopd.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var pIE = __webpack_require__(/*! ./_object-pie */ "./node_modules/core-js/modules/_object-pie.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var IE8_DOM_DEFINE = __webpack_require__(/*! ./_ie8-dom-define */ "./node_modules/core-js/modules/_ie8-dom-define.js");
var gOPD = Object.getOwnPropertyDescriptor;

exports.f = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? gOPD : function getOwnPropertyDescriptor(O, P) {
  O = toIObject(O);
  P = toPrimitive(P, true);
  if (IE8_DOM_DEFINE) try {
    return gOPD(O, P);
  } catch (e) { /* empty */ }
  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-gopn-ext.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_object-gopn-ext.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f;
var toString = {}.toString;

var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
  ? Object.getOwnPropertyNames(window) : [];

var getWindowNames = function (it) {
  try {
    return gOPN(it);
  } catch (e) {
    return windowNames.slice();
  }
};

module.exports.f = function getOwnPropertyNames(it) {
  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-gopn.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_object-gopn.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
var $keys = __webpack_require__(/*! ./_object-keys-internal */ "./node_modules/core-js/modules/_object-keys-internal.js");
var hiddenKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/core-js/modules/_enum-bug-keys.js").concat('length', 'prototype');

exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
  return $keys(O, hiddenKeys);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-gops.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_object-gops.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

exports.f = Object.getOwnPropertySymbols;


/***/ }),

/***/ "./node_modules/core-js/modules/_object-gpo.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-gpo.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/core-js/modules/_shared-key.js")('IE_PROTO');
var ObjectProto = Object.prototype;

module.exports = Object.getPrototypeOf || function (O) {
  O = toObject(O);
  if (has(O, IE_PROTO)) return O[IE_PROTO];
  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
    return O.constructor.prototype;
  } return O instanceof Object ? ObjectProto : null;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-keys-internal.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/_object-keys-internal.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var arrayIndexOf = __webpack_require__(/*! ./_array-includes */ "./node_modules/core-js/modules/_array-includes.js")(false);
var IE_PROTO = __webpack_require__(/*! ./_shared-key */ "./node_modules/core-js/modules/_shared-key.js")('IE_PROTO');

module.exports = function (object, names) {
  var O = toIObject(object);
  var i = 0;
  var result = [];
  var key;
  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);
  // Don't enum bug & hidden keys
  while (names.length > i) if (has(O, key = names[i++])) {
    ~arrayIndexOf(result, key) || result.push(key);
  }
  return result;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-keys.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_object-keys.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 / 15.2.3.14 Object.keys(O)
var $keys = __webpack_require__(/*! ./_object-keys-internal */ "./node_modules/core-js/modules/_object-keys-internal.js");
var enumBugKeys = __webpack_require__(/*! ./_enum-bug-keys */ "./node_modules/core-js/modules/_enum-bug-keys.js");

module.exports = Object.keys || function keys(O) {
  return $keys(O, enumBugKeys);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-pie.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-pie.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

exports.f = {}.propertyIsEnumerable;


/***/ }),

/***/ "./node_modules/core-js/modules/_object-sap.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_object-sap.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// most Object methods by ES6 should accept primitives
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
module.exports = function (KEY, exec) {
  var fn = (core.Object || {})[KEY] || Object[KEY];
  var exp = {};
  exp[KEY] = exec(fn);
  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_object-to-array.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_object-to-array.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var isEnum = __webpack_require__(/*! ./_object-pie */ "./node_modules/core-js/modules/_object-pie.js").f;
module.exports = function (isEntries) {
  return function (it) {
    var O = toIObject(it);
    var keys = getKeys(O);
    var length = keys.length;
    var i = 0;
    var result = [];
    var key;
    while (length > i) if (isEnum.call(O, key = keys[i++])) {
      result.push(isEntries ? [key, O[key]] : O[key]);
    } return result;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_own-keys.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_own-keys.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// all object keys, includes non-enumerable and symbols
var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js");
var gOPS = __webpack_require__(/*! ./_object-gops */ "./node_modules/core-js/modules/_object-gops.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var Reflect = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").Reflect;
module.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {
  var keys = gOPN.f(anObject(it));
  var getSymbols = gOPS.f;
  return getSymbols ? keys.concat(getSymbols(it)) : keys;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_parse-float.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_parse-float.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $parseFloat = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").parseFloat;
var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js").trim;

module.exports = 1 / $parseFloat(__webpack_require__(/*! ./_string-ws */ "./node_modules/core-js/modules/_string-ws.js") + '-0') !== -Infinity ? function parseFloat(str) {
  var string = $trim(String(str), 3);
  var result = $parseFloat(string);
  return result === 0 && string.charAt(0) == '-' ? -0 : result;
} : $parseFloat;


/***/ }),

/***/ "./node_modules/core-js/modules/_parse-int.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_parse-int.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $parseInt = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").parseInt;
var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js").trim;
var ws = __webpack_require__(/*! ./_string-ws */ "./node_modules/core-js/modules/_string-ws.js");
var hex = /^[-+]?0[xX]/;

module.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix) {
  var string = $trim(String(str), 3);
  return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10));
} : $parseInt;


/***/ }),

/***/ "./node_modules/core-js/modules/_perform.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_perform.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (exec) {
  try {
    return { e: false, v: exec() };
  } catch (e) {
    return { e: true, v: e };
  }
};


/***/ }),

/***/ "./node_modules/core-js/modules/_promise-resolve.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/_promise-resolve.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var newPromiseCapability = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/core-js/modules/_new-promise-capability.js");

module.exports = function (C, x) {
  anObject(C);
  if (isObject(x) && x.constructor === C) return x;
  var promiseCapability = newPromiseCapability.f(C);
  var resolve = promiseCapability.resolve;
  resolve(x);
  return promiseCapability.promise;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_property-desc.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_property-desc.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (bitmap, value) {
  return {
    enumerable: !(bitmap & 1),
    configurable: !(bitmap & 2),
    writable: !(bitmap & 4),
    value: value
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_redefine-all.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/_redefine-all.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
module.exports = function (target, src, safe) {
  for (var key in src) redefine(target, key, src[key], safe);
  return target;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_redefine.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_redefine.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var SRC = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js")('src');
var $toString = __webpack_require__(/*! ./_function-to-string */ "./node_modules/core-js/modules/_function-to-string.js");
var TO_STRING = 'toString';
var TPL = ('' + $toString).split(TO_STRING);

__webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js").inspectSource = function (it) {
  return $toString.call(it);
};

(module.exports = function (O, key, val, safe) {
  var isFunction = typeof val == 'function';
  if (isFunction) has(val, 'name') || hide(val, 'name', key);
  if (O[key] === val) return;
  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
  if (O === global) {
    O[key] = val;
  } else if (!safe) {
    delete O[key];
    hide(O, key, val);
  } else if (O[key]) {
    O[key] = val;
  } else {
    hide(O, key, val);
  }
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, TO_STRING, function toString() {
  return typeof this == 'function' && this[SRC] || $toString.call(this);
});


/***/ }),

/***/ "./node_modules/core-js/modules/_regexp-exec-abstract.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/_regexp-exec-abstract.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
var builtinExec = RegExp.prototype.exec;

 // `RegExpExec` abstract operation
// https://tc39.github.io/ecma262/#sec-regexpexec
module.exports = function (R, S) {
  var exec = R.exec;
  if (typeof exec === 'function') {
    var result = exec.call(R, S);
    if (typeof result !== 'object') {
      throw new TypeError('RegExp exec method returned something other than an Object or null');
    }
    return result;
  }
  if (classof(R) !== 'RegExp') {
    throw new TypeError('RegExp#exec called on incompatible receiver');
  }
  return builtinExec.call(R, S);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_regexp-exec.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_regexp-exec.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var regexpFlags = __webpack_require__(/*! ./_flags */ "./node_modules/core-js/modules/_flags.js");

var nativeExec = RegExp.prototype.exec;
// This always refers to the native implementation, because the
// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,
// which loads this file before patching the method.
var nativeReplace = String.prototype.replace;

var patchedExec = nativeExec;

var LAST_INDEX = 'lastIndex';

var UPDATES_LAST_INDEX_WRONG = (function () {
  var re1 = /a/,
      re2 = /b*/g;
  nativeExec.call(re1, 'a');
  nativeExec.call(re2, 'a');
  return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0;
})();

// nonparticipating capturing group, copied from es5-shim's String#split patch.
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;

var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;

if (PATCH) {
  patchedExec = function exec(str) {
    var re = this;
    var lastIndex, reCopy, match, i;

    if (NPCG_INCLUDED) {
      reCopy = new RegExp('^' + re.source + '$(?!\\s)', regexpFlags.call(re));
    }
    if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX];

    match = nativeExec.call(re, str);

    if (UPDATES_LAST_INDEX_WRONG && match) {
      re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex;
    }
    if (NPCG_INCLUDED && match && match.length > 1) {
      // Fix browsers whose `exec` methods don't consistently return `undefined`
      // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
      // eslint-disable-next-line no-loop-func
      nativeReplace.call(match[0], reCopy, function () {
        for (i = 1; i < arguments.length - 2; i++) {
          if (arguments[i] === undefined) match[i] = undefined;
        }
      });
    }

    return match;
  };
}

module.exports = patchedExec;


/***/ }),

/***/ "./node_modules/core-js/modules/_replacer.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_replacer.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = function (regExp, replace) {
  var replacer = replace === Object(replace) ? function (part) {
    return replace[part];
  } : replace;
  return function (it) {
    return String(it).replace(regExp, replacer);
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_same-value.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_same-value.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 7.2.9 SameValue(x, y)
module.exports = Object.is || function is(x, y) {
  // eslint-disable-next-line no-self-compare
  return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_set-collection-from.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/_set-collection-from.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/proposal-setmap-offrom/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");

module.exports = function (COLLECTION) {
  $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {
    var mapFn = arguments[1];
    var mapping, A, n, cb;
    aFunction(this);
    mapping = mapFn !== undefined;
    if (mapping) aFunction(mapFn);
    if (source == undefined) return new this();
    A = [];
    if (mapping) {
      n = 0;
      cb = ctx(mapFn, arguments[2], 2);
      forOf(source, false, function (nextItem) {
        A.push(cb(nextItem, n++));
      });
    } else {
      forOf(source, false, A.push, A);
    }
    return new this(A);
  } });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_set-collection-of.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_set-collection-of.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/proposal-setmap-offrom/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

module.exports = function (COLLECTION) {
  $export($export.S, COLLECTION, { of: function of() {
    var length = arguments.length;
    var A = new Array(length);
    while (length--) A[length] = arguments[length];
    return new this(A);
  } });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_set-proto.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_set-proto.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// Works with __proto__ only. Old v8 can't work with null proto objects.
/* eslint-disable no-proto */
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var check = function (O, proto) {
  anObject(O);
  if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
};
module.exports = {
  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line
    function (test, buggy, set) {
      try {
        set = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js")(Function.call, __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f(Object.prototype, '__proto__').set, 2);
        set(test, []);
        buggy = !(test instanceof Array);
      } catch (e) { buggy = true; }
      return function setPrototypeOf(O, proto) {
        check(O, proto);
        if (buggy) O.__proto__ = proto;
        else set(O, proto);
        return O;
      };
    }({}, false) : undefined),
  check: check
};


/***/ }),

/***/ "./node_modules/core-js/modules/_set-species.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_set-species.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js");
var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('species');

module.exports = function (KEY) {
  var C = global[KEY];
  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
    configurable: true,
    get: function () { return this; }
  });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_set-to-string-tag.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_set-to-string-tag.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var def = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var TAG = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('toStringTag');

module.exports = function (it, tag, stat) {
  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_shared-key.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_shared-key.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var shared = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js")('keys');
var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
module.exports = function (key) {
  return shared[key] || (shared[key] = uid(key));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_shared.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/_shared.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var SHARED = '__core-js_shared__';
var store = global[SHARED] || (global[SHARED] = {});

(module.exports = function (key, value) {
  return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
  version: core.version,
  mode: __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js") ? 'pure' : 'global',
  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
});


/***/ }),

/***/ "./node_modules/core-js/modules/_species-constructor.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/_species-constructor.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.3.20 SpeciesConstructor(O, defaultConstructor)
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var SPECIES = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('species');
module.exports = function (O, D) {
  var C = anObject(O).constructor;
  var S;
  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_strict-method.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_strict-method.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");

module.exports = function (method, arg) {
  return !!method && fails(function () {
    // eslint-disable-next-line no-useless-call
    arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);
  });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-at.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_string-at.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
// true  -> String#at
// false -> String#codePointAt
module.exports = function (TO_STRING) {
  return function (that, pos) {
    var s = String(defined(that));
    var i = toInteger(pos);
    var l = s.length;
    var a, b;
    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
    a = s.charCodeAt(i);
    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
      ? TO_STRING ? s.charAt(i) : a
      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
  };
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-context.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/_string-context.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// helper for String#{startsWith, endsWith, includes}
var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/core-js/modules/_is-regexp.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");

module.exports = function (that, searchString, NAME) {
  if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!");
  return String(defined(that));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-html.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_string-html.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
var quot = /"/g;
// B.2.3.2.1 CreateHTML(string, tag, attribute, value)
var createHTML = function (string, tag, attribute, value) {
  var S = String(defined(string));
  var p1 = '<' + tag;
  if (attribute !== '') p1 += ' ' + attribute + '="' + String(value).replace(quot, '"') + '"';
  return p1 + '>' + S + '';
};
module.exports = function (NAME, exec) {
  var O = {};
  O[NAME] = exec(createHTML);
  $export($export.P + $export.F * fails(function () {
    var test = ''[NAME]('"');
    return test !== test.toLowerCase() || test.split('"').length > 3;
  }), 'String', O);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-pad.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_string-pad.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-string-pad-start-end
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var repeat = __webpack_require__(/*! ./_string-repeat */ "./node_modules/core-js/modules/_string-repeat.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");

module.exports = function (that, maxLength, fillString, left) {
  var S = String(defined(that));
  var stringLength = S.length;
  var fillStr = fillString === undefined ? ' ' : String(fillString);
  var intMaxLength = toLength(maxLength);
  if (intMaxLength <= stringLength || fillStr == '') return S;
  var fillLen = intMaxLength - stringLength;
  var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
  if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);
  return left ? stringFiller + S : S + stringFiller;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-repeat.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/_string-repeat.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");

module.exports = function repeat(count) {
  var str = String(defined(this));
  var res = '';
  var n = toInteger(count);
  if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");
  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str;
  return res;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_string-trim.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_string-trim.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var spaces = __webpack_require__(/*! ./_string-ws */ "./node_modules/core-js/modules/_string-ws.js");
var space = '[' + spaces + ']';
var non = '\u200b\u0085';
var ltrim = RegExp('^' + space + space + '*');
var rtrim = RegExp(space + space + '*$');

var exporter = function (KEY, exec, ALIAS) {
  var exp = {};
  var FORCE = fails(function () {
    return !!spaces[KEY]() || non[KEY]() != non;
  });
  var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY];
  if (ALIAS) exp[ALIAS] = fn;
  $export($export.P + $export.F * FORCE, 'String', exp);
};

// 1 -> String#trimLeft
// 2 -> String#trimRight
// 3 -> String#trim
var trim = exporter.trim = function (string, TYPE) {
  string = String(defined(string));
  if (TYPE & 1) string = string.replace(ltrim, '');
  if (TYPE & 2) string = string.replace(rtrim, '');
  return string;
};

module.exports = exporter;


/***/ }),

/***/ "./node_modules/core-js/modules/_string-ws.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_string-ws.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

module.exports = '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003' +
  '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';


/***/ }),

/***/ "./node_modules/core-js/modules/_task.js":
/*!***********************************************!*\
  !*** ./node_modules/core-js/modules/_task.js ***!
  \***********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var invoke = __webpack_require__(/*! ./_invoke */ "./node_modules/core-js/modules/_invoke.js");
var html = __webpack_require__(/*! ./_html */ "./node_modules/core-js/modules/_html.js");
var cel = __webpack_require__(/*! ./_dom-create */ "./node_modules/core-js/modules/_dom-create.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var process = global.process;
var setTask = global.setImmediate;
var clearTask = global.clearImmediate;
var MessageChannel = global.MessageChannel;
var Dispatch = global.Dispatch;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = 'onreadystatechange';
var defer, channel, port;
var run = function () {
  var id = +this;
  // eslint-disable-next-line no-prototype-builtins
  if (queue.hasOwnProperty(id)) {
    var fn = queue[id];
    delete queue[id];
    fn();
  }
};
var listener = function (event) {
  run.call(event.data);
};
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if (!setTask || !clearTask) {
  setTask = function setImmediate(fn) {
    var args = [];
    var i = 1;
    while (arguments.length > i) args.push(arguments[i++]);
    queue[++counter] = function () {
      // eslint-disable-next-line no-new-func
      invoke(typeof fn == 'function' ? fn : Function(fn), args);
    };
    defer(counter);
    return counter;
  };
  clearTask = function clearImmediate(id) {
    delete queue[id];
  };
  // Node.js 0.8-
  if (__webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js")(process) == 'process') {
    defer = function (id) {
      process.nextTick(ctx(run, id, 1));
    };
  // Sphere (JS game engine) Dispatch API
  } else if (Dispatch && Dispatch.now) {
    defer = function (id) {
      Dispatch.now(ctx(run, id, 1));
    };
  // Browsers with MessageChannel, includes WebWorkers
  } else if (MessageChannel) {
    channel = new MessageChannel();
    port = channel.port2;
    channel.port1.onmessage = listener;
    defer = ctx(port.postMessage, port, 1);
  // Browsers with postMessage, skip WebWorkers
  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
  } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
    defer = function (id) {
      global.postMessage(id + '', '*');
    };
    global.addEventListener('message', listener, false);
  // IE8-
  } else if (ONREADYSTATECHANGE in cel('script')) {
    defer = function (id) {
      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
        html.removeChild(this);
        run.call(id);
      };
    };
  // Rest old browsers
  } else {
    defer = function (id) {
      setTimeout(ctx(run, id, 1), 0);
    };
  }
}
module.exports = {
  set: setTask,
  clear: clearTask
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-absolute-index.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/_to-absolute-index.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var max = Math.max;
var min = Math.min;
module.exports = function (index, length) {
  index = toInteger(index);
  return index < 0 ? max(index + length, 0) : min(index, length);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-index.js":
/*!***************************************************!*\
  !*** ./node_modules/core-js/modules/_to-index.js ***!
  \***************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/ecma262/#sec-toindex
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
module.exports = function (it) {
  if (it === undefined) return 0;
  var number = toInteger(it);
  var length = toLength(number);
  if (number !== length) throw RangeError('Wrong length!');
  return length;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-integer.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-integer.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// 7.1.4 ToInteger
var ceil = Math.ceil;
var floor = Math.floor;
module.exports = function (it) {
  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-iobject.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-iobject.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// to indexed object, toObject with fallback for non-array-like ES3 strings
var IObject = __webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
module.exports = function (it) {
  return IObject(defined(it));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-length.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-length.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.15 ToLength
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var min = Math.min;
module.exports = function (it) {
  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-object.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/_to-object.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.13 ToObject(argument)
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
module.exports = function (it) {
  return Object(defined(it));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_to-primitive.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/_to-primitive.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 7.1.1 ToPrimitive(input [, PreferredType])
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
// and the second argument - flag - preferred type is a string
module.exports = function (it, S) {
  if (!isObject(it)) return it;
  var fn, val;
  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
  throw TypeError("Can't convert object to primitive value");
};


/***/ }),

/***/ "./node_modules/core-js/modules/_typed-array.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/_typed-array.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

if (__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js")) {
  var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js");
  var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
  var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
  var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
  var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/core-js/modules/_typed.js");
  var $buffer = __webpack_require__(/*! ./_typed-buffer */ "./node_modules/core-js/modules/_typed-buffer.js");
  var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
  var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
  var propertyDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
  var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
  var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
  var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
  var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
  var toIndex = __webpack_require__(/*! ./_to-index */ "./node_modules/core-js/modules/_to-index.js");
  var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
  var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
  var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
  var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
  var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
  var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
  var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/core-js/modules/_is-array-iter.js");
  var create = __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js");
  var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
  var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f;
  var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/core-js/modules/core.get-iterator-method.js");
  var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
  var wks = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");
  var createArrayMethod = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js");
  var createArrayIncludes = __webpack_require__(/*! ./_array-includes */ "./node_modules/core-js/modules/_array-includes.js");
  var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/core-js/modules/_species-constructor.js");
  var ArrayIterators = __webpack_require__(/*! ./es6.array.iterator */ "./node_modules/core-js/modules/es6.array.iterator.js");
  var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
  var $iterDetect = __webpack_require__(/*! ./_iter-detect */ "./node_modules/core-js/modules/_iter-detect.js");
  var setSpecies = __webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js");
  var arrayFill = __webpack_require__(/*! ./_array-fill */ "./node_modules/core-js/modules/_array-fill.js");
  var arrayCopyWithin = __webpack_require__(/*! ./_array-copy-within */ "./node_modules/core-js/modules/_array-copy-within.js");
  var $DP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
  var $GOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
  var dP = $DP.f;
  var gOPD = $GOPD.f;
  var RangeError = global.RangeError;
  var TypeError = global.TypeError;
  var Uint8Array = global.Uint8Array;
  var ARRAY_BUFFER = 'ArrayBuffer';
  var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;
  var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
  var PROTOTYPE = 'prototype';
  var ArrayProto = Array[PROTOTYPE];
  var $ArrayBuffer = $buffer.ArrayBuffer;
  var $DataView = $buffer.DataView;
  var arrayForEach = createArrayMethod(0);
  var arrayFilter = createArrayMethod(2);
  var arraySome = createArrayMethod(3);
  var arrayEvery = createArrayMethod(4);
  var arrayFind = createArrayMethod(5);
  var arrayFindIndex = createArrayMethod(6);
  var arrayIncludes = createArrayIncludes(true);
  var arrayIndexOf = createArrayIncludes(false);
  var arrayValues = ArrayIterators.values;
  var arrayKeys = ArrayIterators.keys;
  var arrayEntries = ArrayIterators.entries;
  var arrayLastIndexOf = ArrayProto.lastIndexOf;
  var arrayReduce = ArrayProto.reduce;
  var arrayReduceRight = ArrayProto.reduceRight;
  var arrayJoin = ArrayProto.join;
  var arraySort = ArrayProto.sort;
  var arraySlice = ArrayProto.slice;
  var arrayToString = ArrayProto.toString;
  var arrayToLocaleString = ArrayProto.toLocaleString;
  var ITERATOR = wks('iterator');
  var TAG = wks('toStringTag');
  var TYPED_CONSTRUCTOR = uid('typed_constructor');
  var DEF_CONSTRUCTOR = uid('def_constructor');
  var ALL_CONSTRUCTORS = $typed.CONSTR;
  var TYPED_ARRAY = $typed.TYPED;
  var VIEW = $typed.VIEW;
  var WRONG_LENGTH = 'Wrong length!';

  var $map = createArrayMethod(1, function (O, length) {
    return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);
  });

  var LITTLE_ENDIAN = fails(function () {
    // eslint-disable-next-line no-undef
    return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;
  });

  var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {
    new Uint8Array(1).set({});
  });

  var toOffset = function (it, BYTES) {
    var offset = toInteger(it);
    if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');
    return offset;
  };

  var validate = function (it) {
    if (isObject(it) && TYPED_ARRAY in it) return it;
    throw TypeError(it + ' is not a typed array!');
  };

  var allocate = function (C, length) {
    if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {
      throw TypeError('It is not a typed array constructor!');
    } return new C(length);
  };

  var speciesFromList = function (O, list) {
    return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);
  };

  var fromList = function (C, list) {
    var index = 0;
    var length = list.length;
    var result = allocate(C, length);
    while (length > index) result[index] = list[index++];
    return result;
  };

  var addGetter = function (it, key, internal) {
    dP(it, key, { get: function () { return this._d[internal]; } });
  };

  var $from = function from(source /* , mapfn, thisArg */) {
    var O = toObject(source);
    var aLen = arguments.length;
    var mapfn = aLen > 1 ? arguments[1] : undefined;
    var mapping = mapfn !== undefined;
    var iterFn = getIterFn(O);
    var i, length, values, result, step, iterator;
    if (iterFn != undefined && !isArrayIter(iterFn)) {
      for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {
        values.push(step.value);
      } O = values;
    }
    if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);
    for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {
      result[i] = mapping ? mapfn(O[i], i) : O[i];
    }
    return result;
  };

  var $of = function of(/* ...items */) {
    var index = 0;
    var length = arguments.length;
    var result = allocate(this, length);
    while (length > index) result[index] = arguments[index++];
    return result;
  };

  // iOS Safari 6.x fails here
  var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });

  var $toLocaleString = function toLocaleString() {
    return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);
  };

  var proto = {
    copyWithin: function copyWithin(target, start /* , end */) {
      return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
    },
    every: function every(callbackfn /* , thisArg */) {
      return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
    },
    fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars
      return arrayFill.apply(validate(this), arguments);
    },
    filter: function filter(callbackfn /* , thisArg */) {
      return speciesFromList(this, arrayFilter(validate(this), callbackfn,
        arguments.length > 1 ? arguments[1] : undefined));
    },
    find: function find(predicate /* , thisArg */) {
      return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
    },
    findIndex: function findIndex(predicate /* , thisArg */) {
      return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
    },
    forEach: function forEach(callbackfn /* , thisArg */) {
      arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
    },
    indexOf: function indexOf(searchElement /* , fromIndex */) {
      return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
    },
    includes: function includes(searchElement /* , fromIndex */) {
      return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
    },
    join: function join(separator) { // eslint-disable-line no-unused-vars
      return arrayJoin.apply(validate(this), arguments);
    },
    lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars
      return arrayLastIndexOf.apply(validate(this), arguments);
    },
    map: function map(mapfn /* , thisArg */) {
      return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);
    },
    reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
      return arrayReduce.apply(validate(this), arguments);
    },
    reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars
      return arrayReduceRight.apply(validate(this), arguments);
    },
    reverse: function reverse() {
      var that = this;
      var length = validate(that).length;
      var middle = Math.floor(length / 2);
      var index = 0;
      var value;
      while (index < middle) {
        value = that[index];
        that[index++] = that[--length];
        that[length] = value;
      } return that;
    },
    some: function some(callbackfn /* , thisArg */) {
      return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
    },
    sort: function sort(comparefn) {
      return arraySort.call(validate(this), comparefn);
    },
    subarray: function subarray(begin, end) {
      var O = validate(this);
      var length = O.length;
      var $begin = toAbsoluteIndex(begin, length);
      return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(
        O.buffer,
        O.byteOffset + $begin * O.BYTES_PER_ELEMENT,
        toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)
      );
    }
  };

  var $slice = function slice(start, end) {
    return speciesFromList(this, arraySlice.call(validate(this), start, end));
  };

  var $set = function set(arrayLike /* , offset */) {
    validate(this);
    var offset = toOffset(arguments[1], 1);
    var length = this.length;
    var src = toObject(arrayLike);
    var len = toLength(src.length);
    var index = 0;
    if (len + offset > length) throw RangeError(WRONG_LENGTH);
    while (index < len) this[offset + index] = src[index++];
  };

  var $iterators = {
    entries: function entries() {
      return arrayEntries.call(validate(this));
    },
    keys: function keys() {
      return arrayKeys.call(validate(this));
    },
    values: function values() {
      return arrayValues.call(validate(this));
    }
  };

  var isTAIndex = function (target, key) {
    return isObject(target)
      && target[TYPED_ARRAY]
      && typeof key != 'symbol'
      && key in target
      && String(+key) == String(key);
  };
  var $getDesc = function getOwnPropertyDescriptor(target, key) {
    return isTAIndex(target, key = toPrimitive(key, true))
      ? propertyDesc(2, target[key])
      : gOPD(target, key);
  };
  var $setDesc = function defineProperty(target, key, desc) {
    if (isTAIndex(target, key = toPrimitive(key, true))
      && isObject(desc)
      && has(desc, 'value')
      && !has(desc, 'get')
      && !has(desc, 'set')
      // TODO: add validation descriptor w/o calling accessors
      && !desc.configurable
      && (!has(desc, 'writable') || desc.writable)
      && (!has(desc, 'enumerable') || desc.enumerable)
    ) {
      target[key] = desc.value;
      return target;
    } return dP(target, key, desc);
  };

  if (!ALL_CONSTRUCTORS) {
    $GOPD.f = $getDesc;
    $DP.f = $setDesc;
  }

  $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {
    getOwnPropertyDescriptor: $getDesc,
    defineProperty: $setDesc
  });

  if (fails(function () { arrayToString.call({}); })) {
    arrayToString = arrayToLocaleString = function toString() {
      return arrayJoin.call(this);
    };
  }

  var $TypedArrayPrototype$ = redefineAll({}, proto);
  redefineAll($TypedArrayPrototype$, $iterators);
  hide($TypedArrayPrototype$, ITERATOR, $iterators.values);
  redefineAll($TypedArrayPrototype$, {
    slice: $slice,
    set: $set,
    constructor: function () { /* noop */ },
    toString: arrayToString,
    toLocaleString: $toLocaleString
  });
  addGetter($TypedArrayPrototype$, 'buffer', 'b');
  addGetter($TypedArrayPrototype$, 'byteOffset', 'o');
  addGetter($TypedArrayPrototype$, 'byteLength', 'l');
  addGetter($TypedArrayPrototype$, 'length', 'e');
  dP($TypedArrayPrototype$, TAG, {
    get: function () { return this[TYPED_ARRAY]; }
  });

  // eslint-disable-next-line max-statements
  module.exports = function (KEY, BYTES, wrapper, CLAMPED) {
    CLAMPED = !!CLAMPED;
    var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';
    var GETTER = 'get' + KEY;
    var SETTER = 'set' + KEY;
    var TypedArray = global[NAME];
    var Base = TypedArray || {};
    var TAC = TypedArray && getPrototypeOf(TypedArray);
    var FORCED = !TypedArray || !$typed.ABV;
    var O = {};
    var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];
    var getter = function (that, index) {
      var data = that._d;
      return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);
    };
    var setter = function (that, index, value) {
      var data = that._d;
      if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;
      data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);
    };
    var addElement = function (that, index) {
      dP(that, index, {
        get: function () {
          return getter(this, index);
        },
        set: function (value) {
          return setter(this, index, value);
        },
        enumerable: true
      });
    };
    if (FORCED) {
      TypedArray = wrapper(function (that, data, $offset, $length) {
        anInstance(that, TypedArray, NAME, '_d');
        var index = 0;
        var offset = 0;
        var buffer, byteLength, length, klass;
        if (!isObject(data)) {
          length = toIndex(data);
          byteLength = length * BYTES;
          buffer = new $ArrayBuffer(byteLength);
        } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
          buffer = data;
          offset = toOffset($offset, BYTES);
          var $len = data.byteLength;
          if ($length === undefined) {
            if ($len % BYTES) throw RangeError(WRONG_LENGTH);
            byteLength = $len - offset;
            if (byteLength < 0) throw RangeError(WRONG_LENGTH);
          } else {
            byteLength = toLength($length) * BYTES;
            if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);
          }
          length = byteLength / BYTES;
        } else if (TYPED_ARRAY in data) {
          return fromList(TypedArray, data);
        } else {
          return $from.call(TypedArray, data);
        }
        hide(that, '_d', {
          b: buffer,
          o: offset,
          l: byteLength,
          e: length,
          v: new $DataView(buffer)
        });
        while (index < length) addElement(that, index++);
      });
      TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);
      hide(TypedArrayPrototype, 'constructor', TypedArray);
    } else if (!fails(function () {
      TypedArray(1);
    }) || !fails(function () {
      new TypedArray(-1); // eslint-disable-line no-new
    }) || !$iterDetect(function (iter) {
      new TypedArray(); // eslint-disable-line no-new
      new TypedArray(null); // eslint-disable-line no-new
      new TypedArray(1.5); // eslint-disable-line no-new
      new TypedArray(iter); // eslint-disable-line no-new
    }, true)) {
      TypedArray = wrapper(function (that, data, $offset, $length) {
        anInstance(that, TypedArray, NAME);
        var klass;
        // `ws` module bug, temporarily remove validation length for Uint8Array
        // https://github.com/websockets/ws/pull/645
        if (!isObject(data)) return new Base(toIndex(data));
        if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {
          return $length !== undefined
            ? new Base(data, toOffset($offset, BYTES), $length)
            : $offset !== undefined
              ? new Base(data, toOffset($offset, BYTES))
              : new Base(data);
        }
        if (TYPED_ARRAY in data) return fromList(TypedArray, data);
        return $from.call(TypedArray, data);
      });
      arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {
        if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);
      });
      TypedArray[PROTOTYPE] = TypedArrayPrototype;
      if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;
    }
    var $nativeIterator = TypedArrayPrototype[ITERATOR];
    var CORRECT_ITER_NAME = !!$nativeIterator
      && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);
    var $iterator = $iterators.values;
    hide(TypedArray, TYPED_CONSTRUCTOR, true);
    hide(TypedArrayPrototype, TYPED_ARRAY, NAME);
    hide(TypedArrayPrototype, VIEW, true);
    hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);

    if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {
      dP(TypedArrayPrototype, TAG, {
        get: function () { return NAME; }
      });
    }

    O[NAME] = TypedArray;

    $export($export.G + $export.W + $export.F * (TypedArray != Base), O);

    $export($export.S, NAME, {
      BYTES_PER_ELEMENT: BYTES
    });

    $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {
      from: $from,
      of: $of
    });

    if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);

    $export($export.P, NAME, proto);

    setSpecies(NAME);

    $export($export.P + $export.F * FORCED_SET, NAME, { set: $set });

    $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);

    if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;

    $export($export.P + $export.F * fails(function () {
      new TypedArray(1).slice();
    }), NAME, { slice: $slice });

    $export($export.P + $export.F * (fails(function () {
      return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();
    }) || !fails(function () {
      TypedArrayPrototype.toLocaleString.call([1, 2]);
    })), NAME, { toLocaleString: $toLocaleString });

    Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;
    if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator);
  };
} else module.exports = function () { /* empty */ };


/***/ }),

/***/ "./node_modules/core-js/modules/_typed-buffer.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/_typed-buffer.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js");
var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js");
var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/core-js/modules/_typed.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var toIndex = __webpack_require__(/*! ./_to-index */ "./node_modules/core-js/modules/_to-index.js");
var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f;
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var arrayFill = __webpack_require__(/*! ./_array-fill */ "./node_modules/core-js/modules/_array-fill.js");
var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js");
var ARRAY_BUFFER = 'ArrayBuffer';
var DATA_VIEW = 'DataView';
var PROTOTYPE = 'prototype';
var WRONG_LENGTH = 'Wrong length!';
var WRONG_INDEX = 'Wrong index!';
var $ArrayBuffer = global[ARRAY_BUFFER];
var $DataView = global[DATA_VIEW];
var Math = global.Math;
var RangeError = global.RangeError;
// eslint-disable-next-line no-shadow-restricted-names
var Infinity = global.Infinity;
var BaseBuffer = $ArrayBuffer;
var abs = Math.abs;
var pow = Math.pow;
var floor = Math.floor;
var log = Math.log;
var LN2 = Math.LN2;
var BUFFER = 'buffer';
var BYTE_LENGTH = 'byteLength';
var BYTE_OFFSET = 'byteOffset';
var $BUFFER = DESCRIPTORS ? '_b' : BUFFER;
var $LENGTH = DESCRIPTORS ? '_l' : BYTE_LENGTH;
var $OFFSET = DESCRIPTORS ? '_o' : BYTE_OFFSET;

// IEEE754 conversions based on https://github.com/feross/ieee754
function packIEEE754(value, mLen, nBytes) {
  var buffer = new Array(nBytes);
  var eLen = nBytes * 8 - mLen - 1;
  var eMax = (1 << eLen) - 1;
  var eBias = eMax >> 1;
  var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;
  var i = 0;
  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
  var e, m, c;
  value = abs(value);
  // eslint-disable-next-line no-self-compare
  if (value != value || value === Infinity) {
    // eslint-disable-next-line no-self-compare
    m = value != value ? 1 : 0;
    e = eMax;
  } else {
    e = floor(log(value) / LN2);
    if (value * (c = pow(2, -e)) < 1) {
      e--;
      c *= 2;
    }
    if (e + eBias >= 1) {
      value += rt / c;
    } else {
      value += rt * pow(2, 1 - eBias);
    }
    if (value * c >= 2) {
      e++;
      c /= 2;
    }
    if (e + eBias >= eMax) {
      m = 0;
      e = eMax;
    } else if (e + eBias >= 1) {
      m = (value * c - 1) * pow(2, mLen);
      e = e + eBias;
    } else {
      m = value * pow(2, eBias - 1) * pow(2, mLen);
      e = 0;
    }
  }
  for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);
  e = e << mLen | m;
  eLen += mLen;
  for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);
  buffer[--i] |= s * 128;
  return buffer;
}
function unpackIEEE754(buffer, mLen, nBytes) {
  var eLen = nBytes * 8 - mLen - 1;
  var eMax = (1 << eLen) - 1;
  var eBias = eMax >> 1;
  var nBits = eLen - 7;
  var i = nBytes - 1;
  var s = buffer[i--];
  var e = s & 127;
  var m;
  s >>= 7;
  for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);
  m = e & (1 << -nBits) - 1;
  e >>= -nBits;
  nBits += mLen;
  for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);
  if (e === 0) {
    e = 1 - eBias;
  } else if (e === eMax) {
    return m ? NaN : s ? -Infinity : Infinity;
  } else {
    m = m + pow(2, mLen);
    e = e - eBias;
  } return (s ? -1 : 1) * m * pow(2, e - mLen);
}

function unpackI32(bytes) {
  return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];
}
function packI8(it) {
  return [it & 0xff];
}
function packI16(it) {
  return [it & 0xff, it >> 8 & 0xff];
}
function packI32(it) {
  return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff];
}
function packF64(it) {
  return packIEEE754(it, 52, 8);
}
function packF32(it) {
  return packIEEE754(it, 23, 4);
}

function addGetter(C, key, internal) {
  dP(C[PROTOTYPE], key, { get: function () { return this[internal]; } });
}

function get(view, bytes, index, isLittleEndian) {
  var numIndex = +index;
  var intIndex = toIndex(numIndex);
  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
  var store = view[$BUFFER]._b;
  var start = intIndex + view[$OFFSET];
  var pack = store.slice(start, start + bytes);
  return isLittleEndian ? pack : pack.reverse();
}
function set(view, bytes, index, conversion, value, isLittleEndian) {
  var numIndex = +index;
  var intIndex = toIndex(numIndex);
  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);
  var store = view[$BUFFER]._b;
  var start = intIndex + view[$OFFSET];
  var pack = conversion(+value);
  for (var i = 0; i < bytes; i++) store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];
}

if (!$typed.ABV) {
  $ArrayBuffer = function ArrayBuffer(length) {
    anInstance(this, $ArrayBuffer, ARRAY_BUFFER);
    var byteLength = toIndex(length);
    this._b = arrayFill.call(new Array(byteLength), 0);
    this[$LENGTH] = byteLength;
  };

  $DataView = function DataView(buffer, byteOffset, byteLength) {
    anInstance(this, $DataView, DATA_VIEW);
    anInstance(buffer, $ArrayBuffer, DATA_VIEW);
    var bufferLength = buffer[$LENGTH];
    var offset = toInteger(byteOffset);
    if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!');
    byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
    if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
    this[$BUFFER] = buffer;
    this[$OFFSET] = offset;
    this[$LENGTH] = byteLength;
  };

  if (DESCRIPTORS) {
    addGetter($ArrayBuffer, BYTE_LENGTH, '_l');
    addGetter($DataView, BUFFER, '_b');
    addGetter($DataView, BYTE_LENGTH, '_l');
    addGetter($DataView, BYTE_OFFSET, '_o');
  }

  redefineAll($DataView[PROTOTYPE], {
    getInt8: function getInt8(byteOffset) {
      return get(this, 1, byteOffset)[0] << 24 >> 24;
    },
    getUint8: function getUint8(byteOffset) {
      return get(this, 1, byteOffset)[0];
    },
    getInt16: function getInt16(byteOffset /* , littleEndian */) {
      var bytes = get(this, 2, byteOffset, arguments[1]);
      return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
    },
    getUint16: function getUint16(byteOffset /* , littleEndian */) {
      var bytes = get(this, 2, byteOffset, arguments[1]);
      return bytes[1] << 8 | bytes[0];
    },
    getInt32: function getInt32(byteOffset /* , littleEndian */) {
      return unpackI32(get(this, 4, byteOffset, arguments[1]));
    },
    getUint32: function getUint32(byteOffset /* , littleEndian */) {
      return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;
    },
    getFloat32: function getFloat32(byteOffset /* , littleEndian */) {
      return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);
    },
    getFloat64: function getFloat64(byteOffset /* , littleEndian */) {
      return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);
    },
    setInt8: function setInt8(byteOffset, value) {
      set(this, 1, byteOffset, packI8, value);
    },
    setUint8: function setUint8(byteOffset, value) {
      set(this, 1, byteOffset, packI8, value);
    },
    setInt16: function setInt16(byteOffset, value /* , littleEndian */) {
      set(this, 2, byteOffset, packI16, value, arguments[2]);
    },
    setUint16: function setUint16(byteOffset, value /* , littleEndian */) {
      set(this, 2, byteOffset, packI16, value, arguments[2]);
    },
    setInt32: function setInt32(byteOffset, value /* , littleEndian */) {
      set(this, 4, byteOffset, packI32, value, arguments[2]);
    },
    setUint32: function setUint32(byteOffset, value /* , littleEndian */) {
      set(this, 4, byteOffset, packI32, value, arguments[2]);
    },
    setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {
      set(this, 4, byteOffset, packF32, value, arguments[2]);
    },
    setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {
      set(this, 8, byteOffset, packF64, value, arguments[2]);
    }
  });
} else {
  if (!fails(function () {
    $ArrayBuffer(1);
  }) || !fails(function () {
    new $ArrayBuffer(-1); // eslint-disable-line no-new
  }) || fails(function () {
    new $ArrayBuffer(); // eslint-disable-line no-new
    new $ArrayBuffer(1.5); // eslint-disable-line no-new
    new $ArrayBuffer(NaN); // eslint-disable-line no-new
    return $ArrayBuffer.name != ARRAY_BUFFER;
  })) {
    $ArrayBuffer = function ArrayBuffer(length) {
      anInstance(this, $ArrayBuffer);
      return new BaseBuffer(toIndex(length));
    };
    var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE];
    for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) {
      if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, BaseBuffer[key]);
    }
    if (!LIBRARY) ArrayBufferProto.constructor = $ArrayBuffer;
  }
  // iOS Safari 7.x bug
  var view = new $DataView(new $ArrayBuffer(2));
  var $setInt8 = $DataView[PROTOTYPE].setInt8;
  view.setInt8(0, 2147483648);
  view.setInt8(1, 2147483649);
  if (view.getInt8(0) || !view.getInt8(1)) redefineAll($DataView[PROTOTYPE], {
    setInt8: function setInt8(byteOffset, value) {
      $setInt8.call(this, byteOffset, value << 24 >> 24);
    },
    setUint8: function setUint8(byteOffset, value) {
      $setInt8.call(this, byteOffset, value << 24 >> 24);
    }
  }, true);
}
setToStringTag($ArrayBuffer, ARRAY_BUFFER);
setToStringTag($DataView, DATA_VIEW);
hide($DataView[PROTOTYPE], $typed.VIEW, true);
exports[ARRAY_BUFFER] = $ArrayBuffer;
exports[DATA_VIEW] = $DataView;


/***/ }),

/***/ "./node_modules/core-js/modules/_typed.js":
/*!************************************************!*\
  !*** ./node_modules/core-js/modules/_typed.js ***!
  \************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
var TYPED = uid('typed_array');
var VIEW = uid('view');
var ABV = !!(global.ArrayBuffer && global.DataView);
var CONSTR = ABV;
var i = 0;
var l = 9;
var Typed;

var TypedArrayConstructors = (
  'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'
).split(',');

while (i < l) {
  if (Typed = global[TypedArrayConstructors[i++]]) {
    hide(Typed.prototype, TYPED, true);
    hide(Typed.prototype, VIEW, true);
  } else CONSTR = false;
}

module.exports = {
  ABV: ABV,
  CONSTR: CONSTR,
  TYPED: TYPED,
  VIEW: VIEW
};


/***/ }),

/***/ "./node_modules/core-js/modules/_uid.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_uid.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

var id = 0;
var px = Math.random();
module.exports = function (key) {
  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
};


/***/ }),

/***/ "./node_modules/core-js/modules/_user-agent.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_user-agent.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var navigator = global.navigator;

module.exports = navigator && navigator.userAgent || '';


/***/ }),

/***/ "./node_modules/core-js/modules/_validate-collection.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/_validate-collection.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
module.exports = function (it, TYPE) {
  if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
  return it;
};


/***/ }),

/***/ "./node_modules/core-js/modules/_wks-define.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/_wks-define.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js");
var wksExt = __webpack_require__(/*! ./_wks-ext */ "./node_modules/core-js/modules/_wks-ext.js");
var defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
module.exports = function (name) {
  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });
};


/***/ }),

/***/ "./node_modules/core-js/modules/_wks-ext.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/_wks-ext.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

exports.f = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");


/***/ }),

/***/ "./node_modules/core-js/modules/_wks.js":
/*!**********************************************!*\
  !*** ./node_modules/core-js/modules/_wks.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var store = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js")('wks');
var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
var Symbol = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").Symbol;
var USE_SYMBOL = typeof Symbol == 'function';

var $exports = module.exports = function (name) {
  return store[name] || (store[name] =
    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));
};

$exports.store = store;


/***/ }),

/***/ "./node_modules/core-js/modules/core.get-iterator-method.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/core.get-iterator-method.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
var ITERATOR = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('iterator');
var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
module.exports = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js").getIteratorMethod = function (it) {
  if (it != undefined) return it[ITERATOR]
    || it['@@iterator']
    || Iterators[classof(it)];
};


/***/ }),

/***/ "./node_modules/core-js/modules/core.regexp.escape.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/core.regexp.escape.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/benjamingr/RexExp.escape
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $re = __webpack_require__(/*! ./_replacer */ "./node_modules/core-js/modules/_replacer.js")(/[\\^$*+?.()|[\]{}]/g, '\\$&');

$export($export.S, 'RegExp', { escape: function escape(it) { return $re(it); } });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.copy-within.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.copy-within.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P, 'Array', { copyWithin: __webpack_require__(/*! ./_array-copy-within */ "./node_modules/core-js/modules/_array-copy-within.js") });

__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")('copyWithin');


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.every.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.every.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $every = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(4);

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].every, true), 'Array', {
  // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])
  every: function every(callbackfn /* , thisArg */) {
    return $every(this, callbackfn, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.fill.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.fill.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P, 'Array', { fill: __webpack_require__(/*! ./_array-fill */ "./node_modules/core-js/modules/_array-fill.js") });

__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")('fill');


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.filter.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.filter.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $filter = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(2);

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].filter, true), 'Array', {
  // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])
  filter: function filter(callbackfn /* , thisArg */) {
    return $filter(this, callbackfn, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.find-index.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.find-index.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $find = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(6);
var KEY = 'findIndex';
var forced = true;
// Shouldn't skip holes
if (KEY in []) Array(1)[KEY](function () { forced = false; });
$export($export.P + $export.F * forced, 'Array', {
  findIndex: function findIndex(callbackfn /* , that = undefined */) {
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});
__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")(KEY);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.find.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.find.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $find = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(5);
var KEY = 'find';
var forced = true;
// Shouldn't skip holes
if (KEY in []) Array(1)[KEY](function () { forced = false; });
$export($export.P + $export.F * forced, 'Array', {
  find: function find(callbackfn /* , that = undefined */) {
    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
  }
});
__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")(KEY);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.for-each.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.for-each.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $forEach = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(0);
var STRICT = __webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].forEach, true);

$export($export.P + $export.F * !STRICT, 'Array', {
  // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])
  forEach: function forEach(callbackfn /* , thisArg */) {
    return $forEach(this, callbackfn, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.from.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.from.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var call = __webpack_require__(/*! ./_iter-call */ "./node_modules/core-js/modules/_iter-call.js");
var isArrayIter = __webpack_require__(/*! ./_is-array-iter */ "./node_modules/core-js/modules/_is-array-iter.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/core-js/modules/_create-property.js");
var getIterFn = __webpack_require__(/*! ./core.get-iterator-method */ "./node_modules/core-js/modules/core.get-iterator-method.js");

$export($export.S + $export.F * !__webpack_require__(/*! ./_iter-detect */ "./node_modules/core-js/modules/_iter-detect.js")(function (iter) { Array.from(iter); }), 'Array', {
  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
  from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
    var O = toObject(arrayLike);
    var C = typeof this == 'function' ? this : Array;
    var aLen = arguments.length;
    var mapfn = aLen > 1 ? arguments[1] : undefined;
    var mapping = mapfn !== undefined;
    var index = 0;
    var iterFn = getIterFn(O);
    var length, result, step, iterator;
    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
    // if object isn't iterable or it's array with default iterator - use simple case
    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
      }
    } else {
      length = toLength(O.length);
      for (result = new C(length); length > index; index++) {
        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
      }
    }
    result.length = index;
    return result;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.index-of.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.index-of.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $indexOf = __webpack_require__(/*! ./_array-includes */ "./node_modules/core-js/modules/_array-includes.js")(false);
var $native = [].indexOf;
var NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;

$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")($native)), 'Array', {
  // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])
  indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
    return NEGATIVE_ZERO
      // convert -0 to +0
      ? $native.apply(this, arguments) || 0
      : $indexOf(this, searchElement, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.is-array.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.is-array.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 22.1.2.2 / 15.4.3.2 Array.isArray(arg)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Array', { isArray: __webpack_require__(/*! ./_is-array */ "./node_modules/core-js/modules/_is-array.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.iterator.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.iterator.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var addToUnscopables = __webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js");
var step = __webpack_require__(/*! ./_iter-step */ "./node_modules/core-js/modules/_iter-step.js");
var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");

// 22.1.3.4 Array.prototype.entries()
// 22.1.3.13 Array.prototype.keys()
// 22.1.3.29 Array.prototype.values()
// 22.1.3.30 Array.prototype[@@iterator]()
module.exports = __webpack_require__(/*! ./_iter-define */ "./node_modules/core-js/modules/_iter-define.js")(Array, 'Array', function (iterated, kind) {
  this._t = toIObject(iterated); // target
  this._i = 0;                   // next index
  this._k = kind;                // kind
// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
}, function () {
  var O = this._t;
  var kind = this._k;
  var index = this._i++;
  if (!O || index >= O.length) {
    this._t = undefined;
    return step(1);
  }
  if (kind == 'keys') return step(0, index);
  if (kind == 'values') return step(0, O[index]);
  return step(0, [index, O[index]]);
}, 'values');

// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
Iterators.Arguments = Iterators.Array;

addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.join.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.join.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 22.1.3.13 Array.prototype.join(separator)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var arrayJoin = [].join;

// fallback for not array-like strings
$export($export.P + $export.F * (__webpack_require__(/*! ./_iobject */ "./node_modules/core-js/modules/_iobject.js") != Object || !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")(arrayJoin)), 'Array', {
  join: function join(separator) {
    return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.last-index-of.js":
/*!*****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.last-index-of.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var $native = [].lastIndexOf;
var NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0;

$export($export.P + $export.F * (NEGATIVE_ZERO || !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")($native)), 'Array', {
  // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])
  lastIndexOf: function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
    // convert -0 to +0
    if (NEGATIVE_ZERO) return $native.apply(this, arguments) || 0;
    var O = toIObject(this);
    var length = toLength(O.length);
    var index = length - 1;
    if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1]));
    if (index < 0) index = length + index;
    for (;index >= 0; index--) if (index in O) if (O[index] === searchElement) return index || 0;
    return -1;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.map.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.map.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $map = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(1);

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].map, true), 'Array', {
  // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])
  map: function map(callbackfn /* , thisArg */) {
    return $map(this, callbackfn, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.of.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.of.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/core-js/modules/_create-property.js");

// WebKit Array.of isn't generic
$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  function F() { /* empty */ }
  return !(Array.of.call(F) instanceof F);
}), 'Array', {
  // 22.1.2.3 Array.of( ...items)
  of: function of(/* ...args */) {
    var index = 0;
    var aLen = arguments.length;
    var result = new (typeof this == 'function' ? this : Array)(aLen);
    while (aLen > index) createProperty(result, index, arguments[index++]);
    result.length = aLen;
    return result;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.reduce-right.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.reduce-right.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $reduce = __webpack_require__(/*! ./_array-reduce */ "./node_modules/core-js/modules/_array-reduce.js");

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].reduceRight, true), 'Array', {
  // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])
  reduceRight: function reduceRight(callbackfn /* , initialValue */) {
    return $reduce(this, callbackfn, arguments.length, arguments[1], true);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.reduce.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.reduce.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $reduce = __webpack_require__(/*! ./_array-reduce */ "./node_modules/core-js/modules/_array-reduce.js");

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].reduce, true), 'Array', {
  // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])
  reduce: function reduce(callbackfn /* , initialValue */) {
    return $reduce(this, callbackfn, arguments.length, arguments[1], false);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.slice.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.slice.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var html = __webpack_require__(/*! ./_html */ "./node_modules/core-js/modules/_html.js");
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var arraySlice = [].slice;

// fallback for not array-like ES3 strings and DOM objects
$export($export.P + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  if (html) arraySlice.call(html);
}), 'Array', {
  slice: function slice(begin, end) {
    var len = toLength(this.length);
    var klass = cof(this);
    end = end === undefined ? len : end;
    if (klass == 'Array') return arraySlice.call(this, begin, end);
    var start = toAbsoluteIndex(begin, len);
    var upTo = toAbsoluteIndex(end, len);
    var size = toLength(upTo - start);
    var cloned = new Array(size);
    var i = 0;
    for (; i < size; i++) cloned[i] = klass == 'String'
      ? this.charAt(start + i)
      : this[start + i];
    return cloned;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.some.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.some.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $some = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(3);

$export($export.P + $export.F * !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")([].some, true), 'Array', {
  // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])
  some: function some(callbackfn /* , thisArg */) {
    return $some(this, callbackfn, arguments[1]);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.sort.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.sort.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var $sort = [].sort;
var test = [1, 2, 3];

$export($export.P + $export.F * (fails(function () {
  // IE8-
  test.sort(undefined);
}) || !fails(function () {
  // V8 bug
  test.sort(null);
  // Old WebKit
}) || !__webpack_require__(/*! ./_strict-method */ "./node_modules/core-js/modules/_strict-method.js")($sort)), 'Array', {
  // 22.1.3.25 Array.prototype.sort(comparefn)
  sort: function sort(comparefn) {
    return comparefn === undefined
      ? $sort.call(toObject(this))
      : $sort.call(toObject(this), aFunction(comparefn));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.array.species.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.array.species.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js")('Array');


/***/ }),

/***/ "./node_modules/core-js/modules/es6.date.now.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.date.now.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.3.3.1 / 15.9.4.4 Date.now()
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Date', { now: function () { return new Date().getTime(); } });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.date.to-iso-string.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.date.to-iso-string.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toISOString = __webpack_require__(/*! ./_date-to-iso-string */ "./node_modules/core-js/modules/_date-to-iso-string.js");

// PhantomJS / old WebKit has a broken implementations
$export($export.P + $export.F * (Date.prototype.toISOString !== toISOString), 'Date', {
  toISOString: toISOString
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.date.to-json.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.date.to-json.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");

$export($export.P + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return new Date(NaN).toJSON() !== null
    || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;
}), 'Date', {
  // eslint-disable-next-line no-unused-vars
  toJSON: function toJSON(key) {
    var O = toObject(this);
    var pv = toPrimitive(O);
    return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.date.to-primitive.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.date.to-primitive.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var TO_PRIMITIVE = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('toPrimitive');
var proto = Date.prototype;

if (!(TO_PRIMITIVE in proto)) __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js")(proto, TO_PRIMITIVE, __webpack_require__(/*! ./_date-to-primitive */ "./node_modules/core-js/modules/_date-to-primitive.js"));


/***/ }),

/***/ "./node_modules/core-js/modules/es6.date.to-string.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.date.to-string.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var DateProto = Date.prototype;
var INVALID_DATE = 'Invalid Date';
var TO_STRING = 'toString';
var $toString = DateProto[TO_STRING];
var getTime = DateProto.getTime;
if (new Date(NaN) + '' != INVALID_DATE) {
  __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js")(DateProto, TO_STRING, function toString() {
    var value = getTime.call(this);
    // eslint-disable-next-line no-self-compare
    return value === value ? $toString.call(this) : INVALID_DATE;
  });
}


/***/ }),

/***/ "./node_modules/core-js/modules/es6.function.bind.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.function.bind.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P, 'Function', { bind: __webpack_require__(/*! ./_bind */ "./node_modules/core-js/modules/_bind.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.function.has-instance.js":
/*!*******************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.function.has-instance.js ***!
  \*******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var HAS_INSTANCE = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('hasInstance');
var FunctionProto = Function.prototype;
// 19.2.3.6 Function.prototype[@@hasInstance](V)
if (!(HAS_INSTANCE in FunctionProto)) __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f(FunctionProto, HAS_INSTANCE, { value: function (O) {
  if (typeof this != 'function' || !isObject(O)) return false;
  if (!isObject(this.prototype)) return O instanceof this;
  // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
  while (O = getPrototypeOf(O)) if (this.prototype === O) return true;
  return false;
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.function.name.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.function.name.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var FProto = Function.prototype;
var nameRE = /^\s*function ([^ (]*)/;
var NAME = 'name';

// 19.2.4.2 name
NAME in FProto || __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && dP(FProto, NAME, {
  configurable: true,
  get: function () {
    try {
      return ('' + this).match(nameRE)[1];
    } catch (e) {
      return '';
    }
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.map.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/es6.map.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var strong = __webpack_require__(/*! ./_collection-strong */ "./node_modules/core-js/modules/_collection-strong.js");
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var MAP = 'Map';

// 23.1 Map Objects
module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/core-js/modules/_collection.js")(MAP, function (get) {
  return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.1.3.6 Map.prototype.get(key)
  get: function get(key) {
    var entry = strong.getEntry(validate(this, MAP), key);
    return entry && entry.v;
  },
  // 23.1.3.9 Map.prototype.set(key, value)
  set: function set(key, value) {
    return strong.def(validate(this, MAP), key === 0 ? 0 : key, value);
  }
}, strong, true);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.acosh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.acosh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.3 Math.acosh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var log1p = __webpack_require__(/*! ./_math-log1p */ "./node_modules/core-js/modules/_math-log1p.js");
var sqrt = Math.sqrt;
var $acosh = Math.acosh;

$export($export.S + $export.F * !($acosh
  // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
  && Math.floor($acosh(Number.MAX_VALUE)) == 710
  // Tor Browser bug: Math.acosh(Infinity) -> NaN
  && $acosh(Infinity) == Infinity
), 'Math', {
  acosh: function acosh(x) {
    return (x = +x) < 1 ? NaN : x > 94906265.62425156
      ? Math.log(x) + Math.LN2
      : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.asinh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.asinh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.5 Math.asinh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $asinh = Math.asinh;

function asinh(x) {
  return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1));
}

// Tor Browser bug: Math.asinh(0) -> -0
$export($export.S + $export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', { asinh: asinh });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.atanh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.atanh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.7 Math.atanh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $atanh = Math.atanh;

// Tor Browser bug: Math.atanh(-0) -> 0
$export($export.S + $export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', {
  atanh: function atanh(x) {
    return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.cbrt.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.cbrt.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.9 Math.cbrt(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var sign = __webpack_require__(/*! ./_math-sign */ "./node_modules/core-js/modules/_math-sign.js");

$export($export.S, 'Math', {
  cbrt: function cbrt(x) {
    return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.clz32.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.clz32.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.11 Math.clz32(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  clz32: function clz32(x) {
    return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.cosh.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.cosh.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.12 Math.cosh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var exp = Math.exp;

$export($export.S, 'Math', {
  cosh: function cosh(x) {
    return (exp(x = +x) + exp(-x)) / 2;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.expm1.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.expm1.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.14 Math.expm1(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/core-js/modules/_math-expm1.js");

$export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', { expm1: $expm1 });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.fround.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.fround.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.16 Math.fround(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { fround: __webpack_require__(/*! ./_math-fround */ "./node_modules/core-js/modules/_math-fround.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.hypot.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.hypot.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.17 Math.hypot([value1[, value2[, … ]]])
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var abs = Math.abs;

$export($export.S, 'Math', {
  hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars
    var sum = 0;
    var i = 0;
    var aLen = arguments.length;
    var larg = 0;
    var arg, div;
    while (i < aLen) {
      arg = abs(arguments[i++]);
      if (larg < arg) {
        div = larg / arg;
        sum = sum * div * div + 1;
        larg = arg;
      } else if (arg > 0) {
        div = arg / larg;
        sum += div * div;
      } else sum += arg;
    }
    return larg === Infinity ? Infinity : larg * Math.sqrt(sum);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.imul.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.imul.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.18 Math.imul(x, y)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $imul = Math.imul;

// some WebKit versions fails with big numbers, some has wrong arity
$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return $imul(0xffffffff, 5) != -5 || $imul.length != 2;
}), 'Math', {
  imul: function imul(x, y) {
    var UINT16 = 0xffff;
    var xn = +x;
    var yn = +y;
    var xl = UINT16 & xn;
    var yl = UINT16 & yn;
    return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.log10.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.log10.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.21 Math.log10(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  log10: function log10(x) {
    return Math.log(x) * Math.LOG10E;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.log1p.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.log1p.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.20 Math.log1p(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { log1p: __webpack_require__(/*! ./_math-log1p */ "./node_modules/core-js/modules/_math-log1p.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.log2.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.log2.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.22 Math.log2(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  log2: function log2(x) {
    return Math.log(x) / Math.LN2;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.sign.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.sign.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.28 Math.sign(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { sign: __webpack_require__(/*! ./_math-sign */ "./node_modules/core-js/modules/_math-sign.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.sinh.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.sinh.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.30 Math.sinh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/core-js/modules/_math-expm1.js");
var exp = Math.exp;

// V8 near Chromium 38 has a problem with very small numbers
$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return !Math.sinh(-2e-17) != -2e-17;
}), 'Math', {
  sinh: function sinh(x) {
    return Math.abs(x = +x) < 1
      ? (expm1(x) - expm1(-x)) / 2
      : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.tanh.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.tanh.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.33 Math.tanh(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var expm1 = __webpack_require__(/*! ./_math-expm1 */ "./node_modules/core-js/modules/_math-expm1.js");
var exp = Math.exp;

$export($export.S, 'Math', {
  tanh: function tanh(x) {
    var a = expm1(x = +x);
    var b = expm1(-x);
    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.math.trunc.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.math.trunc.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.2.2.34 Math.trunc(x)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  trunc: function trunc(it) {
    return (it > 0 ? Math.floor : Math.ceil)(it);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.constructor.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.constructor.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");
var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/core-js/modules/_inherit-if-required.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f;
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f;
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var $trim = __webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js").trim;
var NUMBER = 'Number';
var $Number = global[NUMBER];
var Base = $Number;
var proto = $Number.prototype;
// Opera ~12 has broken Object#toString
var BROKEN_COF = cof(__webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js")(proto)) == NUMBER;
var TRIM = 'trim' in String.prototype;

// 7.1.3 ToNumber(argument)
var toNumber = function (argument) {
  var it = toPrimitive(argument, false);
  if (typeof it == 'string' && it.length > 2) {
    it = TRIM ? it.trim() : $trim(it, 3);
    var first = it.charCodeAt(0);
    var third, radix, maxCode;
    if (first === 43 || first === 45) {
      third = it.charCodeAt(2);
      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
    } else if (first === 48) {
      switch (it.charCodeAt(1)) {
        case 66: case 98: radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i
        case 79: case 111: radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i
        default: return +it;
      }
      for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) {
        code = digits.charCodeAt(i);
        // parseInt parses a string to a first unavailable symbol
        // but ToNumber should return NaN if a string contains unavailable symbols
        if (code < 48 || code > maxCode) return NaN;
      } return parseInt(digits, radix);
    }
  } return +it;
};

if (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) {
  $Number = function Number(value) {
    var it = arguments.length < 1 ? 0 : value;
    var that = this;
    return that instanceof $Number
      // check on 1..constructor(foo) case
      && (BROKEN_COF ? fails(function () { proto.valueOf.call(that); }) : cof(that) != NUMBER)
        ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it);
  };
  for (var keys = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") ? gOPN(Base) : (
    // ES3:
    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
    // ES6 (in case, if modules with ES6 Number statics required before):
    'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +
    'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'
  ).split(','), j = 0, key; keys.length > j; j++) {
    if (has(Base, key = keys[j]) && !has($Number, key)) {
      dP($Number, key, gOPD(Base, key));
    }
  }
  $Number.prototype = proto;
  proto.constructor = $Number;
  __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js")(global, NUMBER, $Number);
}


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.epsilon.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.epsilon.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.1 Number.EPSILON
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Number', { EPSILON: Math.pow(2, -52) });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.is-finite.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.is-finite.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.2 Number.isFinite(number)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var _isFinite = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").isFinite;

$export($export.S, 'Number', {
  isFinite: function isFinite(it) {
    return typeof it == 'number' && _isFinite(it);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.is-integer.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.is-integer.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.3 Number.isInteger(number)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Number', { isInteger: __webpack_require__(/*! ./_is-integer */ "./node_modules/core-js/modules/_is-integer.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.is-nan.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.is-nan.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.4 Number.isNaN(number)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Number', {
  isNaN: function isNaN(number) {
    // eslint-disable-next-line no-self-compare
    return number != number;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.is-safe-integer.js":
/*!********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.is-safe-integer.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.5 Number.isSafeInteger(number)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var isInteger = __webpack_require__(/*! ./_is-integer */ "./node_modules/core-js/modules/_is-integer.js");
var abs = Math.abs;

$export($export.S, 'Number', {
  isSafeInteger: function isSafeInteger(number) {
    return isInteger(number) && abs(number) <= 0x1fffffffffffff;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.max-safe-integer.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.max-safe-integer.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.6 Number.MAX_SAFE_INTEGER
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Number', { MAX_SAFE_INTEGER: 0x1fffffffffffff });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.min-safe-integer.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.min-safe-integer.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 20.1.2.10 Number.MIN_SAFE_INTEGER
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Number', { MIN_SAFE_INTEGER: -0x1fffffffffffff });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.parse-float.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.parse-float.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $parseFloat = __webpack_require__(/*! ./_parse-float */ "./node_modules/core-js/modules/_parse-float.js");
// 20.1.2.12 Number.parseFloat(string)
$export($export.S + $export.F * (Number.parseFloat != $parseFloat), 'Number', { parseFloat: $parseFloat });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.parse-int.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.parse-int.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $parseInt = __webpack_require__(/*! ./_parse-int */ "./node_modules/core-js/modules/_parse-int.js");
// 20.1.2.13 Number.parseInt(string, radix)
$export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', { parseInt: $parseInt });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.to-fixed.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.to-fixed.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var aNumberValue = __webpack_require__(/*! ./_a-number-value */ "./node_modules/core-js/modules/_a-number-value.js");
var repeat = __webpack_require__(/*! ./_string-repeat */ "./node_modules/core-js/modules/_string-repeat.js");
var $toFixed = 1.0.toFixed;
var floor = Math.floor;
var data = [0, 0, 0, 0, 0, 0];
var ERROR = 'Number.toFixed: incorrect invocation!';
var ZERO = '0';

var multiply = function (n, c) {
  var i = -1;
  var c2 = c;
  while (++i < 6) {
    c2 += n * data[i];
    data[i] = c2 % 1e7;
    c2 = floor(c2 / 1e7);
  }
};
var divide = function (n) {
  var i = 6;
  var c = 0;
  while (--i >= 0) {
    c += data[i];
    data[i] = floor(c / n);
    c = (c % n) * 1e7;
  }
};
var numToString = function () {
  var i = 6;
  var s = '';
  while (--i >= 0) {
    if (s !== '' || i === 0 || data[i] !== 0) {
      var t = String(data[i]);
      s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;
    }
  } return s;
};
var pow = function (x, n, acc) {
  return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
};
var log = function (x) {
  var n = 0;
  var x2 = x;
  while (x2 >= 4096) {
    n += 12;
    x2 /= 4096;
  }
  while (x2 >= 2) {
    n += 1;
    x2 /= 2;
  } return n;
};

$export($export.P + $export.F * (!!$toFixed && (
  0.00008.toFixed(3) !== '0.000' ||
  0.9.toFixed(0) !== '1' ||
  1.255.toFixed(2) !== '1.25' ||
  1000000000000000128.0.toFixed(0) !== '1000000000000000128'
) || !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  // V8 ~ Android 4.3-
  $toFixed.call({});
})), 'Number', {
  toFixed: function toFixed(fractionDigits) {
    var x = aNumberValue(this, ERROR);
    var f = toInteger(fractionDigits);
    var s = '';
    var m = ZERO;
    var e, z, j, k;
    if (f < 0 || f > 20) throw RangeError(ERROR);
    // eslint-disable-next-line no-self-compare
    if (x != x) return 'NaN';
    if (x <= -1e21 || x >= 1e21) return String(x);
    if (x < 0) {
      s = '-';
      x = -x;
    }
    if (x > 1e-21) {
      e = log(x * pow(2, 69, 1)) - 69;
      z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);
      z *= 0x10000000000000;
      e = 52 - e;
      if (e > 0) {
        multiply(0, z);
        j = f;
        while (j >= 7) {
          multiply(1e7, 0);
          j -= 7;
        }
        multiply(pow(10, j, 1), 0);
        j = e - 1;
        while (j >= 23) {
          divide(1 << 23);
          j -= 23;
        }
        divide(1 << j);
        multiply(1, 1);
        divide(2);
        m = numToString();
      } else {
        multiply(0, z);
        multiply(1 << -e, 0);
        m = numToString() + repeat.call(ZERO, f);
      }
    }
    if (f > 0) {
      k = m.length;
      m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));
    } else {
      m = s + m;
    } return m;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.number.to-precision.js":
/*!*****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.number.to-precision.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var aNumberValue = __webpack_require__(/*! ./_a-number-value */ "./node_modules/core-js/modules/_a-number-value.js");
var $toPrecision = 1.0.toPrecision;

$export($export.P + $export.F * ($fails(function () {
  // IE7-
  return $toPrecision.call(1, undefined) !== '1';
}) || !$fails(function () {
  // V8 ~ Android 4.3-
  $toPrecision.call({});
})), 'Number', {
  toPrecision: function toPrecision(precision) {
    var that = aNumberValue(this, 'Number#toPrecision: incorrect invocation!');
    return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.assign.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.assign.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.1 Object.assign(target, source)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S + $export.F, 'Object', { assign: __webpack_require__(/*! ./_object-assign */ "./node_modules/core-js/modules/_object-assign.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.create.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.create.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
$export($export.S, 'Object', { create: __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.define-properties.js":
/*!**********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.define-properties.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
// 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)
$export($export.S + $export.F * !__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js"), 'Object', { defineProperties: __webpack_require__(/*! ./_object-dps */ "./node_modules/core-js/modules/_object-dps.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.define-property.js":
/*!********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.define-property.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)
$export($export.S + $export.F * !__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js"), 'Object', { defineProperty: __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.freeze.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.freeze.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.5 Object.freeze(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var meta = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").onFreeze;

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('freeze', function ($freeze) {
  return function freeze(it) {
    return $freeze && isObject(it) ? $freeze(meta(it)) : it;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.get-own-property-descriptor.js":
/*!********************************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.get-own-property-descriptor.js ***!
  \********************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var $getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f;

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('getOwnPropertyDescriptor', function () {
  return function getOwnPropertyDescriptor(it, key) {
    return $getOwnPropertyDescriptor(toIObject(it), key);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.get-own-property-names.js":
/*!***************************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.get-own-property-names.js ***!
  \***************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.7 Object.getOwnPropertyNames(O)
__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('getOwnPropertyNames', function () {
  return __webpack_require__(/*! ./_object-gopn-ext */ "./node_modules/core-js/modules/_object-gopn-ext.js").f;
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.get-prototype-of.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.get-prototype-of.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.9 Object.getPrototypeOf(O)
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var $getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('getPrototypeOf', function () {
  return function getPrototypeOf(it) {
    return $getPrototypeOf(toObject(it));
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.is-extensible.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.is-extensible.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.11 Object.isExtensible(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('isExtensible', function ($isExtensible) {
  return function isExtensible(it) {
    return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.is-frozen.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.is-frozen.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.12 Object.isFrozen(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('isFrozen', function ($isFrozen) {
  return function isFrozen(it) {
    return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.is-sealed.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.is-sealed.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.13 Object.isSealed(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('isSealed', function ($isSealed) {
  return function isSealed(it) {
    return isObject(it) ? $isSealed ? $isSealed(it) : false : true;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.is.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.is.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.10 Object.is(value1, value2)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
$export($export.S, 'Object', { is: __webpack_require__(/*! ./_same-value */ "./node_modules/core-js/modules/_same-value.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.keys.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.keys.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.14 Object.keys(O)
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var $keys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('keys', function () {
  return function keys(it) {
    return $keys(toObject(it));
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.prevent-extensions.js":
/*!***********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.prevent-extensions.js ***!
  \***********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.15 Object.preventExtensions(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var meta = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").onFreeze;

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('preventExtensions', function ($preventExtensions) {
  return function preventExtensions(it) {
    return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.seal.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.seal.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.2.17 Object.seal(O)
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var meta = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").onFreeze;

__webpack_require__(/*! ./_object-sap */ "./node_modules/core-js/modules/_object-sap.js")('seal', function ($seal) {
  return function seal(it) {
    return $seal && isObject(it) ? $seal(meta(it)) : it;
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.set-prototype-of.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.set-prototype-of.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 19.1.3.19 Object.setPrototypeOf(O, proto)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
$export($export.S, 'Object', { setPrototypeOf: __webpack_require__(/*! ./_set-proto */ "./node_modules/core-js/modules/_set-proto.js").set });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.object.to-string.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.object.to-string.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 19.1.3.6 Object.prototype.toString()
var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
var test = {};
test[__webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('toStringTag')] = 'z';
if (test + '' != '[object z]') {
  __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js")(Object.prototype, 'toString', function toString() {
    return '[object ' + classof(this) + ']';
  }, true);
}


/***/ }),

/***/ "./node_modules/core-js/modules/es6.parse-float.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.parse-float.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $parseFloat = __webpack_require__(/*! ./_parse-float */ "./node_modules/core-js/modules/_parse-float.js");
// 18.2.4 parseFloat(string)
$export($export.G + $export.F * (parseFloat != $parseFloat), { parseFloat: $parseFloat });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.parse-int.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.parse-int.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $parseInt = __webpack_require__(/*! ./_parse-int */ "./node_modules/core-js/modules/_parse-int.js");
// 18.2.5 parseInt(string, radix)
$export($export.G + $export.F * (parseInt != $parseInt), { parseInt: $parseInt });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.promise.js":
/*!*****************************************************!*\
  !*** ./node_modules/core-js/modules/es6.promise.js ***!
  \*****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var LIBRARY = __webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var ctx = __webpack_require__(/*! ./_ctx */ "./node_modules/core-js/modules/_ctx.js");
var classof = __webpack_require__(/*! ./_classof */ "./node_modules/core-js/modules/_classof.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");
var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/core-js/modules/_species-constructor.js");
var task = __webpack_require__(/*! ./_task */ "./node_modules/core-js/modules/_task.js").set;
var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/core-js/modules/_microtask.js")();
var newPromiseCapabilityModule = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/core-js/modules/_new-promise-capability.js");
var perform = __webpack_require__(/*! ./_perform */ "./node_modules/core-js/modules/_perform.js");
var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/core-js/modules/_user-agent.js");
var promiseResolve = __webpack_require__(/*! ./_promise-resolve */ "./node_modules/core-js/modules/_promise-resolve.js");
var PROMISE = 'Promise';
var TypeError = global.TypeError;
var process = global.process;
var versions = process && process.versions;
var v8 = versions && versions.v8 || '';
var $Promise = global[PROMISE];
var isNode = classof(process) == 'process';
var empty = function () { /* empty */ };
var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;

var USE_NATIVE = !!function () {
  try {
    // correct subclassing with @@species support
    var promise = $Promise.resolve(1);
    var FakePromise = (promise.constructor = {})[__webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('species')] = function (exec) {
      exec(empty, empty);
    };
    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test
    return (isNode || typeof PromiseRejectionEvent == 'function')
      && promise.then(empty) instanceof FakePromise
      // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
      // https://bugs.chromium.org/p/chromium/issues/detail?id=830565
      // we can't detect it synchronously, so just check versions
      && v8.indexOf('6.6') !== 0
      && userAgent.indexOf('Chrome/66') === -1;
  } catch (e) { /* empty */ }
}();

// helpers
var isThenable = function (it) {
  var then;
  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
};
var notify = function (promise, isReject) {
  if (promise._n) return;
  promise._n = true;
  var chain = promise._c;
  microtask(function () {
    var value = promise._v;
    var ok = promise._s == 1;
    var i = 0;
    var run = function (reaction) {
      var handler = ok ? reaction.ok : reaction.fail;
      var resolve = reaction.resolve;
      var reject = reaction.reject;
      var domain = reaction.domain;
      var result, then, exited;
      try {
        if (handler) {
          if (!ok) {
            if (promise._h == 2) onHandleUnhandled(promise);
            promise._h = 1;
          }
          if (handler === true) result = value;
          else {
            if (domain) domain.enter();
            result = handler(value); // may throw
            if (domain) {
              domain.exit();
              exited = true;
            }
          }
          if (result === reaction.promise) {
            reject(TypeError('Promise-chain cycle'));
          } else if (then = isThenable(result)) {
            then.call(result, resolve, reject);
          } else resolve(result);
        } else reject(value);
      } catch (e) {
        if (domain && !exited) domain.exit();
        reject(e);
      }
    };
    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach
    promise._c = [];
    promise._n = false;
    if (isReject && !promise._h) onUnhandled(promise);
  });
};
var onUnhandled = function (promise) {
  task.call(global, function () {
    var value = promise._v;
    var unhandled = isUnhandled(promise);
    var result, handler, console;
    if (unhandled) {
      result = perform(function () {
        if (isNode) {
          process.emit('unhandledRejection', value, promise);
        } else if (handler = global.onunhandledrejection) {
          handler({ promise: promise, reason: value });
        } else if ((console = global.console) && console.error) {
          console.error('Unhandled promise rejection', value);
        }
      });
      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
      promise._h = isNode || isUnhandled(promise) ? 2 : 1;
    } promise._a = undefined;
    if (unhandled && result.e) throw result.v;
  });
};
var isUnhandled = function (promise) {
  return promise._h !== 1 && (promise._a || promise._c).length === 0;
};
var onHandleUnhandled = function (promise) {
  task.call(global, function () {
    var handler;
    if (isNode) {
      process.emit('rejectionHandled', promise);
    } else if (handler = global.onrejectionhandled) {
      handler({ promise: promise, reason: promise._v });
    }
  });
};
var $reject = function (value) {
  var promise = this;
  if (promise._d) return;
  promise._d = true;
  promise = promise._w || promise; // unwrap
  promise._v = value;
  promise._s = 2;
  if (!promise._a) promise._a = promise._c.slice();
  notify(promise, true);
};
var $resolve = function (value) {
  var promise = this;
  var then;
  if (promise._d) return;
  promise._d = true;
  promise = promise._w || promise; // unwrap
  try {
    if (promise === value) throw TypeError("Promise can't be resolved itself");
    if (then = isThenable(value)) {
      microtask(function () {
        var wrapper = { _w: promise, _d: false }; // wrap
        try {
          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
        } catch (e) {
          $reject.call(wrapper, e);
        }
      });
    } else {
      promise._v = value;
      promise._s = 1;
      notify(promise, false);
    }
  } catch (e) {
    $reject.call({ _w: promise, _d: false }, e); // wrap
  }
};

// constructor polyfill
if (!USE_NATIVE) {
  // 25.4.3.1 Promise(executor)
  $Promise = function Promise(executor) {
    anInstance(this, $Promise, PROMISE, '_h');
    aFunction(executor);
    Internal.call(this);
    try {
      executor(ctx($resolve, this, 1), ctx($reject, this, 1));
    } catch (err) {
      $reject.call(this, err);
    }
  };
  // eslint-disable-next-line no-unused-vars
  Internal = function Promise(executor) {
    this._c = [];             // <- awaiting reactions
    this._a = undefined;      // <- checked in isUnhandled reactions
    this._s = 0;              // <- state
    this._d = false;          // <- done
    this._v = undefined;      // <- value
    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled
    this._n = false;          // <- notify
  };
  Internal.prototype = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js")($Promise.prototype, {
    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)
    then: function then(onFulfilled, onRejected) {
      var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
      reaction.fail = typeof onRejected == 'function' && onRejected;
      reaction.domain = isNode ? process.domain : undefined;
      this._c.push(reaction);
      if (this._a) this._a.push(reaction);
      if (this._s) notify(this, false);
      return reaction.promise;
    },
    // 25.4.5.1 Promise.prototype.catch(onRejected)
    'catch': function (onRejected) {
      return this.then(undefined, onRejected);
    }
  });
  OwnPromiseCapability = function () {
    var promise = new Internal();
    this.promise = promise;
    this.resolve = ctx($resolve, promise, 1);
    this.reject = ctx($reject, promise, 1);
  };
  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
    return C === $Promise || C === Wrapper
      ? new OwnPromiseCapability(C)
      : newGenericPromiseCapability(C);
  };
}

$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });
__webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js")($Promise, PROMISE);
__webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js")(PROMISE);
Wrapper = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js")[PROMISE];

// statics
$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
  // 25.4.4.5 Promise.reject(r)
  reject: function reject(r) {
    var capability = newPromiseCapability(this);
    var $$reject = capability.reject;
    $$reject(r);
    return capability.promise;
  }
});
$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
  // 25.4.4.6 Promise.resolve(x)
  resolve: function resolve(x) {
    return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
  }
});
$export($export.S + $export.F * !(USE_NATIVE && __webpack_require__(/*! ./_iter-detect */ "./node_modules/core-js/modules/_iter-detect.js")(function (iter) {
  $Promise.all(iter)['catch'](empty);
})), PROMISE, {
  // 25.4.4.1 Promise.all(iterable)
  all: function all(iterable) {
    var C = this;
    var capability = newPromiseCapability(C);
    var resolve = capability.resolve;
    var reject = capability.reject;
    var result = perform(function () {
      var values = [];
      var index = 0;
      var remaining = 1;
      forOf(iterable, false, function (promise) {
        var $index = index++;
        var alreadyCalled = false;
        values.push(undefined);
        remaining++;
        C.resolve(promise).then(function (value) {
          if (alreadyCalled) return;
          alreadyCalled = true;
          values[$index] = value;
          --remaining || resolve(values);
        }, reject);
      });
      --remaining || resolve(values);
    });
    if (result.e) reject(result.v);
    return capability.promise;
  },
  // 25.4.4.4 Promise.race(iterable)
  race: function race(iterable) {
    var C = this;
    var capability = newPromiseCapability(C);
    var reject = capability.reject;
    var result = perform(function () {
      forOf(iterable, false, function (promise) {
        C.resolve(promise).then(capability.resolve, reject);
      });
    });
    if (result.e) reject(result.v);
    return capability.promise;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.apply.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.apply.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.1 Reflect.apply(target, thisArgument, argumentsList)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var rApply = (__webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").Reflect || {}).apply;
var fApply = Function.apply;
// MS Edge argumentsList argument is optional
$export($export.S + $export.F * !__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  rApply(function () { /* empty */ });
}), 'Reflect', {
  apply: function apply(target, thisArgument, argumentsList) {
    var T = aFunction(target);
    var L = anObject(argumentsList);
    return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.construct.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.construct.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var create = __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var bind = __webpack_require__(/*! ./_bind */ "./node_modules/core-js/modules/_bind.js");
var rConstruct = (__webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").Reflect || {}).construct;

// MS Edge supports only 2 arguments and argumentsList argument is optional
// FF Nightly sets third argument as `new.target`, but does not create `this` from it
var NEW_TARGET_BUG = fails(function () {
  function F() { /* empty */ }
  return !(rConstruct(function () { /* empty */ }, [], F) instanceof F);
});
var ARGS_BUG = !fails(function () {
  rConstruct(function () { /* empty */ });
});

$export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {
  construct: function construct(Target, args /* , newTarget */) {
    aFunction(Target);
    anObject(args);
    var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);
    if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget);
    if (Target == newTarget) {
      // w/o altered newTarget, optimization for 0-4 arguments
      switch (args.length) {
        case 0: return new Target();
        case 1: return new Target(args[0]);
        case 2: return new Target(args[0], args[1]);
        case 3: return new Target(args[0], args[1], args[2]);
        case 4: return new Target(args[0], args[1], args[2], args[3]);
      }
      // w/o altered newTarget, lot of arguments case
      var $args = [null];
      $args.push.apply($args, args);
      return new (bind.apply(Target, $args))();
    }
    // with altered newTarget, not support built-in constructors
    var proto = newTarget.prototype;
    var instance = create(isObject(proto) ? proto : Object.prototype);
    var result = Function.apply.call(Target, instance, args);
    return isObject(result) ? result : instance;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.define-property.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.define-property.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");

// MS Edge has broken Reflect.defineProperty - throwing instead of returning false
$export($export.S + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  // eslint-disable-next-line no-undef
  Reflect.defineProperty(dP.f({}, 1, { value: 1 }), 1, { value: 2 });
}), 'Reflect', {
  defineProperty: function defineProperty(target, propertyKey, attributes) {
    anObject(target);
    propertyKey = toPrimitive(propertyKey, true);
    anObject(attributes);
    try {
      dP.f(target, propertyKey, attributes);
      return true;
    } catch (e) {
      return false;
    }
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.delete-property.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.delete-property.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.4 Reflect.deleteProperty(target, propertyKey)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f;
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");

$export($export.S, 'Reflect', {
  deleteProperty: function deleteProperty(target, propertyKey) {
    var desc = gOPD(anObject(target), propertyKey);
    return desc && !desc.configurable ? false : delete target[propertyKey];
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.enumerate.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.enumerate.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 26.1.5 Reflect.enumerate(target)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var Enumerate = function (iterated) {
  this._t = anObject(iterated); // target
  this._i = 0;                  // next index
  var keys = this._k = [];      // keys
  var key;
  for (key in iterated) keys.push(key);
};
__webpack_require__(/*! ./_iter-create */ "./node_modules/core-js/modules/_iter-create.js")(Enumerate, 'Object', function () {
  var that = this;
  var keys = that._k;
  var key;
  do {
    if (that._i >= keys.length) return { value: undefined, done: true };
  } while (!((key = keys[that._i++]) in that._t));
  return { value: key, done: false };
});

$export($export.S, 'Reflect', {
  enumerate: function enumerate(target) {
    return new Enumerate(target);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js":
/*!*********************************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js ***!
  \*********************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");

$export($export.S, 'Reflect', {
  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {
    return gOPD.f(anObject(target), propertyKey);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.get-prototype-of.js":
/*!**********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.get-prototype-of.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.8 Reflect.getPrototypeOf(target)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var getProto = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");

$export($export.S, 'Reflect', {
  getPrototypeOf: function getPrototypeOf(target) {
    return getProto(anObject(target));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.get.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.get.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.6 Reflect.get(target, propertyKey [, receiver])
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");

function get(target, propertyKey /* , receiver */) {
  var receiver = arguments.length < 3 ? target : arguments[2];
  var desc, proto;
  if (anObject(target) === receiver) return target[propertyKey];
  if (desc = gOPD.f(target, propertyKey)) return has(desc, 'value')
    ? desc.value
    : desc.get !== undefined
      ? desc.get.call(receiver)
      : undefined;
  if (isObject(proto = getPrototypeOf(target))) return get(proto, propertyKey, receiver);
}

$export($export.S, 'Reflect', { get: get });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.has.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.has.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.9 Reflect.has(target, propertyKey)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Reflect', {
  has: function has(target, propertyKey) {
    return propertyKey in target;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.is-extensible.js":
/*!*******************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.is-extensible.js ***!
  \*******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.10 Reflect.isExtensible(target)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var $isExtensible = Object.isExtensible;

$export($export.S, 'Reflect', {
  isExtensible: function isExtensible(target) {
    anObject(target);
    return $isExtensible ? $isExtensible(target) : true;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.own-keys.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.own-keys.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.11 Reflect.ownKeys(target)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Reflect', { ownKeys: __webpack_require__(/*! ./_own-keys */ "./node_modules/core-js/modules/_own-keys.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.prevent-extensions.js":
/*!************************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.prevent-extensions.js ***!
  \************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.12 Reflect.preventExtensions(target)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var $preventExtensions = Object.preventExtensions;

$export($export.S, 'Reflect', {
  preventExtensions: function preventExtensions(target) {
    anObject(target);
    try {
      if ($preventExtensions) $preventExtensions(target);
      return true;
    } catch (e) {
      return false;
    }
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.set-prototype-of.js":
/*!**********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.set-prototype-of.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.14 Reflect.setPrototypeOf(target, proto)
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var setProto = __webpack_require__(/*! ./_set-proto */ "./node_modules/core-js/modules/_set-proto.js");

if (setProto) $export($export.S, 'Reflect', {
  setPrototypeOf: function setPrototypeOf(target, proto) {
    setProto.check(target, proto);
    try {
      setProto.set(target, proto);
      return true;
    } catch (e) {
      return false;
    }
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.reflect.set.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.reflect.set.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 26.1.13 Reflect.set(target, propertyKey, V [, receiver])
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");

function set(target, propertyKey, V /* , receiver */) {
  var receiver = arguments.length < 4 ? target : arguments[3];
  var ownDesc = gOPD.f(anObject(target), propertyKey);
  var existingDescriptor, proto;
  if (!ownDesc) {
    if (isObject(proto = getPrototypeOf(target))) {
      return set(proto, propertyKey, V, receiver);
    }
    ownDesc = createDesc(0);
  }
  if (has(ownDesc, 'value')) {
    if (ownDesc.writable === false || !isObject(receiver)) return false;
    if (existingDescriptor = gOPD.f(receiver, propertyKey)) {
      if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;
      existingDescriptor.value = V;
      dP.f(receiver, propertyKey, existingDescriptor);
    } else dP.f(receiver, propertyKey, createDesc(0, V));
    return true;
  }
  return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);
}

$export($export.S, 'Reflect', { set: set });


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.constructor.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.constructor.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var inheritIfRequired = __webpack_require__(/*! ./_inherit-if-required */ "./node_modules/core-js/modules/_inherit-if-required.js");
var dP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f;
var gOPN = __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f;
var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/core-js/modules/_is-regexp.js");
var $flags = __webpack_require__(/*! ./_flags */ "./node_modules/core-js/modules/_flags.js");
var $RegExp = global.RegExp;
var Base = $RegExp;
var proto = $RegExp.prototype;
var re1 = /a/g;
var re2 = /a/g;
// "new" creates a new object, old webkit buggy here
var CORRECT_NEW = new $RegExp(re1) !== re1;

if (__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && (!CORRECT_NEW || __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  re2[__webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('match')] = false;
  // RegExp constructor can alter flags and IsRegExp works correct with @@match
  return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i';
}))) {
  $RegExp = function RegExp(p, f) {
    var tiRE = this instanceof $RegExp;
    var piRE = isRegExp(p);
    var fiU = f === undefined;
    return !tiRE && piRE && p.constructor === $RegExp && fiU ? p
      : inheritIfRequired(CORRECT_NEW
        ? new Base(piRE && !fiU ? p.source : p, f)
        : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f)
      , tiRE ? this : proto, $RegExp);
  };
  var proxy = function (key) {
    key in $RegExp || dP($RegExp, key, {
      configurable: true,
      get: function () { return Base[key]; },
      set: function (it) { Base[key] = it; }
    });
  };
  for (var keys = gOPN(Base), i = 0; keys.length > i;) proxy(keys[i++]);
  proto.constructor = $RegExp;
  $RegExp.prototype = proto;
  __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js")(global, 'RegExp', $RegExp);
}

__webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js")('RegExp');


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.exec.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.exec.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/core-js/modules/_regexp-exec.js");
__webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js")({
  target: 'RegExp',
  proto: true,
  forced: regexpExec !== /./.exec
}, {
  exec: regexpExec
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.flags.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.flags.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// 21.2.5.3 get RegExp.prototype.flags()
if (__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && /./g.flags != 'g') __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js").f(RegExp.prototype, 'flags', {
  configurable: true,
  get: __webpack_require__(/*! ./_flags */ "./node_modules/core-js/modules/_flags.js")
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.match.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.match.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/core-js/modules/_advance-string-index.js");
var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/core-js/modules/_regexp-exec-abstract.js");

// @@match logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('match', 1, function (defined, MATCH, $match, maybeCallNative) {
  return [
    // `String.prototype.match` method
    // https://tc39.github.io/ecma262/#sec-string.prototype.match
    function match(regexp) {
      var O = defined(this);
      var fn = regexp == undefined ? undefined : regexp[MATCH];
      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));
    },
    // `RegExp.prototype[@@match]` method
    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match
    function (regexp) {
      var res = maybeCallNative($match, regexp, this);
      if (res.done) return res.value;
      var rx = anObject(regexp);
      var S = String(this);
      if (!rx.global) return regExpExec(rx, S);
      var fullUnicode = rx.unicode;
      rx.lastIndex = 0;
      var A = [];
      var n = 0;
      var result;
      while ((result = regExpExec(rx, S)) !== null) {
        var matchStr = String(result[0]);
        A[n] = matchStr;
        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
        n++;
      }
      return n === 0 ? null : A;
    }
  ];
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.replace.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.replace.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/core-js/modules/_advance-string-index.js");
var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/core-js/modules/_regexp-exec-abstract.js");
var max = Math.max;
var min = Math.min;
var floor = Math.floor;
var SUBSTITUTION_SYMBOLS = /\$([$&`']|\d\d?|<[^>]*>)/g;
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&`']|\d\d?)/g;

var maybeToString = function (it) {
  return it === undefined ? it : String(it);
};

// @@replace logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) {
  return [
    // `String.prototype.replace` method
    // https://tc39.github.io/ecma262/#sec-string.prototype.replace
    function replace(searchValue, replaceValue) {
      var O = defined(this);
      var fn = searchValue == undefined ? undefined : searchValue[REPLACE];
      return fn !== undefined
        ? fn.call(searchValue, O, replaceValue)
        : $replace.call(String(O), searchValue, replaceValue);
    },
    // `RegExp.prototype[@@replace]` method
    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace
    function (regexp, replaceValue) {
      var res = maybeCallNative($replace, regexp, this, replaceValue);
      if (res.done) return res.value;

      var rx = anObject(regexp);
      var S = String(this);
      var functionalReplace = typeof replaceValue === 'function';
      if (!functionalReplace) replaceValue = String(replaceValue);
      var global = rx.global;
      if (global) {
        var fullUnicode = rx.unicode;
        rx.lastIndex = 0;
      }
      var results = [];
      while (true) {
        var result = regExpExec(rx, S);
        if (result === null) break;
        results.push(result);
        if (!global) break;
        var matchStr = String(result[0]);
        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
      }
      var accumulatedResult = '';
      var nextSourcePosition = 0;
      for (var i = 0; i < results.length; i++) {
        result = results[i];
        var matched = String(result[0]);
        var position = max(min(toInteger(result.index), S.length), 0);
        var captures = [];
        // NOTE: This is equivalent to
        //   captures = result.slice(1).map(maybeToString)
        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in
        // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
        for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));
        var namedCaptures = result.groups;
        if (functionalReplace) {
          var replacerArgs = [matched].concat(captures, position, S);
          if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);
          var replacement = String(replaceValue.apply(undefined, replacerArgs));
        } else {
          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
        }
        if (position >= nextSourcePosition) {
          accumulatedResult += S.slice(nextSourcePosition, position) + replacement;
          nextSourcePosition = position + matched.length;
        }
      }
      return accumulatedResult + S.slice(nextSourcePosition);
    }
  ];

    // https://tc39.github.io/ecma262/#sec-getsubstitution
  function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {
    var tailPos = position + matched.length;
    var m = captures.length;
    var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
    if (namedCaptures !== undefined) {
      namedCaptures = toObject(namedCaptures);
      symbols = SUBSTITUTION_SYMBOLS;
    }
    return $replace.call(replacement, symbols, function (match, ch) {
      var capture;
      switch (ch.charAt(0)) {
        case '$': return '$';
        case '&': return matched;
        case '`': return str.slice(0, position);
        case "'": return str.slice(tailPos);
        case '<':
          capture = namedCaptures[ch.slice(1, -1)];
          break;
        default: // \d\d?
          var n = +ch;
          if (n === 0) return match;
          if (n > m) {
            var f = floor(n / 10);
            if (f === 0) return match;
            if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);
            return match;
          }
          capture = captures[n - 1];
      }
      return capture === undefined ? '' : capture;
    });
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.search.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.search.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var sameValue = __webpack_require__(/*! ./_same-value */ "./node_modules/core-js/modules/_same-value.js");
var regExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/core-js/modules/_regexp-exec-abstract.js");

// @@search logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('search', 1, function (defined, SEARCH, $search, maybeCallNative) {
  return [
    // `String.prototype.search` method
    // https://tc39.github.io/ecma262/#sec-string.prototype.search
    function search(regexp) {
      var O = defined(this);
      var fn = regexp == undefined ? undefined : regexp[SEARCH];
      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));
    },
    // `RegExp.prototype[@@search]` method
    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search
    function (regexp) {
      var res = maybeCallNative($search, regexp, this);
      if (res.done) return res.value;
      var rx = anObject(regexp);
      var S = String(this);
      var previousLastIndex = rx.lastIndex;
      if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
      var result = regExpExec(rx, S);
      if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
      return result === null ? -1 : result.index;
    }
  ];
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.split.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.split.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/core-js/modules/_is-regexp.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/core-js/modules/_species-constructor.js");
var advanceStringIndex = __webpack_require__(/*! ./_advance-string-index */ "./node_modules/core-js/modules/_advance-string-index.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var callRegExpExec = __webpack_require__(/*! ./_regexp-exec-abstract */ "./node_modules/core-js/modules/_regexp-exec-abstract.js");
var regexpExec = __webpack_require__(/*! ./_regexp-exec */ "./node_modules/core-js/modules/_regexp-exec.js");
var fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var $min = Math.min;
var $push = [].push;
var $SPLIT = 'split';
var LENGTH = 'length';
var LAST_INDEX = 'lastIndex';
var MAX_UINT32 = 0xffffffff;

// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError
var SUPPORTS_Y = !fails(function () { RegExp(MAX_UINT32, 'y'); });

// @@split logic
__webpack_require__(/*! ./_fix-re-wks */ "./node_modules/core-js/modules/_fix-re-wks.js")('split', 2, function (defined, SPLIT, $split, maybeCallNative) {
  var internalSplit;
  if (
    'abbc'[$SPLIT](/(b)*/)[1] == 'c' ||
    'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||
    'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||
    '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||
    '.'[$SPLIT](/()()/)[LENGTH] > 1 ||
    ''[$SPLIT](/.?/)[LENGTH]
  ) {
    // based on es5-shim implementation, need to rework it
    internalSplit = function (separator, limit) {
      var string = String(this);
      if (separator === undefined && limit === 0) return [];
      // If `separator` is not a regex, use native split
      if (!isRegExp(separator)) return $split.call(string, separator, limit);
      var output = [];
      var flags = (separator.ignoreCase ? 'i' : '') +
                  (separator.multiline ? 'm' : '') +
                  (separator.unicode ? 'u' : '') +
                  (separator.sticky ? 'y' : '');
      var lastLastIndex = 0;
      var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0;
      // Make `global` and avoid `lastIndex` issues by working with a copy
      var separatorCopy = new RegExp(separator.source, flags + 'g');
      var match, lastIndex, lastLength;
      while (match = regexpExec.call(separatorCopy, string)) {
        lastIndex = separatorCopy[LAST_INDEX];
        if (lastIndex > lastLastIndex) {
          output.push(string.slice(lastLastIndex, match.index));
          if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1));
          lastLength = match[0][LENGTH];
          lastLastIndex = lastIndex;
          if (output[LENGTH] >= splitLimit) break;
        }
        if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop
      }
      if (lastLastIndex === string[LENGTH]) {
        if (lastLength || !separatorCopy.test('')) output.push('');
      } else output.push(string.slice(lastLastIndex));
      return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;
    };
  // Chakra, V8
  } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) {
    internalSplit = function (separator, limit) {
      return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit);
    };
  } else {
    internalSplit = $split;
  }

  return [
    // `String.prototype.split` method
    // https://tc39.github.io/ecma262/#sec-string.prototype.split
    function split(separator, limit) {
      var O = defined(this);
      var splitter = separator == undefined ? undefined : separator[SPLIT];
      return splitter !== undefined
        ? splitter.call(separator, O, limit)
        : internalSplit.call(String(O), separator, limit);
    },
    // `RegExp.prototype[@@split]` method
    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split
    //
    // NOTE: This cannot be properly polyfilled in engines that don't support
    // the 'y' flag.
    function (regexp, limit) {
      var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split);
      if (res.done) return res.value;

      var rx = anObject(regexp);
      var S = String(this);
      var C = speciesConstructor(rx, RegExp);

      var unicodeMatching = rx.unicode;
      var flags = (rx.ignoreCase ? 'i' : '') +
                  (rx.multiline ? 'm' : '') +
                  (rx.unicode ? 'u' : '') +
                  (SUPPORTS_Y ? 'y' : 'g');

      // ^(? + rx + ) is needed, in combination with some S slicing, to
      // simulate the 'y' flag.
      var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);
      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
      if (lim === 0) return [];
      if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
      var p = 0;
      var q = 0;
      var A = [];
      while (q < S.length) {
        splitter.lastIndex = SUPPORTS_Y ? q : 0;
        var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q));
        var e;
        if (
          z === null ||
          (e = $min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p
        ) {
          q = advanceStringIndex(S, q, unicodeMatching);
        } else {
          A.push(S.slice(p, q));
          if (A.length === lim) return A;
          for (var i = 1; i <= z.length - 1; i++) {
            A.push(z[i]);
            if (A.length === lim) return A;
          }
          q = p = e;
        }
      }
      A.push(S.slice(p));
      return A;
    }
  ];
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.regexp.to-string.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.regexp.to-string.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

__webpack_require__(/*! ./es6.regexp.flags */ "./node_modules/core-js/modules/es6.regexp.flags.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var $flags = __webpack_require__(/*! ./_flags */ "./node_modules/core-js/modules/_flags.js");
var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js");
var TO_STRING = 'toString';
var $toString = /./[TO_STRING];

var define = function (fn) {
  __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js")(RegExp.prototype, TO_STRING, fn, true);
};

// 21.2.5.14 RegExp.prototype.toString()
if (__webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () { return $toString.call({ source: 'a', flags: 'b' }) != '/a/b'; })) {
  define(function toString() {
    var R = anObject(this);
    return '/'.concat(R.source, '/',
      'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined);
  });
// FF44- RegExp#toString has a wrong name
} else if ($toString.name != TO_STRING) {
  define(function toString() {
    return $toString.call(this);
  });
}


/***/ }),

/***/ "./node_modules/core-js/modules/es6.set.js":
/*!*************************************************!*\
  !*** ./node_modules/core-js/modules/es6.set.js ***!
  \*************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var strong = __webpack_require__(/*! ./_collection-strong */ "./node_modules/core-js/modules/_collection-strong.js");
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var SET = 'Set';

// 23.2 Set Objects
module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/core-js/modules/_collection.js")(SET, function (get) {
  return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.2.3.1 Set.prototype.add(value)
  add: function add(value) {
    return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value);
  }
}, strong);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.anchor.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.anchor.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.2 String.prototype.anchor(name)
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('anchor', function (createHTML) {
  return function anchor(name) {
    return createHTML(this, 'a', 'name', name);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.big.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.big.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.3 String.prototype.big()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('big', function (createHTML) {
  return function big() {
    return createHTML(this, 'big', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.blink.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.blink.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.4 String.prototype.blink()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('blink', function (createHTML) {
  return function blink() {
    return createHTML(this, 'blink', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.bold.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.bold.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.5 String.prototype.bold()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('bold', function (createHTML) {
  return function bold() {
    return createHTML(this, 'b', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.code-point-at.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.code-point-at.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/core-js/modules/_string-at.js")(false);
$export($export.P, 'String', {
  // 21.1.3.3 String.prototype.codePointAt(pos)
  codePointAt: function codePointAt(pos) {
    return $at(this, pos);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.ends-with.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.ends-with.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var context = __webpack_require__(/*! ./_string-context */ "./node_modules/core-js/modules/_string-context.js");
var ENDS_WITH = 'endsWith';
var $endsWith = ''[ENDS_WITH];

$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/core-js/modules/_fails-is-regexp.js")(ENDS_WITH), 'String', {
  endsWith: function endsWith(searchString /* , endPosition = @length */) {
    var that = context(this, searchString, ENDS_WITH);
    var endPosition = arguments.length > 1 ? arguments[1] : undefined;
    var len = toLength(that.length);
    var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
    var search = String(searchString);
    return $endsWith
      ? $endsWith.call(that, search, end)
      : that.slice(end - search.length, end) === search;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.fixed.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.fixed.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.6 String.prototype.fixed()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('fixed', function (createHTML) {
  return function fixed() {
    return createHTML(this, 'tt', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.fontcolor.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.fontcolor.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.7 String.prototype.fontcolor(color)
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('fontcolor', function (createHTML) {
  return function fontcolor(color) {
    return createHTML(this, 'font', 'color', color);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.fontsize.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.fontsize.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.8 String.prototype.fontsize(size)
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('fontsize', function (createHTML) {
  return function fontsize(size) {
    return createHTML(this, 'font', 'size', size);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.from-code-point.js":
/*!********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.from-code-point.js ***!
  \********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
var fromCharCode = String.fromCharCode;
var $fromCodePoint = String.fromCodePoint;

// length should be 1, old FF problem
$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
  // 21.1.2.2 String.fromCodePoint(...codePoints)
  fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars
    var res = [];
    var aLen = arguments.length;
    var i = 0;
    var code;
    while (aLen > i) {
      code = +arguments[i++];
      if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');
      res.push(code < 0x10000
        ? fromCharCode(code)
        : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)
      );
    } return res.join('');
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.includes.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.includes.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.7 String.prototype.includes(searchString, position = 0)

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var context = __webpack_require__(/*! ./_string-context */ "./node_modules/core-js/modules/_string-context.js");
var INCLUDES = 'includes';

$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/core-js/modules/_fails-is-regexp.js")(INCLUDES), 'String', {
  includes: function includes(searchString /* , position = 0 */) {
    return !!~context(this, searchString, INCLUDES)
      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.italics.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.italics.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.9 String.prototype.italics()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('italics', function (createHTML) {
  return function italics() {
    return createHTML(this, 'i', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.iterator.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.iterator.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/core-js/modules/_string-at.js")(true);

// 21.1.3.27 String.prototype[@@iterator]()
__webpack_require__(/*! ./_iter-define */ "./node_modules/core-js/modules/_iter-define.js")(String, 'String', function (iterated) {
  this._t = String(iterated); // target
  this._i = 0;                // next index
// 21.1.5.2.1 %StringIteratorPrototype%.next()
}, function () {
  var O = this._t;
  var index = this._i;
  var point;
  if (index >= O.length) return { value: undefined, done: true };
  point = $at(O, index);
  this._i += point.length;
  return { value: point, done: false };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.link.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.link.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.10 String.prototype.link(url)
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('link', function (createHTML) {
  return function link(url) {
    return createHTML(this, 'a', 'href', url);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.raw.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.raw.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");

$export($export.S, 'String', {
  // 21.1.2.4 String.raw(callSite, ...substitutions)
  raw: function raw(callSite) {
    var tpl = toIObject(callSite.raw);
    var len = toLength(tpl.length);
    var aLen = arguments.length;
    var res = [];
    var i = 0;
    while (len > i) {
      res.push(String(tpl[i++]));
      if (i < aLen) res.push(String(arguments[i]));
    } return res.join('');
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.repeat.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.repeat.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P, 'String', {
  // 21.1.3.13 String.prototype.repeat(count)
  repeat: __webpack_require__(/*! ./_string-repeat */ "./node_modules/core-js/modules/_string-repeat.js")
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.small.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.small.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.11 String.prototype.small()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('small', function (createHTML) {
  return function small() {
    return createHTML(this, 'small', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.starts-with.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.starts-with.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// 21.1.3.18 String.prototype.startsWith(searchString [, position ])

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var context = __webpack_require__(/*! ./_string-context */ "./node_modules/core-js/modules/_string-context.js");
var STARTS_WITH = 'startsWith';
var $startsWith = ''[STARTS_WITH];

$export($export.P + $export.F * __webpack_require__(/*! ./_fails-is-regexp */ "./node_modules/core-js/modules/_fails-is-regexp.js")(STARTS_WITH), 'String', {
  startsWith: function startsWith(searchString /* , position = 0 */) {
    var that = context(this, searchString, STARTS_WITH);
    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
    var search = String(searchString);
    return $startsWith
      ? $startsWith.call(that, search, index)
      : that.slice(index, index + search.length) === search;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.strike.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.strike.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.12 String.prototype.strike()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('strike', function (createHTML) {
  return function strike() {
    return createHTML(this, 'strike', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.sub.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.sub.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.13 String.prototype.sub()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('sub', function (createHTML) {
  return function sub() {
    return createHTML(this, 'sub', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.sup.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.sup.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// B.2.3.14 String.prototype.sup()
__webpack_require__(/*! ./_string-html */ "./node_modules/core-js/modules/_string-html.js")('sup', function (createHTML) {
  return function sup() {
    return createHTML(this, 'sup', '', '');
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.string.trim.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es6.string.trim.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// 21.1.3.25 String.prototype.trim()
__webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js")('trim', function ($trim) {
  return function trim() {
    return $trim(this, 3);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.symbol.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/es6.symbol.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// ECMAScript 6 symbols shim
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var has = __webpack_require__(/*! ./_has */ "./node_modules/core-js/modules/_has.js");
var DESCRIPTORS = __webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var META = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js").KEY;
var $fails = __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js");
var shared = __webpack_require__(/*! ./_shared */ "./node_modules/core-js/modules/_shared.js");
var setToStringTag = __webpack_require__(/*! ./_set-to-string-tag */ "./node_modules/core-js/modules/_set-to-string-tag.js");
var uid = __webpack_require__(/*! ./_uid */ "./node_modules/core-js/modules/_uid.js");
var wks = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");
var wksExt = __webpack_require__(/*! ./_wks-ext */ "./node_modules/core-js/modules/_wks-ext.js");
var wksDefine = __webpack_require__(/*! ./_wks-define */ "./node_modules/core-js/modules/_wks-define.js");
var enumKeys = __webpack_require__(/*! ./_enum-keys */ "./node_modules/core-js/modules/_enum-keys.js");
var isArray = __webpack_require__(/*! ./_is-array */ "./node_modules/core-js/modules/_is-array.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var createDesc = __webpack_require__(/*! ./_property-desc */ "./node_modules/core-js/modules/_property-desc.js");
var _create = __webpack_require__(/*! ./_object-create */ "./node_modules/core-js/modules/_object-create.js");
var gOPNExt = __webpack_require__(/*! ./_object-gopn-ext */ "./node_modules/core-js/modules/_object-gopn-ext.js");
var $GOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
var $DP = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");
var $keys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");
var gOPD = $GOPD.f;
var dP = $DP.f;
var gOPN = gOPNExt.f;
var $Symbol = global.Symbol;
var $JSON = global.JSON;
var _stringify = $JSON && $JSON.stringify;
var PROTOTYPE = 'prototype';
var HIDDEN = wks('_hidden');
var TO_PRIMITIVE = wks('toPrimitive');
var isEnum = {}.propertyIsEnumerable;
var SymbolRegistry = shared('symbol-registry');
var AllSymbols = shared('symbols');
var OPSymbols = shared('op-symbols');
var ObjectProto = Object[PROTOTYPE];
var USE_NATIVE = typeof $Symbol == 'function';
var QObject = global.QObject;
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;

// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDesc = DESCRIPTORS && $fails(function () {
  return _create(dP({}, 'a', {
    get: function () { return dP(this, 'a', { value: 7 }).a; }
  })).a != 7;
}) ? function (it, key, D) {
  var protoDesc = gOPD(ObjectProto, key);
  if (protoDesc) delete ObjectProto[key];
  dP(it, key, D);
  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
} : dP;

var wrap = function (tag) {
  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
  sym._k = tag;
  return sym;
};

var isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {
  return typeof it == 'symbol';
} : function (it) {
  return it instanceof $Symbol;
};

var $defineProperty = function defineProperty(it, key, D) {
  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
  anObject(it);
  key = toPrimitive(key, true);
  anObject(D);
  if (has(AllSymbols, key)) {
    if (!D.enumerable) {
      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
      it[HIDDEN][key] = true;
    } else {
      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
      D = _create(D, { enumerable: createDesc(0, false) });
    } return setSymbolDesc(it, key, D);
  } return dP(it, key, D);
};
var $defineProperties = function defineProperties(it, P) {
  anObject(it);
  var keys = enumKeys(P = toIObject(P));
  var i = 0;
  var l = keys.length;
  var key;
  while (l > i) $defineProperty(it, key = keys[i++], P[key]);
  return it;
};
var $create = function create(it, P) {
  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
};
var $propertyIsEnumerable = function propertyIsEnumerable(key) {
  var E = isEnum.call(this, key = toPrimitive(key, true));
  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
  it = toIObject(it);
  key = toPrimitive(key, true);
  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
  var D = gOPD(it, key);
  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
  return D;
};
var $getOwnPropertyNames = function getOwnPropertyNames(it) {
  var names = gOPN(toIObject(it));
  var result = [];
  var i = 0;
  var key;
  while (names.length > i) {
    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
  } return result;
};
var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
  var IS_OP = it === ObjectProto;
  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
  var result = [];
  var i = 0;
  var key;
  while (names.length > i) {
    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
  } return result;
};

// 19.4.1.1 Symbol([description])
if (!USE_NATIVE) {
  $Symbol = function Symbol() {
    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
    var $set = function (value) {
      if (this === ObjectProto) $set.call(OPSymbols, value);
      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
      setSymbolDesc(this, tag, createDesc(1, value));
    };
    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });
    return wrap(tag);
  };
  redefine($Symbol[PROTOTYPE], 'toString', function toString() {
    return this._k;
  });

  $GOPD.f = $getOwnPropertyDescriptor;
  $DP.f = $defineProperty;
  __webpack_require__(/*! ./_object-gopn */ "./node_modules/core-js/modules/_object-gopn.js").f = gOPNExt.f = $getOwnPropertyNames;
  __webpack_require__(/*! ./_object-pie */ "./node_modules/core-js/modules/_object-pie.js").f = $propertyIsEnumerable;
  __webpack_require__(/*! ./_object-gops */ "./node_modules/core-js/modules/_object-gops.js").f = $getOwnPropertySymbols;

  if (DESCRIPTORS && !__webpack_require__(/*! ./_library */ "./node_modules/core-js/modules/_library.js")) {
    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
  }

  wksExt.f = function (name) {
    return wrap(wks(name));
  };
}

$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });

for (var es6Symbols = (
  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14
  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'
).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);

for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);

$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
  // 19.4.2.1 Symbol.for(key)
  'for': function (key) {
    return has(SymbolRegistry, key += '')
      ? SymbolRegistry[key]
      : SymbolRegistry[key] = $Symbol(key);
  },
  // 19.4.2.5 Symbol.keyFor(sym)
  keyFor: function keyFor(sym) {
    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;
  },
  useSetter: function () { setter = true; },
  useSimple: function () { setter = false; }
});

$export($export.S + $export.F * !USE_NATIVE, 'Object', {
  // 19.1.2.2 Object.create(O [, Properties])
  create: $create,
  // 19.1.2.4 Object.defineProperty(O, P, Attributes)
  defineProperty: $defineProperty,
  // 19.1.2.3 Object.defineProperties(O, Properties)
  defineProperties: $defineProperties,
  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
  // 19.1.2.7 Object.getOwnPropertyNames(O)
  getOwnPropertyNames: $getOwnPropertyNames,
  // 19.1.2.8 Object.getOwnPropertySymbols(O)
  getOwnPropertySymbols: $getOwnPropertySymbols
});

// 24.3.2 JSON.stringify(value [, replacer [, space]])
$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
  var S = $Symbol();
  // MS Edge converts symbol values to JSON as {}
  // WebKit converts symbol values to JSON as null
  // V8 throws on boxed symbols
  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';
})), 'JSON', {
  stringify: function stringify(it) {
    var args = [it];
    var i = 1;
    var replacer, $replacer;
    while (arguments.length > i) args.push(arguments[i++]);
    $replacer = replacer = args[1];
    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
    if (!isArray(replacer)) replacer = function (key, value) {
      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
      if (!isSymbol(value)) return value;
    };
    args[1] = replacer;
    return _stringify.apply($JSON, args);
  }
});

// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)
$Symbol[PROTOTYPE][TO_PRIMITIVE] || __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js")($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
// 19.4.3.5 Symbol.prototype[@@toStringTag]
setToStringTag($Symbol, 'Symbol');
// 20.2.1.9 Math[@@toStringTag]
setToStringTag(Math, 'Math', true);
// 24.3.3 JSON[@@toStringTag]
setToStringTag(global.JSON, 'JSON', true);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.array-buffer.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.array-buffer.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $typed = __webpack_require__(/*! ./_typed */ "./node_modules/core-js/modules/_typed.js");
var buffer = __webpack_require__(/*! ./_typed-buffer */ "./node_modules/core-js/modules/_typed-buffer.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toAbsoluteIndex = __webpack_require__(/*! ./_to-absolute-index */ "./node_modules/core-js/modules/_to-absolute-index.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var ArrayBuffer = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").ArrayBuffer;
var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/core-js/modules/_species-constructor.js");
var $ArrayBuffer = buffer.ArrayBuffer;
var $DataView = buffer.DataView;
var $isView = $typed.ABV && ArrayBuffer.isView;
var $slice = $ArrayBuffer.prototype.slice;
var VIEW = $typed.VIEW;
var ARRAY_BUFFER = 'ArrayBuffer';

$export($export.G + $export.W + $export.F * (ArrayBuffer !== $ArrayBuffer), { ArrayBuffer: $ArrayBuffer });

$export($export.S + $export.F * !$typed.CONSTR, ARRAY_BUFFER, {
  // 24.1.3.1 ArrayBuffer.isView(arg)
  isView: function isView(it) {
    return $isView && $isView(it) || isObject(it) && VIEW in it;
  }
});

$export($export.P + $export.U + $export.F * __webpack_require__(/*! ./_fails */ "./node_modules/core-js/modules/_fails.js")(function () {
  return !new $ArrayBuffer(2).slice(1, undefined).byteLength;
}), ARRAY_BUFFER, {
  // 24.1.4.3 ArrayBuffer.prototype.slice(start, end)
  slice: function slice(start, end) {
    if ($slice !== undefined && end === undefined) return $slice.call(anObject(this), start); // FF fix
    var len = anObject(this).byteLength;
    var first = toAbsoluteIndex(start, len);
    var fin = toAbsoluteIndex(end === undefined ? len : end, len);
    var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(fin - first));
    var viewS = new $DataView(this);
    var viewT = new $DataView(result);
    var index = 0;
    while (first < fin) {
      viewT.setUint8(index++, viewS.getUint8(first++));
    } return result;
  }
});

__webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js")(ARRAY_BUFFER);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.data-view.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.data-view.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
$export($export.G + $export.W + $export.F * !__webpack_require__(/*! ./_typed */ "./node_modules/core-js/modules/_typed.js").ABV, {
  DataView: __webpack_require__(/*! ./_typed-buffer */ "./node_modules/core-js/modules/_typed-buffer.js").DataView
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.float32-array.js":
/*!*****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.float32-array.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Float32', 4, function (init) {
  return function Float32Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.float64-array.js":
/*!*****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.float64-array.js ***!
  \*****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Float64', 8, function (init) {
  return function Float64Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.int16-array.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.int16-array.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Int16', 2, function (init) {
  return function Int16Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.int32-array.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.int32-array.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Int32', 4, function (init) {
  return function Int32Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.int8-array.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.int8-array.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Int8', 1, function (init) {
  return function Int8Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.uint16-array.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.uint16-array.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Uint16', 2, function (init) {
  return function Uint16Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.uint32-array.js":
/*!****************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.uint32-array.js ***!
  \****************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Uint32', 4, function (init) {
  return function Uint32Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.uint8-array.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.uint8-array.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Uint8', 1, function (init) {
  return function Uint8Array(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
});


/***/ }),

/***/ "./node_modules/core-js/modules/es6.typed.uint8-clamped-array.js":
/*!***********************************************************************!*\
  !*** ./node_modules/core-js/modules/es6.typed.uint8-clamped-array.js ***!
  \***********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_typed-array */ "./node_modules/core-js/modules/_typed-array.js")('Uint8', 1, function (init) {
  return function Uint8ClampedArray(data, byteOffset, length) {
    return init(this, data, byteOffset, length);
  };
}, true);


/***/ }),

/***/ "./node_modules/core-js/modules/es6.weak-map.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.weak-map.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var each = __webpack_require__(/*! ./_array-methods */ "./node_modules/core-js/modules/_array-methods.js")(0);
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var meta = __webpack_require__(/*! ./_meta */ "./node_modules/core-js/modules/_meta.js");
var assign = __webpack_require__(/*! ./_object-assign */ "./node_modules/core-js/modules/_object-assign.js");
var weak = __webpack_require__(/*! ./_collection-weak */ "./node_modules/core-js/modules/_collection-weak.js");
var isObject = __webpack_require__(/*! ./_is-object */ "./node_modules/core-js/modules/_is-object.js");
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var NATIVE_WEAK_MAP = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
var WEAK_MAP = 'WeakMap';
var getWeak = meta.getWeak;
var isExtensible = Object.isExtensible;
var uncaughtFrozenStore = weak.ufstore;
var InternalMap;

var wrapper = function (get) {
  return function WeakMap() {
    return get(this, arguments.length > 0 ? arguments[0] : undefined);
  };
};

var methods = {
  // 23.3.3.3 WeakMap.prototype.get(key)
  get: function get(key) {
    if (isObject(key)) {
      var data = getWeak(key);
      if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);
      return data ? data[this._i] : undefined;
    }
  },
  // 23.3.3.5 WeakMap.prototype.set(key, value)
  set: function set(key, value) {
    return weak.def(validate(this, WEAK_MAP), key, value);
  }
};

// 23.3 WeakMap Objects
var $WeakMap = module.exports = __webpack_require__(/*! ./_collection */ "./node_modules/core-js/modules/_collection.js")(WEAK_MAP, wrapper, methods, weak, true, true);

// IE11 WeakMap frozen keys fix
if (NATIVE_WEAK_MAP && IS_IE11) {
  InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
  assign(InternalMap.prototype, methods);
  meta.NEED = true;
  each(['delete', 'has', 'get', 'set'], function (key) {
    var proto = $WeakMap.prototype;
    var method = proto[key];
    redefine(proto, key, function (a, b) {
      // store frozen objects on internal weakmap shim
      if (isObject(a) && !isExtensible(a)) {
        if (!this._f) this._f = new InternalMap();
        var result = this._f[key](a, b);
        return key == 'set' ? this : result;
      // store all the rest on native weakmap
      } return method.call(this, a, b);
    });
  });
}


/***/ }),

/***/ "./node_modules/core-js/modules/es6.weak-set.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es6.weak-set.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var weak = __webpack_require__(/*! ./_collection-weak */ "./node_modules/core-js/modules/_collection-weak.js");
var validate = __webpack_require__(/*! ./_validate-collection */ "./node_modules/core-js/modules/_validate-collection.js");
var WEAK_SET = 'WeakSet';

// 23.4 WeakSet Objects
__webpack_require__(/*! ./_collection */ "./node_modules/core-js/modules/_collection.js")(WEAK_SET, function (get) {
  return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
}, {
  // 23.4.3.1 WeakSet.prototype.add(value)
  add: function add(value) {
    return weak.def(validate(this, WEAK_SET), value, true);
  }
}, weak, false, true);


/***/ }),

/***/ "./node_modules/core-js/modules/es7.array.flat-map.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.array.flat-map.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var flattenIntoArray = __webpack_require__(/*! ./_flatten-into-array */ "./node_modules/core-js/modules/_flatten-into-array.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var arraySpeciesCreate = __webpack_require__(/*! ./_array-species-create */ "./node_modules/core-js/modules/_array-species-create.js");

$export($export.P, 'Array', {
  flatMap: function flatMap(callbackfn /* , thisArg */) {
    var O = toObject(this);
    var sourceLen, A;
    aFunction(callbackfn);
    sourceLen = toLength(O.length);
    A = arraySpeciesCreate(O, 0);
    flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);
    return A;
  }
});

__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")('flatMap');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.array.flatten.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.array.flatten.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var flattenIntoArray = __webpack_require__(/*! ./_flatten-into-array */ "./node_modules/core-js/modules/_flatten-into-array.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var toInteger = __webpack_require__(/*! ./_to-integer */ "./node_modules/core-js/modules/_to-integer.js");
var arraySpeciesCreate = __webpack_require__(/*! ./_array-species-create */ "./node_modules/core-js/modules/_array-species-create.js");

$export($export.P, 'Array', {
  flatten: function flatten(/* depthArg = 1 */) {
    var depthArg = arguments[0];
    var O = toObject(this);
    var sourceLen = toLength(O.length);
    var A = arraySpeciesCreate(O, 0);
    flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));
    return A;
  }
});

__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")('flatten');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.array.includes.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.array.includes.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/Array.prototype.includes
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $includes = __webpack_require__(/*! ./_array-includes */ "./node_modules/core-js/modules/_array-includes.js")(true);

$export($export.P, 'Array', {
  includes: function includes(el /* , fromIndex = 0 */) {
    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
  }
});

__webpack_require__(/*! ./_add-to-unscopables */ "./node_modules/core-js/modules/_add-to-unscopables.js")('includes');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.asap.js":
/*!**************************************************!*\
  !*** ./node_modules/core-js/modules/es7.asap.js ***!
  \**************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/core-js/modules/_microtask.js")();
var process = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js").process;
var isNode = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js")(process) == 'process';

$export($export.G, {
  asap: function asap(fn) {
    var domain = isNode && process.domain;
    microtask(domain ? domain.bind(fn) : fn);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.error.is-error.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.error.is-error.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/ljharb/proposal-is-error
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var cof = __webpack_require__(/*! ./_cof */ "./node_modules/core-js/modules/_cof.js");

$export($export.S, 'Error', {
  isError: function isError(it) {
    return cof(it) === 'Error';
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.global.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/es7.global.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-global
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.G, { global: __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.map.from.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es7.map.from.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from
__webpack_require__(/*! ./_set-collection-from */ "./node_modules/core-js/modules/_set-collection-from.js")('Map');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.map.of.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/es7.map.of.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of
__webpack_require__(/*! ./_set-collection-of */ "./node_modules/core-js/modules/_set-collection-of.js")('Map');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.map.to-json.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.map.to-json.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/DavidBruant/Map-Set.prototype.toJSON
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P + $export.R, 'Map', { toJSON: __webpack_require__(/*! ./_collection-to-json */ "./node_modules/core-js/modules/_collection-to-json.js")('Map') });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.clamp.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.clamp.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  clamp: function clamp(x, lower, upper) {
    return Math.min(upper, Math.max(lower, x));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.deg-per-rad.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.deg-per-rad.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { DEG_PER_RAD: Math.PI / 180 });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.degrees.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.degrees.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var RAD_PER_DEG = 180 / Math.PI;

$export($export.S, 'Math', {
  degrees: function degrees(radians) {
    return radians * RAD_PER_DEG;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.fscale.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.fscale.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var scale = __webpack_require__(/*! ./_math-scale */ "./node_modules/core-js/modules/_math-scale.js");
var fround = __webpack_require__(/*! ./_math-fround */ "./node_modules/core-js/modules/_math-fround.js");

$export($export.S, 'Math', {
  fscale: function fscale(x, inLow, inHigh, outLow, outHigh) {
    return fround(scale(x, inLow, inHigh, outLow, outHigh));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.iaddh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.iaddh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  iaddh: function iaddh(x0, x1, y0, y1) {
    var $x0 = x0 >>> 0;
    var $x1 = x1 >>> 0;
    var $y0 = y0 >>> 0;
    return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.imulh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.imulh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  imulh: function imulh(u, v) {
    var UINT16 = 0xffff;
    var $u = +u;
    var $v = +v;
    var u0 = $u & UINT16;
    var v0 = $v & UINT16;
    var u1 = $u >> 16;
    var v1 = $v >> 16;
    var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
    return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.isubh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.isubh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  isubh: function isubh(x0, x1, y0, y1) {
    var $x0 = x0 >>> 0;
    var $x1 = x1 >>> 0;
    var $y0 = y0 >>> 0;
    return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.rad-per-deg.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.rad-per-deg.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { RAD_PER_DEG: 180 / Math.PI });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.radians.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.radians.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var DEG_PER_RAD = Math.PI / 180;

$export($export.S, 'Math', {
  radians: function radians(degrees) {
    return degrees * DEG_PER_RAD;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.scale.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.scale.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://rwaldron.github.io/proposal-math-extensions/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { scale: __webpack_require__(/*! ./_math-scale */ "./node_modules/core-js/modules/_math-scale.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.signbit.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.signbit.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// http://jfbastien.github.io/papers/Math.signbit.html
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', { signbit: function signbit(x) {
  // eslint-disable-next-line no-self-compare
  return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0;
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.math.umulh.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.math.umulh.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://gist.github.com/BrendanEich/4294d5c212a6d2254703
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'Math', {
  umulh: function umulh(u, v) {
    var UINT16 = 0xffff;
    var $u = +u;
    var $v = +v;
    var u0 = $u & UINT16;
    var v0 = $v & UINT16;
    var u1 = $u >>> 16;
    var v1 = $v >>> 16;
    var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);
    return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.define-getter.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.define-getter.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");

// B.2.2.2 Object.prototype.__defineGetter__(P, getter)
__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
  __defineGetter__: function __defineGetter__(P, getter) {
    $defineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true });
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.define-setter.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.define-setter.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var $defineProperty = __webpack_require__(/*! ./_object-dp */ "./node_modules/core-js/modules/_object-dp.js");

// B.2.2.3 Object.prototype.__defineSetter__(P, setter)
__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
  __defineSetter__: function __defineSetter__(P, setter) {
    $defineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true });
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.entries.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.entries.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-values-entries
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $entries = __webpack_require__(/*! ./_object-to-array */ "./node_modules/core-js/modules/_object-to-array.js")(true);

$export($export.S, 'Object', {
  entries: function entries(it) {
    return $entries(it);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js":
/*!*********************************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js ***!
  \*********************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-getownpropertydescriptors
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var ownKeys = __webpack_require__(/*! ./_own-keys */ "./node_modules/core-js/modules/_own-keys.js");
var toIObject = __webpack_require__(/*! ./_to-iobject */ "./node_modules/core-js/modules/_to-iobject.js");
var gOPD = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js");
var createProperty = __webpack_require__(/*! ./_create-property */ "./node_modules/core-js/modules/_create-property.js");

$export($export.S, 'Object', {
  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
    var O = toIObject(object);
    var getDesc = gOPD.f;
    var keys = ownKeys(O);
    var result = {};
    var i = 0;
    var key, desc;
    while (keys.length > i) {
      desc = getDesc(O, key = keys[i++]);
      if (desc !== undefined) createProperty(result, key, desc);
    }
    return result;
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.lookup-getter.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.lookup-getter.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f;

// B.2.2.4 Object.prototype.__lookupGetter__(P)
__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
  __lookupGetter__: function __lookupGetter__(P) {
    var O = toObject(this);
    var K = toPrimitive(P, true);
    var D;
    do {
      if (D = getOwnPropertyDescriptor(O, K)) return D.get;
    } while (O = getPrototypeOf(O));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.lookup-setter.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.lookup-setter.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var toObject = __webpack_require__(/*! ./_to-object */ "./node_modules/core-js/modules/_to-object.js");
var toPrimitive = __webpack_require__(/*! ./_to-primitive */ "./node_modules/core-js/modules/_to-primitive.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var getOwnPropertyDescriptor = __webpack_require__(/*! ./_object-gopd */ "./node_modules/core-js/modules/_object-gopd.js").f;

// B.2.2.5 Object.prototype.__lookupSetter__(P)
__webpack_require__(/*! ./_descriptors */ "./node_modules/core-js/modules/_descriptors.js") && $export($export.P + __webpack_require__(/*! ./_object-forced-pam */ "./node_modules/core-js/modules/_object-forced-pam.js"), 'Object', {
  __lookupSetter__: function __lookupSetter__(P) {
    var O = toObject(this);
    var K = toPrimitive(P, true);
    var D;
    do {
      if (D = getOwnPropertyDescriptor(O, K)) return D.set;
    } while (O = getPrototypeOf(O));
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.object.values.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.object.values.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-object-values-entries
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $values = __webpack_require__(/*! ./_object-to-array */ "./node_modules/core-js/modules/_object-to-array.js")(false);

$export($export.S, 'Object', {
  values: function values(it) {
    return $values(it);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.observable.js":
/*!********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.observable.js ***!
  \********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/zenparsing/es-observable
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var microtask = __webpack_require__(/*! ./_microtask */ "./node_modules/core-js/modules/_microtask.js")();
var OBSERVABLE = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js")('observable');
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var anInstance = __webpack_require__(/*! ./_an-instance */ "./node_modules/core-js/modules/_an-instance.js");
var redefineAll = __webpack_require__(/*! ./_redefine-all */ "./node_modules/core-js/modules/_redefine-all.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var forOf = __webpack_require__(/*! ./_for-of */ "./node_modules/core-js/modules/_for-of.js");
var RETURN = forOf.RETURN;

var getMethod = function (fn) {
  return fn == null ? undefined : aFunction(fn);
};

var cleanupSubscription = function (subscription) {
  var cleanup = subscription._c;
  if (cleanup) {
    subscription._c = undefined;
    cleanup();
  }
};

var subscriptionClosed = function (subscription) {
  return subscription._o === undefined;
};

var closeSubscription = function (subscription) {
  if (!subscriptionClosed(subscription)) {
    subscription._o = undefined;
    cleanupSubscription(subscription);
  }
};

var Subscription = function (observer, subscriber) {
  anObject(observer);
  this._c = undefined;
  this._o = observer;
  observer = new SubscriptionObserver(this);
  try {
    var cleanup = subscriber(observer);
    var subscription = cleanup;
    if (cleanup != null) {
      if (typeof cleanup.unsubscribe === 'function') cleanup = function () { subscription.unsubscribe(); };
      else aFunction(cleanup);
      this._c = cleanup;
    }
  } catch (e) {
    observer.error(e);
    return;
  } if (subscriptionClosed(this)) cleanupSubscription(this);
};

Subscription.prototype = redefineAll({}, {
  unsubscribe: function unsubscribe() { closeSubscription(this); }
});

var SubscriptionObserver = function (subscription) {
  this._s = subscription;
};

SubscriptionObserver.prototype = redefineAll({}, {
  next: function next(value) {
    var subscription = this._s;
    if (!subscriptionClosed(subscription)) {
      var observer = subscription._o;
      try {
        var m = getMethod(observer.next);
        if (m) return m.call(observer, value);
      } catch (e) {
        try {
          closeSubscription(subscription);
        } finally {
          throw e;
        }
      }
    }
  },
  error: function error(value) {
    var subscription = this._s;
    if (subscriptionClosed(subscription)) throw value;
    var observer = subscription._o;
    subscription._o = undefined;
    try {
      var m = getMethod(observer.error);
      if (!m) throw value;
      value = m.call(observer, value);
    } catch (e) {
      try {
        cleanupSubscription(subscription);
      } finally {
        throw e;
      }
    } cleanupSubscription(subscription);
    return value;
  },
  complete: function complete(value) {
    var subscription = this._s;
    if (!subscriptionClosed(subscription)) {
      var observer = subscription._o;
      subscription._o = undefined;
      try {
        var m = getMethod(observer.complete);
        value = m ? m.call(observer, value) : undefined;
      } catch (e) {
        try {
          cleanupSubscription(subscription);
        } finally {
          throw e;
        }
      } cleanupSubscription(subscription);
      return value;
    }
  }
});

var $Observable = function Observable(subscriber) {
  anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber);
};

redefineAll($Observable.prototype, {
  subscribe: function subscribe(observer) {
    return new Subscription(observer, this._f);
  },
  forEach: function forEach(fn) {
    var that = this;
    return new (core.Promise || global.Promise)(function (resolve, reject) {
      aFunction(fn);
      var subscription = that.subscribe({
        next: function (value) {
          try {
            return fn(value);
          } catch (e) {
            reject(e);
            subscription.unsubscribe();
          }
        },
        error: reject,
        complete: resolve
      });
    });
  }
});

redefineAll($Observable, {
  from: function from(x) {
    var C = typeof this === 'function' ? this : $Observable;
    var method = getMethod(anObject(x)[OBSERVABLE]);
    if (method) {
      var observable = anObject(method.call(x));
      return observable.constructor === C ? observable : new C(function (observer) {
        return observable.subscribe(observer);
      });
    }
    return new C(function (observer) {
      var done = false;
      microtask(function () {
        if (!done) {
          try {
            if (forOf(x, false, function (it) {
              observer.next(it);
              if (done) return RETURN;
            }) === RETURN) return;
          } catch (e) {
            if (done) throw e;
            observer.error(e);
            return;
          } observer.complete();
        }
      });
      return function () { done = true; };
    });
  },
  of: function of() {
    for (var i = 0, l = arguments.length, items = new Array(l); i < l;) items[i] = arguments[i++];
    return new (typeof this === 'function' ? this : $Observable)(function (observer) {
      var done = false;
      microtask(function () {
        if (!done) {
          for (var j = 0; j < items.length; ++j) {
            observer.next(items[j]);
            if (done) return;
          } observer.complete();
        }
      });
      return function () { done = true; };
    });
  }
});

hide($Observable.prototype, OBSERVABLE, function () { return this; });

$export($export.G, { Observable: $Observable });

__webpack_require__(/*! ./_set-species */ "./node_modules/core-js/modules/_set-species.js")('Observable');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.promise.finally.js":
/*!*************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.promise.finally.js ***!
  \*************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";
// https://github.com/tc39/proposal-promise-finally

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var core = __webpack_require__(/*! ./_core */ "./node_modules/core-js/modules/_core.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var speciesConstructor = __webpack_require__(/*! ./_species-constructor */ "./node_modules/core-js/modules/_species-constructor.js");
var promiseResolve = __webpack_require__(/*! ./_promise-resolve */ "./node_modules/core-js/modules/_promise-resolve.js");

$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {
  var C = speciesConstructor(this, core.Promise || global.Promise);
  var isFunction = typeof onFinally == 'function';
  return this.then(
    isFunction ? function (x) {
      return promiseResolve(C, onFinally()).then(function () { return x; });
    } : onFinally,
    isFunction ? function (e) {
      return promiseResolve(C, onFinally()).then(function () { throw e; });
    } : onFinally
  );
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.promise.try.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.promise.try.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/proposal-promise-try
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var newPromiseCapability = __webpack_require__(/*! ./_new-promise-capability */ "./node_modules/core-js/modules/_new-promise-capability.js");
var perform = __webpack_require__(/*! ./_perform */ "./node_modules/core-js/modules/_perform.js");

$export($export.S, 'Promise', { 'try': function (callbackfn) {
  var promiseCapability = newPromiseCapability.f(this);
  var result = perform(callbackfn);
  (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
  return promiseCapability.promise;
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.define-metadata.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.define-metadata.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toMetaKey = metadata.key;
var ordinaryDefineOwnMetadata = metadata.set;

metadata.exp({ defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey) {
  ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.delete-metadata.js":
/*!*********************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.delete-metadata.js ***!
  \*********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var toMetaKey = metadata.key;
var getOrCreateMetadataMap = metadata.map;
var store = metadata.store;

metadata.exp({ deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) {
  var targetKey = arguments.length < 3 ? undefined : toMetaKey(arguments[2]);
  var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);
  if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false;
  if (metadataMap.size) return true;
  var targetMetadata = store.get(target);
  targetMetadata['delete'](targetKey);
  return !!targetMetadata.size || store['delete'](target);
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.get-metadata-keys.js":
/*!***********************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.get-metadata-keys.js ***!
  \***********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var Set = __webpack_require__(/*! ./es6.set */ "./node_modules/core-js/modules/es6.set.js");
var from = __webpack_require__(/*! ./_array-from-iterable */ "./node_modules/core-js/modules/_array-from-iterable.js");
var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var ordinaryOwnMetadataKeys = metadata.keys;
var toMetaKey = metadata.key;

var ordinaryMetadataKeys = function (O, P) {
  var oKeys = ordinaryOwnMetadataKeys(O, P);
  var parent = getPrototypeOf(O);
  if (parent === null) return oKeys;
  var pKeys = ordinaryMetadataKeys(parent, P);
  return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;
};

metadata.exp({ getMetadataKeys: function getMetadataKeys(target /* , targetKey */) {
  return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.get-metadata.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.get-metadata.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var ordinaryHasOwnMetadata = metadata.has;
var ordinaryGetOwnMetadata = metadata.get;
var toMetaKey = metadata.key;

var ordinaryGetMetadata = function (MetadataKey, O, P) {
  var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
  if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P);
  var parent = getPrototypeOf(O);
  return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;
};

metadata.exp({ getMetadata: function getMetadata(metadataKey, target /* , targetKey */) {
  return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js":
/*!***************************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js ***!
  \***************************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var ordinaryOwnMetadataKeys = metadata.keys;
var toMetaKey = metadata.key;

metadata.exp({ getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) {
  return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.get-own-metadata.js":
/*!**********************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.get-own-metadata.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var ordinaryGetOwnMetadata = metadata.get;
var toMetaKey = metadata.key;

metadata.exp({ getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) {
  return ordinaryGetOwnMetadata(metadataKey, anObject(target)
    , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.has-metadata.js":
/*!******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.has-metadata.js ***!
  \******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var getPrototypeOf = __webpack_require__(/*! ./_object-gpo */ "./node_modules/core-js/modules/_object-gpo.js");
var ordinaryHasOwnMetadata = metadata.has;
var toMetaKey = metadata.key;

var ordinaryHasMetadata = function (MetadataKey, O, P) {
  var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);
  if (hasOwn) return true;
  var parent = getPrototypeOf(O);
  return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;
};

metadata.exp({ hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) {
  return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.has-own-metadata.js":
/*!**********************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.has-own-metadata.js ***!
  \**********************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var ordinaryHasOwnMetadata = metadata.has;
var toMetaKey = metadata.key;

metadata.exp({ hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) {
  return ordinaryHasOwnMetadata(metadataKey, anObject(target)
    , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.reflect.metadata.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.reflect.metadata.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $metadata = __webpack_require__(/*! ./_metadata */ "./node_modules/core-js/modules/_metadata.js");
var anObject = __webpack_require__(/*! ./_an-object */ "./node_modules/core-js/modules/_an-object.js");
var aFunction = __webpack_require__(/*! ./_a-function */ "./node_modules/core-js/modules/_a-function.js");
var toMetaKey = $metadata.key;
var ordinaryDefineOwnMetadata = $metadata.set;

$metadata.exp({ metadata: function metadata(metadataKey, metadataValue) {
  return function decorator(target, targetKey) {
    ordinaryDefineOwnMetadata(
      metadataKey, metadataValue,
      (targetKey !== undefined ? anObject : aFunction)(target),
      toMetaKey(targetKey)
    );
  };
} });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.set.from.js":
/*!******************************************************!*\
  !*** ./node_modules/core-js/modules/es7.set.from.js ***!
  \******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from
__webpack_require__(/*! ./_set-collection-from */ "./node_modules/core-js/modules/_set-collection-from.js")('Set');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.set.of.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/es7.set.of.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of
__webpack_require__(/*! ./_set-collection-of */ "./node_modules/core-js/modules/_set-collection-of.js")('Set');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.set.to-json.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.set.to-json.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/DavidBruant/Map-Set.prototype.toJSON
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.P + $export.R, 'Set', { toJSON: __webpack_require__(/*! ./_collection-to-json */ "./node_modules/core-js/modules/_collection-to-json.js")('Set') });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.at.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.at.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/mathiasbynens/String.prototype.at
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $at = __webpack_require__(/*! ./_string-at */ "./node_modules/core-js/modules/_string-at.js")(true);

$export($export.P, 'String', {
  at: function at(pos) {
    return $at(this, pos);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.match-all.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.match-all.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://tc39.github.io/String.prototype.matchAll/
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var defined = __webpack_require__(/*! ./_defined */ "./node_modules/core-js/modules/_defined.js");
var toLength = __webpack_require__(/*! ./_to-length */ "./node_modules/core-js/modules/_to-length.js");
var isRegExp = __webpack_require__(/*! ./_is-regexp */ "./node_modules/core-js/modules/_is-regexp.js");
var getFlags = __webpack_require__(/*! ./_flags */ "./node_modules/core-js/modules/_flags.js");
var RegExpProto = RegExp.prototype;

var $RegExpStringIterator = function (regexp, string) {
  this._r = regexp;
  this._s = string;
};

__webpack_require__(/*! ./_iter-create */ "./node_modules/core-js/modules/_iter-create.js")($RegExpStringIterator, 'RegExp String', function next() {
  var match = this._r.exec(this._s);
  return { value: match, done: match === null };
});

$export($export.P, 'String', {
  matchAll: function matchAll(regexp) {
    defined(this);
    if (!isRegExp(regexp)) throw TypeError(regexp + ' is not a regexp!');
    var S = String(this);
    var flags = 'flags' in RegExpProto ? String(regexp.flags) : getFlags.call(regexp);
    var rx = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags);
    rx.lastIndex = toLength(regexp.lastIndex);
    return new $RegExpStringIterator(rx, S);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.pad-end.js":
/*!************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.pad-end.js ***!
  \************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/proposal-string-pad-start-end
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $pad = __webpack_require__(/*! ./_string-pad */ "./node_modules/core-js/modules/_string-pad.js");
var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/core-js/modules/_user-agent.js");

// https://github.com/zloirock/core-js/issues/280
$export($export.P + $export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(userAgent), 'String', {
  padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.pad-start.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.pad-start.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/tc39/proposal-string-pad-start-end
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $pad = __webpack_require__(/*! ./_string-pad */ "./node_modules/core-js/modules/_string-pad.js");
var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/core-js/modules/_user-agent.js");

// https://github.com/zloirock/core-js/issues/280
$export($export.P + $export.F * /Version\/10\.\d+(\.\d+)? Safari\//.test(userAgent), 'String', {
  padStart: function padStart(maxLength /* , fillString = ' ' */) {
    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
  }
});


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.trim-left.js":
/*!**************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.trim-left.js ***!
  \**************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
__webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js")('trimLeft', function ($trim) {
  return function trimLeft() {
    return $trim(this, 1);
  };
}, 'trimStart');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.string.trim-right.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.string.trim-right.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";

// https://github.com/sebmarkbage/ecmascript-string-left-right-trim
__webpack_require__(/*! ./_string-trim */ "./node_modules/core-js/modules/_string-trim.js")('trimRight', function ($trim) {
  return function trimRight() {
    return $trim(this, 2);
  };
}, 'trimEnd');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.symbol.async-iterator.js":
/*!*******************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.symbol.async-iterator.js ***!
  \*******************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_wks-define */ "./node_modules/core-js/modules/_wks-define.js")('asyncIterator');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.symbol.observable.js":
/*!***************************************************************!*\
  !*** ./node_modules/core-js/modules/es7.symbol.observable.js ***!
  \***************************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./_wks-define */ "./node_modules/core-js/modules/_wks-define.js")('observable');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.system.global.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.system.global.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://github.com/tc39/proposal-global
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");

$export($export.S, 'System', { global: __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js") });


/***/ }),

/***/ "./node_modules/core-js/modules/es7.weak-map.from.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.weak-map.from.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from
__webpack_require__(/*! ./_set-collection-from */ "./node_modules/core-js/modules/_set-collection-from.js")('WeakMap');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.weak-map.of.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.weak-map.of.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of
__webpack_require__(/*! ./_set-collection-of */ "./node_modules/core-js/modules/_set-collection-of.js")('WeakMap');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.weak-set.from.js":
/*!***********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.weak-set.from.js ***!
  \***********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from
__webpack_require__(/*! ./_set-collection-from */ "./node_modules/core-js/modules/_set-collection-from.js")('WeakSet');


/***/ }),

/***/ "./node_modules/core-js/modules/es7.weak-set.of.js":
/*!*********************************************************!*\
  !*** ./node_modules/core-js/modules/es7.weak-set.of.js ***!
  \*********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of
__webpack_require__(/*! ./_set-collection-of */ "./node_modules/core-js/modules/_set-collection-of.js")('WeakSet');


/***/ }),

/***/ "./node_modules/core-js/modules/web.dom.iterable.js":
/*!**********************************************************!*\
  !*** ./node_modules/core-js/modules/web.dom.iterable.js ***!
  \**********************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $iterators = __webpack_require__(/*! ./es6.array.iterator */ "./node_modules/core-js/modules/es6.array.iterator.js");
var getKeys = __webpack_require__(/*! ./_object-keys */ "./node_modules/core-js/modules/_object-keys.js");
var redefine = __webpack_require__(/*! ./_redefine */ "./node_modules/core-js/modules/_redefine.js");
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var hide = __webpack_require__(/*! ./_hide */ "./node_modules/core-js/modules/_hide.js");
var Iterators = __webpack_require__(/*! ./_iterators */ "./node_modules/core-js/modules/_iterators.js");
var wks = __webpack_require__(/*! ./_wks */ "./node_modules/core-js/modules/_wks.js");
var ITERATOR = wks('iterator');
var TO_STRING_TAG = wks('toStringTag');
var ArrayValues = Iterators.Array;

var DOMIterables = {
  CSSRuleList: true, // TODO: Not spec compliant, should be false.
  CSSStyleDeclaration: false,
  CSSValueList: false,
  ClientRectList: false,
  DOMRectList: false,
  DOMStringList: false,
  DOMTokenList: true,
  DataTransferItemList: false,
  FileList: false,
  HTMLAllCollection: false,
  HTMLCollection: false,
  HTMLFormElement: false,
  HTMLSelectElement: false,
  MediaList: true, // TODO: Not spec compliant, should be false.
  MimeTypeArray: false,
  NamedNodeMap: false,
  NodeList: true,
  PaintRequestList: false,
  Plugin: false,
  PluginArray: false,
  SVGLengthList: false,
  SVGNumberList: false,
  SVGPathSegList: false,
  SVGPointList: false,
  SVGStringList: false,
  SVGTransformList: false,
  SourceBufferList: false,
  StyleSheetList: true, // TODO: Not spec compliant, should be false.
  TextTrackCueList: false,
  TextTrackList: false,
  TouchList: false
};

for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {
  var NAME = collections[i];
  var explicit = DOMIterables[NAME];
  var Collection = global[NAME];
  var proto = Collection && Collection.prototype;
  var key;
  if (proto) {
    if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
    if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
    Iterators[NAME] = ArrayValues;
    if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true);
  }
}


/***/ }),

/***/ "./node_modules/core-js/modules/web.immediate.js":
/*!*******************************************************!*\
  !*** ./node_modules/core-js/modules/web.immediate.js ***!
  \*******************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var $task = __webpack_require__(/*! ./_task */ "./node_modules/core-js/modules/_task.js");
$export($export.G + $export.B, {
  setImmediate: $task.set,
  clearImmediate: $task.clear
});


/***/ }),

/***/ "./node_modules/core-js/modules/web.timers.js":
/*!****************************************************!*\
  !*** ./node_modules/core-js/modules/web.timers.js ***!
  \****************************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

// ie9- setTimeout & setInterval additional parameters fix
var global = __webpack_require__(/*! ./_global */ "./node_modules/core-js/modules/_global.js");
var $export = __webpack_require__(/*! ./_export */ "./node_modules/core-js/modules/_export.js");
var userAgent = __webpack_require__(/*! ./_user-agent */ "./node_modules/core-js/modules/_user-agent.js");
var slice = [].slice;
var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check
var wrap = function (set) {
  return function (fn, time /* , ...args */) {
    var boundArgs = arguments.length > 2;
    var args = boundArgs ? slice.call(arguments, 2) : false;
    return set(boundArgs ? function () {
      // eslint-disable-next-line no-new-func
      (typeof fn == 'function' ? fn : Function(fn)).apply(this, args);
    } : fn, time);
  };
};
$export($export.G + $export.B + $export.F * MSIE, {
  setTimeout: wrap(global.setTimeout),
  setInterval: wrap(global.setInterval)
});


/***/ }),

/***/ "./node_modules/core-js/shim.js":
/*!**************************************!*\
  !*** ./node_modules/core-js/shim.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! ./modules/es6.symbol */ "./node_modules/core-js/modules/es6.symbol.js");
__webpack_require__(/*! ./modules/es6.object.create */ "./node_modules/core-js/modules/es6.object.create.js");
__webpack_require__(/*! ./modules/es6.object.define-property */ "./node_modules/core-js/modules/es6.object.define-property.js");
__webpack_require__(/*! ./modules/es6.object.define-properties */ "./node_modules/core-js/modules/es6.object.define-properties.js");
__webpack_require__(/*! ./modules/es6.object.get-own-property-descriptor */ "./node_modules/core-js/modules/es6.object.get-own-property-descriptor.js");
__webpack_require__(/*! ./modules/es6.object.get-prototype-of */ "./node_modules/core-js/modules/es6.object.get-prototype-of.js");
__webpack_require__(/*! ./modules/es6.object.keys */ "./node_modules/core-js/modules/es6.object.keys.js");
__webpack_require__(/*! ./modules/es6.object.get-own-property-names */ "./node_modules/core-js/modules/es6.object.get-own-property-names.js");
__webpack_require__(/*! ./modules/es6.object.freeze */ "./node_modules/core-js/modules/es6.object.freeze.js");
__webpack_require__(/*! ./modules/es6.object.seal */ "./node_modules/core-js/modules/es6.object.seal.js");
__webpack_require__(/*! ./modules/es6.object.prevent-extensions */ "./node_modules/core-js/modules/es6.object.prevent-extensions.js");
__webpack_require__(/*! ./modules/es6.object.is-frozen */ "./node_modules/core-js/modules/es6.object.is-frozen.js");
__webpack_require__(/*! ./modules/es6.object.is-sealed */ "./node_modules/core-js/modules/es6.object.is-sealed.js");
__webpack_require__(/*! ./modules/es6.object.is-extensible */ "./node_modules/core-js/modules/es6.object.is-extensible.js");
__webpack_require__(/*! ./modules/es6.object.assign */ "./node_modules/core-js/modules/es6.object.assign.js");
__webpack_require__(/*! ./modules/es6.object.is */ "./node_modules/core-js/modules/es6.object.is.js");
__webpack_require__(/*! ./modules/es6.object.set-prototype-of */ "./node_modules/core-js/modules/es6.object.set-prototype-of.js");
__webpack_require__(/*! ./modules/es6.object.to-string */ "./node_modules/core-js/modules/es6.object.to-string.js");
__webpack_require__(/*! ./modules/es6.function.bind */ "./node_modules/core-js/modules/es6.function.bind.js");
__webpack_require__(/*! ./modules/es6.function.name */ "./node_modules/core-js/modules/es6.function.name.js");
__webpack_require__(/*! ./modules/es6.function.has-instance */ "./node_modules/core-js/modules/es6.function.has-instance.js");
__webpack_require__(/*! ./modules/es6.parse-int */ "./node_modules/core-js/modules/es6.parse-int.js");
__webpack_require__(/*! ./modules/es6.parse-float */ "./node_modules/core-js/modules/es6.parse-float.js");
__webpack_require__(/*! ./modules/es6.number.constructor */ "./node_modules/core-js/modules/es6.number.constructor.js");
__webpack_require__(/*! ./modules/es6.number.to-fixed */ "./node_modules/core-js/modules/es6.number.to-fixed.js");
__webpack_require__(/*! ./modules/es6.number.to-precision */ "./node_modules/core-js/modules/es6.number.to-precision.js");
__webpack_require__(/*! ./modules/es6.number.epsilon */ "./node_modules/core-js/modules/es6.number.epsilon.js");
__webpack_require__(/*! ./modules/es6.number.is-finite */ "./node_modules/core-js/modules/es6.number.is-finite.js");
__webpack_require__(/*! ./modules/es6.number.is-integer */ "./node_modules/core-js/modules/es6.number.is-integer.js");
__webpack_require__(/*! ./modules/es6.number.is-nan */ "./node_modules/core-js/modules/es6.number.is-nan.js");
__webpack_require__(/*! ./modules/es6.number.is-safe-integer */ "./node_modules/core-js/modules/es6.number.is-safe-integer.js");
__webpack_require__(/*! ./modules/es6.number.max-safe-integer */ "./node_modules/core-js/modules/es6.number.max-safe-integer.js");
__webpack_require__(/*! ./modules/es6.number.min-safe-integer */ "./node_modules/core-js/modules/es6.number.min-safe-integer.js");
__webpack_require__(/*! ./modules/es6.number.parse-float */ "./node_modules/core-js/modules/es6.number.parse-float.js");
__webpack_require__(/*! ./modules/es6.number.parse-int */ "./node_modules/core-js/modules/es6.number.parse-int.js");
__webpack_require__(/*! ./modules/es6.math.acosh */ "./node_modules/core-js/modules/es6.math.acosh.js");
__webpack_require__(/*! ./modules/es6.math.asinh */ "./node_modules/core-js/modules/es6.math.asinh.js");
__webpack_require__(/*! ./modules/es6.math.atanh */ "./node_modules/core-js/modules/es6.math.atanh.js");
__webpack_require__(/*! ./modules/es6.math.cbrt */ "./node_modules/core-js/modules/es6.math.cbrt.js");
__webpack_require__(/*! ./modules/es6.math.clz32 */ "./node_modules/core-js/modules/es6.math.clz32.js");
__webpack_require__(/*! ./modules/es6.math.cosh */ "./node_modules/core-js/modules/es6.math.cosh.js");
__webpack_require__(/*! ./modules/es6.math.expm1 */ "./node_modules/core-js/modules/es6.math.expm1.js");
__webpack_require__(/*! ./modules/es6.math.fround */ "./node_modules/core-js/modules/es6.math.fround.js");
__webpack_require__(/*! ./modules/es6.math.hypot */ "./node_modules/core-js/modules/es6.math.hypot.js");
__webpack_require__(/*! ./modules/es6.math.imul */ "./node_modules/core-js/modules/es6.math.imul.js");
__webpack_require__(/*! ./modules/es6.math.log10 */ "./node_modules/core-js/modules/es6.math.log10.js");
__webpack_require__(/*! ./modules/es6.math.log1p */ "./node_modules/core-js/modules/es6.math.log1p.js");
__webpack_require__(/*! ./modules/es6.math.log2 */ "./node_modules/core-js/modules/es6.math.log2.js");
__webpack_require__(/*! ./modules/es6.math.sign */ "./node_modules/core-js/modules/es6.math.sign.js");
__webpack_require__(/*! ./modules/es6.math.sinh */ "./node_modules/core-js/modules/es6.math.sinh.js");
__webpack_require__(/*! ./modules/es6.math.tanh */ "./node_modules/core-js/modules/es6.math.tanh.js");
__webpack_require__(/*! ./modules/es6.math.trunc */ "./node_modules/core-js/modules/es6.math.trunc.js");
__webpack_require__(/*! ./modules/es6.string.from-code-point */ "./node_modules/core-js/modules/es6.string.from-code-point.js");
__webpack_require__(/*! ./modules/es6.string.raw */ "./node_modules/core-js/modules/es6.string.raw.js");
__webpack_require__(/*! ./modules/es6.string.trim */ "./node_modules/core-js/modules/es6.string.trim.js");
__webpack_require__(/*! ./modules/es6.string.iterator */ "./node_modules/core-js/modules/es6.string.iterator.js");
__webpack_require__(/*! ./modules/es6.string.code-point-at */ "./node_modules/core-js/modules/es6.string.code-point-at.js");
__webpack_require__(/*! ./modules/es6.string.ends-with */ "./node_modules/core-js/modules/es6.string.ends-with.js");
__webpack_require__(/*! ./modules/es6.string.includes */ "./node_modules/core-js/modules/es6.string.includes.js");
__webpack_require__(/*! ./modules/es6.string.repeat */ "./node_modules/core-js/modules/es6.string.repeat.js");
__webpack_require__(/*! ./modules/es6.string.starts-with */ "./node_modules/core-js/modules/es6.string.starts-with.js");
__webpack_require__(/*! ./modules/es6.string.anchor */ "./node_modules/core-js/modules/es6.string.anchor.js");
__webpack_require__(/*! ./modules/es6.string.big */ "./node_modules/core-js/modules/es6.string.big.js");
__webpack_require__(/*! ./modules/es6.string.blink */ "./node_modules/core-js/modules/es6.string.blink.js");
__webpack_require__(/*! ./modules/es6.string.bold */ "./node_modules/core-js/modules/es6.string.bold.js");
__webpack_require__(/*! ./modules/es6.string.fixed */ "./node_modules/core-js/modules/es6.string.fixed.js");
__webpack_require__(/*! ./modules/es6.string.fontcolor */ "./node_modules/core-js/modules/es6.string.fontcolor.js");
__webpack_require__(/*! ./modules/es6.string.fontsize */ "./node_modules/core-js/modules/es6.string.fontsize.js");
__webpack_require__(/*! ./modules/es6.string.italics */ "./node_modules/core-js/modules/es6.string.italics.js");
__webpack_require__(/*! ./modules/es6.string.link */ "./node_modules/core-js/modules/es6.string.link.js");
__webpack_require__(/*! ./modules/es6.string.small */ "./node_modules/core-js/modules/es6.string.small.js");
__webpack_require__(/*! ./modules/es6.string.strike */ "./node_modules/core-js/modules/es6.string.strike.js");
__webpack_require__(/*! ./modules/es6.string.sub */ "./node_modules/core-js/modules/es6.string.sub.js");
__webpack_require__(/*! ./modules/es6.string.sup */ "./node_modules/core-js/modules/es6.string.sup.js");
__webpack_require__(/*! ./modules/es6.date.now */ "./node_modules/core-js/modules/es6.date.now.js");
__webpack_require__(/*! ./modules/es6.date.to-json */ "./node_modules/core-js/modules/es6.date.to-json.js");
__webpack_require__(/*! ./modules/es6.date.to-iso-string */ "./node_modules/core-js/modules/es6.date.to-iso-string.js");
__webpack_require__(/*! ./modules/es6.date.to-string */ "./node_modules/core-js/modules/es6.date.to-string.js");
__webpack_require__(/*! ./modules/es6.date.to-primitive */ "./node_modules/core-js/modules/es6.date.to-primitive.js");
__webpack_require__(/*! ./modules/es6.array.is-array */ "./node_modules/core-js/modules/es6.array.is-array.js");
__webpack_require__(/*! ./modules/es6.array.from */ "./node_modules/core-js/modules/es6.array.from.js");
__webpack_require__(/*! ./modules/es6.array.of */ "./node_modules/core-js/modules/es6.array.of.js");
__webpack_require__(/*! ./modules/es6.array.join */ "./node_modules/core-js/modules/es6.array.join.js");
__webpack_require__(/*! ./modules/es6.array.slice */ "./node_modules/core-js/modules/es6.array.slice.js");
__webpack_require__(/*! ./modules/es6.array.sort */ "./node_modules/core-js/modules/es6.array.sort.js");
__webpack_require__(/*! ./modules/es6.array.for-each */ "./node_modules/core-js/modules/es6.array.for-each.js");
__webpack_require__(/*! ./modules/es6.array.map */ "./node_modules/core-js/modules/es6.array.map.js");
__webpack_require__(/*! ./modules/es6.array.filter */ "./node_modules/core-js/modules/es6.array.filter.js");
__webpack_require__(/*! ./modules/es6.array.some */ "./node_modules/core-js/modules/es6.array.some.js");
__webpack_require__(/*! ./modules/es6.array.every */ "./node_modules/core-js/modules/es6.array.every.js");
__webpack_require__(/*! ./modules/es6.array.reduce */ "./node_modules/core-js/modules/es6.array.reduce.js");
__webpack_require__(/*! ./modules/es6.array.reduce-right */ "./node_modules/core-js/modules/es6.array.reduce-right.js");
__webpack_require__(/*! ./modules/es6.array.index-of */ "./node_modules/core-js/modules/es6.array.index-of.js");
__webpack_require__(/*! ./modules/es6.array.last-index-of */ "./node_modules/core-js/modules/es6.array.last-index-of.js");
__webpack_require__(/*! ./modules/es6.array.copy-within */ "./node_modules/core-js/modules/es6.array.copy-within.js");
__webpack_require__(/*! ./modules/es6.array.fill */ "./node_modules/core-js/modules/es6.array.fill.js");
__webpack_require__(/*! ./modules/es6.array.find */ "./node_modules/core-js/modules/es6.array.find.js");
__webpack_require__(/*! ./modules/es6.array.find-index */ "./node_modules/core-js/modules/es6.array.find-index.js");
__webpack_require__(/*! ./modules/es6.array.species */ "./node_modules/core-js/modules/es6.array.species.js");
__webpack_require__(/*! ./modules/es6.array.iterator */ "./node_modules/core-js/modules/es6.array.iterator.js");
__webpack_require__(/*! ./modules/es6.regexp.constructor */ "./node_modules/core-js/modules/es6.regexp.constructor.js");
__webpack_require__(/*! ./modules/es6.regexp.exec */ "./node_modules/core-js/modules/es6.regexp.exec.js");
__webpack_require__(/*! ./modules/es6.regexp.to-string */ "./node_modules/core-js/modules/es6.regexp.to-string.js");
__webpack_require__(/*! ./modules/es6.regexp.flags */ "./node_modules/core-js/modules/es6.regexp.flags.js");
__webpack_require__(/*! ./modules/es6.regexp.match */ "./node_modules/core-js/modules/es6.regexp.match.js");
__webpack_require__(/*! ./modules/es6.regexp.replace */ "./node_modules/core-js/modules/es6.regexp.replace.js");
__webpack_require__(/*! ./modules/es6.regexp.search */ "./node_modules/core-js/modules/es6.regexp.search.js");
__webpack_require__(/*! ./modules/es6.regexp.split */ "./node_modules/core-js/modules/es6.regexp.split.js");
__webpack_require__(/*! ./modules/es6.promise */ "./node_modules/core-js/modules/es6.promise.js");
__webpack_require__(/*! ./modules/es6.map */ "./node_modules/core-js/modules/es6.map.js");
__webpack_require__(/*! ./modules/es6.set */ "./node_modules/core-js/modules/es6.set.js");
__webpack_require__(/*! ./modules/es6.weak-map */ "./node_modules/core-js/modules/es6.weak-map.js");
__webpack_require__(/*! ./modules/es6.weak-set */ "./node_modules/core-js/modules/es6.weak-set.js");
__webpack_require__(/*! ./modules/es6.typed.array-buffer */ "./node_modules/core-js/modules/es6.typed.array-buffer.js");
__webpack_require__(/*! ./modules/es6.typed.data-view */ "./node_modules/core-js/modules/es6.typed.data-view.js");
__webpack_require__(/*! ./modules/es6.typed.int8-array */ "./node_modules/core-js/modules/es6.typed.int8-array.js");
__webpack_require__(/*! ./modules/es6.typed.uint8-array */ "./node_modules/core-js/modules/es6.typed.uint8-array.js");
__webpack_require__(/*! ./modules/es6.typed.uint8-clamped-array */ "./node_modules/core-js/modules/es6.typed.uint8-clamped-array.js");
__webpack_require__(/*! ./modules/es6.typed.int16-array */ "./node_modules/core-js/modules/es6.typed.int16-array.js");
__webpack_require__(/*! ./modules/es6.typed.uint16-array */ "./node_modules/core-js/modules/es6.typed.uint16-array.js");
__webpack_require__(/*! ./modules/es6.typed.int32-array */ "./node_modules/core-js/modules/es6.typed.int32-array.js");
__webpack_require__(/*! ./modules/es6.typed.uint32-array */ "./node_modules/core-js/modules/es6.typed.uint32-array.js");
__webpack_require__(/*! ./modules/es6.typed.float32-array */ "./node_modules/core-js/modules/es6.typed.float32-array.js");
__webpack_require__(/*! ./modules/es6.typed.float64-array */ "./node_modules/core-js/modules/es6.typed.float64-array.js");
__webpack_require__(/*! ./modules/es6.reflect.apply */ "./node_modules/core-js/modules/es6.reflect.apply.js");
__webpack_require__(/*! ./modules/es6.reflect.construct */ "./node_modules/core-js/modules/es6.reflect.construct.js");
__webpack_require__(/*! ./modules/es6.reflect.define-property */ "./node_modules/core-js/modules/es6.reflect.define-property.js");
__webpack_require__(/*! ./modules/es6.reflect.delete-property */ "./node_modules/core-js/modules/es6.reflect.delete-property.js");
__webpack_require__(/*! ./modules/es6.reflect.enumerate */ "./node_modules/core-js/modules/es6.reflect.enumerate.js");
__webpack_require__(/*! ./modules/es6.reflect.get */ "./node_modules/core-js/modules/es6.reflect.get.js");
__webpack_require__(/*! ./modules/es6.reflect.get-own-property-descriptor */ "./node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js");
__webpack_require__(/*! ./modules/es6.reflect.get-prototype-of */ "./node_modules/core-js/modules/es6.reflect.get-prototype-of.js");
__webpack_require__(/*! ./modules/es6.reflect.has */ "./node_modules/core-js/modules/es6.reflect.has.js");
__webpack_require__(/*! ./modules/es6.reflect.is-extensible */ "./node_modules/core-js/modules/es6.reflect.is-extensible.js");
__webpack_require__(/*! ./modules/es6.reflect.own-keys */ "./node_modules/core-js/modules/es6.reflect.own-keys.js");
__webpack_require__(/*! ./modules/es6.reflect.prevent-extensions */ "./node_modules/core-js/modules/es6.reflect.prevent-extensions.js");
__webpack_require__(/*! ./modules/es6.reflect.set */ "./node_modules/core-js/modules/es6.reflect.set.js");
__webpack_require__(/*! ./modules/es6.reflect.set-prototype-of */ "./node_modules/core-js/modules/es6.reflect.set-prototype-of.js");
__webpack_require__(/*! ./modules/es7.array.includes */ "./node_modules/core-js/modules/es7.array.includes.js");
__webpack_require__(/*! ./modules/es7.array.flat-map */ "./node_modules/core-js/modules/es7.array.flat-map.js");
__webpack_require__(/*! ./modules/es7.array.flatten */ "./node_modules/core-js/modules/es7.array.flatten.js");
__webpack_require__(/*! ./modules/es7.string.at */ "./node_modules/core-js/modules/es7.string.at.js");
__webpack_require__(/*! ./modules/es7.string.pad-start */ "./node_modules/core-js/modules/es7.string.pad-start.js");
__webpack_require__(/*! ./modules/es7.string.pad-end */ "./node_modules/core-js/modules/es7.string.pad-end.js");
__webpack_require__(/*! ./modules/es7.string.trim-left */ "./node_modules/core-js/modules/es7.string.trim-left.js");
__webpack_require__(/*! ./modules/es7.string.trim-right */ "./node_modules/core-js/modules/es7.string.trim-right.js");
__webpack_require__(/*! ./modules/es7.string.match-all */ "./node_modules/core-js/modules/es7.string.match-all.js");
__webpack_require__(/*! ./modules/es7.symbol.async-iterator */ "./node_modules/core-js/modules/es7.symbol.async-iterator.js");
__webpack_require__(/*! ./modules/es7.symbol.observable */ "./node_modules/core-js/modules/es7.symbol.observable.js");
__webpack_require__(/*! ./modules/es7.object.get-own-property-descriptors */ "./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js");
__webpack_require__(/*! ./modules/es7.object.values */ "./node_modules/core-js/modules/es7.object.values.js");
__webpack_require__(/*! ./modules/es7.object.entries */ "./node_modules/core-js/modules/es7.object.entries.js");
__webpack_require__(/*! ./modules/es7.object.define-getter */ "./node_modules/core-js/modules/es7.object.define-getter.js");
__webpack_require__(/*! ./modules/es7.object.define-setter */ "./node_modules/core-js/modules/es7.object.define-setter.js");
__webpack_require__(/*! ./modules/es7.object.lookup-getter */ "./node_modules/core-js/modules/es7.object.lookup-getter.js");
__webpack_require__(/*! ./modules/es7.object.lookup-setter */ "./node_modules/core-js/modules/es7.object.lookup-setter.js");
__webpack_require__(/*! ./modules/es7.map.to-json */ "./node_modules/core-js/modules/es7.map.to-json.js");
__webpack_require__(/*! ./modules/es7.set.to-json */ "./node_modules/core-js/modules/es7.set.to-json.js");
__webpack_require__(/*! ./modules/es7.map.of */ "./node_modules/core-js/modules/es7.map.of.js");
__webpack_require__(/*! ./modules/es7.set.of */ "./node_modules/core-js/modules/es7.set.of.js");
__webpack_require__(/*! ./modules/es7.weak-map.of */ "./node_modules/core-js/modules/es7.weak-map.of.js");
__webpack_require__(/*! ./modules/es7.weak-set.of */ "./node_modules/core-js/modules/es7.weak-set.of.js");
__webpack_require__(/*! ./modules/es7.map.from */ "./node_modules/core-js/modules/es7.map.from.js");
__webpack_require__(/*! ./modules/es7.set.from */ "./node_modules/core-js/modules/es7.set.from.js");
__webpack_require__(/*! ./modules/es7.weak-map.from */ "./node_modules/core-js/modules/es7.weak-map.from.js");
__webpack_require__(/*! ./modules/es7.weak-set.from */ "./node_modules/core-js/modules/es7.weak-set.from.js");
__webpack_require__(/*! ./modules/es7.global */ "./node_modules/core-js/modules/es7.global.js");
__webpack_require__(/*! ./modules/es7.system.global */ "./node_modules/core-js/modules/es7.system.global.js");
__webpack_require__(/*! ./modules/es7.error.is-error */ "./node_modules/core-js/modules/es7.error.is-error.js");
__webpack_require__(/*! ./modules/es7.math.clamp */ "./node_modules/core-js/modules/es7.math.clamp.js");
__webpack_require__(/*! ./modules/es7.math.deg-per-rad */ "./node_modules/core-js/modules/es7.math.deg-per-rad.js");
__webpack_require__(/*! ./modules/es7.math.degrees */ "./node_modules/core-js/modules/es7.math.degrees.js");
__webpack_require__(/*! ./modules/es7.math.fscale */ "./node_modules/core-js/modules/es7.math.fscale.js");
__webpack_require__(/*! ./modules/es7.math.iaddh */ "./node_modules/core-js/modules/es7.math.iaddh.js");
__webpack_require__(/*! ./modules/es7.math.isubh */ "./node_modules/core-js/modules/es7.math.isubh.js");
__webpack_require__(/*! ./modules/es7.math.imulh */ "./node_modules/core-js/modules/es7.math.imulh.js");
__webpack_require__(/*! ./modules/es7.math.rad-per-deg */ "./node_modules/core-js/modules/es7.math.rad-per-deg.js");
__webpack_require__(/*! ./modules/es7.math.radians */ "./node_modules/core-js/modules/es7.math.radians.js");
__webpack_require__(/*! ./modules/es7.math.scale */ "./node_modules/core-js/modules/es7.math.scale.js");
__webpack_require__(/*! ./modules/es7.math.umulh */ "./node_modules/core-js/modules/es7.math.umulh.js");
__webpack_require__(/*! ./modules/es7.math.signbit */ "./node_modules/core-js/modules/es7.math.signbit.js");
__webpack_require__(/*! ./modules/es7.promise.finally */ "./node_modules/core-js/modules/es7.promise.finally.js");
__webpack_require__(/*! ./modules/es7.promise.try */ "./node_modules/core-js/modules/es7.promise.try.js");
__webpack_require__(/*! ./modules/es7.reflect.define-metadata */ "./node_modules/core-js/modules/es7.reflect.define-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.delete-metadata */ "./node_modules/core-js/modules/es7.reflect.delete-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.get-metadata */ "./node_modules/core-js/modules/es7.reflect.get-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.get-metadata-keys */ "./node_modules/core-js/modules/es7.reflect.get-metadata-keys.js");
__webpack_require__(/*! ./modules/es7.reflect.get-own-metadata */ "./node_modules/core-js/modules/es7.reflect.get-own-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.get-own-metadata-keys */ "./node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js");
__webpack_require__(/*! ./modules/es7.reflect.has-metadata */ "./node_modules/core-js/modules/es7.reflect.has-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.has-own-metadata */ "./node_modules/core-js/modules/es7.reflect.has-own-metadata.js");
__webpack_require__(/*! ./modules/es7.reflect.metadata */ "./node_modules/core-js/modules/es7.reflect.metadata.js");
__webpack_require__(/*! ./modules/es7.asap */ "./node_modules/core-js/modules/es7.asap.js");
__webpack_require__(/*! ./modules/es7.observable */ "./node_modules/core-js/modules/es7.observable.js");
__webpack_require__(/*! ./modules/web.timers */ "./node_modules/core-js/modules/web.timers.js");
__webpack_require__(/*! ./modules/web.immediate */ "./node_modules/core-js/modules/web.immediate.js");
__webpack_require__(/*! ./modules/web.dom.iterable */ "./node_modules/core-js/modules/web.dom.iterable.js");
module.exports = __webpack_require__(/*! ./modules/_core */ "./node_modules/core-js/modules/_core.js");


/***/ }),

/***/ "./node_modules/ieee754/index.js":
/*!***************************************!*\
  !*** ./node_modules/ieee754/index.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports) {

exports.read = function (buffer, offset, isLE, mLen, nBytes) {
  var e, m
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var nBits = -7
  var i = isLE ? (nBytes - 1) : 0
  var d = isLE ? -1 : 1
  var s = buffer[offset + i]

  i += d

  e = s & ((1 << (-nBits)) - 1)
  s >>= (-nBits)
  nBits += eLen
  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  m = e & ((1 << (-nBits)) - 1)
  e >>= (-nBits)
  nBits += mLen
  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}

  if (e === 0) {
    e = 1 - eBias
  } else if (e === eMax) {
    return m ? NaN : ((s ? -1 : 1) * Infinity)
  } else {
    m = m + Math.pow(2, mLen)
    e = e - eBias
  }
  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
}

exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
  var e, m, c
  var eLen = (nBytes * 8) - mLen - 1
  var eMax = (1 << eLen) - 1
  var eBias = eMax >> 1
  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
  var i = isLE ? 0 : (nBytes - 1)
  var d = isLE ? 1 : -1
  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0

  value = Math.abs(value)

  if (isNaN(value) || value === Infinity) {
    m = isNaN(value) ? 1 : 0
    e = eMax
  } else {
    e = Math.floor(Math.log(value) / Math.LN2)
    if (value * (c = Math.pow(2, -e)) < 1) {
      e--
      c *= 2
    }
    if (e + eBias >= 1) {
      value += rt / c
    } else {
      value += rt * Math.pow(2, 1 - eBias)
    }
    if (value * c >= 2) {
      e++
      c /= 2
    }

    if (e + eBias >= eMax) {
      m = 0
      e = eMax
    } else if (e + eBias >= 1) {
      m = ((value * c) - 1) * Math.pow(2, mLen)
      e = e + eBias
    } else {
      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
      e = 0
    }
  }

  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}

  e = (e << mLen) | m
  eLen += mLen
  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}

  buffer[offset + i - d] |= s * 128
}


/***/ }),

/***/ "./node_modules/uuid/lib/bytesToUuid.js":
/*!**********************************************!*\
  !*** ./node_modules/uuid/lib/bytesToUuid.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

/**
 * Convert array of 16 byte values to UUID string format of the form:
 * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
 */
var byteToHex = [];
for (var i = 0; i < 256; ++i) {
  byteToHex[i] = (i + 0x100).toString(16).substr(1);
}

function bytesToUuid(buf, offset) {
  var i = offset || 0;
  var bth = byteToHex;
  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4
  return ([bth[buf[i++]], bth[buf[i++]], 
	bth[buf[i++]], bth[buf[i++]], '-',
	bth[buf[i++]], bth[buf[i++]], '-',
	bth[buf[i++]], bth[buf[i++]], '-',
	bth[buf[i++]], bth[buf[i++]], '-',
	bth[buf[i++]], bth[buf[i++]],
	bth[buf[i++]], bth[buf[i++]],
	bth[buf[i++]], bth[buf[i++]]]).join('');
}

module.exports = bytesToUuid;


/***/ }),

/***/ "./node_modules/uuid/lib/rng-browser.js":
/*!**********************************************!*\
  !*** ./node_modules/uuid/lib/rng-browser.js ***!
  \**********************************************/
/*! no static exports found */
/***/ (function(module, exports) {

// Unique ID creation requires a high quality random # generator.  In the
// browser this is a little complicated due to unknown quality of Math.random()
// and inconsistent support for the `crypto` API.  We do the best we can via
// feature-detection

// getRandomValues needs to be invoked in a context where "this" is a Crypto
// implementation. Also, find the complete implementation of crypto on IE11.
var getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||
                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));

if (getRandomValues) {
  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto
  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef

  module.exports = function whatwgRNG() {
    getRandomValues(rnds8);
    return rnds8;
  };
} else {
  // Math.random()-based (RNG)
  //
  // If all else fails, use Math.random().  It's fast, but is of unspecified
  // quality.
  var rnds = new Array(16);

  module.exports = function mathRNG() {
    for (var i = 0, r; i < 16; i++) {
      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;
      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;
    }

    return rnds;
  };
}


/***/ }),

/***/ "./node_modules/uuid/v4.js":
/*!*********************************!*\
  !*** ./node_modules/uuid/v4.js ***!
  \*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

var rng = __webpack_require__(/*! ./lib/rng */ "./node_modules/uuid/lib/rng-browser.js");
var bytesToUuid = __webpack_require__(/*! ./lib/bytesToUuid */ "./node_modules/uuid/lib/bytesToUuid.js");

function v4(options, buf, offset) {
  var i = buf && offset || 0;

  if (typeof(options) == 'string') {
    buf = options === 'binary' ? new Array(16) : null;
    options = null;
  }
  options = options || {};

  var rnds = options.random || (options.rng || rng)();

  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
  rnds[6] = (rnds[6] & 0x0f) | 0x40;
  rnds[8] = (rnds[8] & 0x3f) | 0x80;

  // Copy bytes to buffer, if provided
  if (buf) {
    for (var ii = 0; ii < 16; ++ii) {
      buf[i + ii] = rnds[ii];
    }
  }

  return buf || bytesToUuid(rnds);
}

module.exports = v4;


/***/ }),

/***/ "./node_modules/webpack/buildin/global.js":
/*!***********************************!*\
  !*** (webpack)/buildin/global.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports) {

var g;

// This works in non-strict mode
g = (function() {
	return this;
})();

try {
	// This works if eval is allowed (see CSP)
	g = g || new Function("return this")();
} catch (e) {
	// This works if the window reference is available
	if (typeof window === "object") g = window;
}

// g can still be undefined, but nothing to do about it...
// We return undefined, instead of nothing here, so it's
// easier to handle this case. if(!global) { ...}

module.exports = g;


/***/ }),

/***/ "./src/AccessTokenEvents.js":
/*!**********************************!*\
  !*** ./src/AccessTokenEvents.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.AccessTokenEvents = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _Timer = __webpack_require__(/*! ./Timer.js */ "./src/Timer.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var DefaultAccessTokenExpiringNotificationTime = 60; // seconds

var AccessTokenEvents = exports.AccessTokenEvents = function () {
    function AccessTokenEvents() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref$accessTokenExpir = _ref.accessTokenExpiringNotificationTime,
            accessTokenExpiringNotificationTime = _ref$accessTokenExpir === undefined ? DefaultAccessTokenExpiringNotificationTime : _ref$accessTokenExpir,
            _ref$accessTokenExpir2 = _ref.accessTokenExpiringTimer,
            accessTokenExpiringTimer = _ref$accessTokenExpir2 === undefined ? new _Timer.Timer("Access token expiring") : _ref$accessTokenExpir2,
            _ref$accessTokenExpir3 = _ref.accessTokenExpiredTimer,
            accessTokenExpiredTimer = _ref$accessTokenExpir3 === undefined ? new _Timer.Timer("Access token expired") : _ref$accessTokenExpir3;

        _classCallCheck(this, AccessTokenEvents);

        this._accessTokenExpiringNotificationTime = accessTokenExpiringNotificationTime;

        this._accessTokenExpiring = accessTokenExpiringTimer;
        this._accessTokenExpired = accessTokenExpiredTimer;
    }

    AccessTokenEvents.prototype.load = function load(container) {
        // only register events if there's an access token and it has an expiration
        if (container.access_token && container.expires_in !== undefined) {
            var duration = container.expires_in;
            _Log.Log.debug("AccessTokenEvents.load: access token present, remaining duration:", duration);

            if (duration > 0) {
                // only register expiring if we still have time
                var expiring = duration - this._accessTokenExpiringNotificationTime;
                if (expiring <= 0) {
                    expiring = 1;
                }

                _Log.Log.debug("AccessTokenEvents.load: registering expiring timer in:", expiring);
                this._accessTokenExpiring.init(expiring);
            } else {
                _Log.Log.debug("AccessTokenEvents.load: canceling existing expiring timer becase we're past expiration.");
                this._accessTokenExpiring.cancel();
            }

            // if it's negative, it will still fire
            var expired = duration + 1;
            _Log.Log.debug("AccessTokenEvents.load: registering expired timer in:", expired);
            this._accessTokenExpired.init(expired);
        } else {
            this._accessTokenExpiring.cancel();
            this._accessTokenExpired.cancel();
        }
    };

    AccessTokenEvents.prototype.unload = function unload() {
        _Log.Log.debug("AccessTokenEvents.unload: canceling existing access token timers");
        this._accessTokenExpiring.cancel();
        this._accessTokenExpired.cancel();
    };

    AccessTokenEvents.prototype.addAccessTokenExpiring = function addAccessTokenExpiring(cb) {
        this._accessTokenExpiring.addHandler(cb);
    };

    AccessTokenEvents.prototype.removeAccessTokenExpiring = function removeAccessTokenExpiring(cb) {
        this._accessTokenExpiring.removeHandler(cb);
    };

    AccessTokenEvents.prototype.addAccessTokenExpired = function addAccessTokenExpired(cb) {
        this._accessTokenExpired.addHandler(cb);
    };

    AccessTokenEvents.prototype.removeAccessTokenExpired = function removeAccessTokenExpired(cb) {
        this._accessTokenExpired.removeHandler(cb);
    };

    return AccessTokenEvents;
}();

/***/ }),

/***/ "./src/CheckSessionIFrame.js":
/*!***********************************!*\
  !*** ./src/CheckSessionIFrame.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.CheckSessionIFrame = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var DefaultInterval = 2000;

var CheckSessionIFrame = exports.CheckSessionIFrame = function () {
    function CheckSessionIFrame(callback, client_id, url, interval) {
        var stopOnError = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;

        _classCallCheck(this, CheckSessionIFrame);

        this._callback = callback;
        this._client_id = client_id;
        this._url = url;
        this._interval = interval || DefaultInterval;
        this._stopOnError = stopOnError;

        var idx = url.indexOf("/", url.indexOf("//") + 2);
        this._frame_origin = url.substr(0, idx);

        this._frame = window.document.createElement("iframe");

        // shotgun approach
        this._frame.style.visibility = "hidden";
        this._frame.style.position = "absolute";
        this._frame.style.display = "none";
        this._frame.style.width = 0;
        this._frame.style.height = 0;

        this._frame.src = url;
    }

    CheckSessionIFrame.prototype.load = function load() {
        var _this = this;

        return new Promise(function (resolve) {
            _this._frame.onload = function () {
                resolve();
            };

            window.document.body.appendChild(_this._frame);
            _this._boundMessageEvent = _this._message.bind(_this);
            window.addEventListener("message", _this._boundMessageEvent, false);
        });
    };

    CheckSessionIFrame.prototype._message = function _message(e) {
        if (e.origin === this._frame_origin && e.source === this._frame.contentWindow) {
            if (e.data === "error") {
                _Log.Log.error("CheckSessionIFrame: error message from check session op iframe");
                if (this._stopOnError) {
                    this.stop();
                }
            } else if (e.data === "changed") {
                _Log.Log.debug("CheckSessionIFrame: changed message from check session op iframe");
                this.stop();
                this._callback();
            } else {
                _Log.Log.debug("CheckSessionIFrame: " + e.data + " message from check session op iframe");
            }
        }
    };

    CheckSessionIFrame.prototype.start = function start(session_state) {
        var _this2 = this;

        if (this._session_state !== session_state) {
            _Log.Log.debug("CheckSessionIFrame.start");

            this.stop();

            this._session_state = session_state;

            var send = function send() {
                _this2._frame.contentWindow.postMessage(_this2._client_id + " " + _this2._session_state, _this2._frame_origin);
            };

            // trigger now
            send();

            // and setup timer
            this._timer = window.setInterval(send, this._interval);
        }
    };

    CheckSessionIFrame.prototype.stop = function stop() {
        this._session_state = null;

        if (this._timer) {
            _Log.Log.debug("CheckSessionIFrame.stop");

            window.clearInterval(this._timer);
            this._timer = null;
        }
    };

    return CheckSessionIFrame;
}();

/***/ }),

/***/ "./src/CordovaIFrameNavigator.js":
/*!***************************************!*\
  !*** ./src/CordovaIFrameNavigator.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.CordovaIFrameNavigator = undefined;

var _CordovaPopupWindow = __webpack_require__(/*! ./CordovaPopupWindow.js */ "./src/CordovaPopupWindow.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var CordovaIFrameNavigator = exports.CordovaIFrameNavigator = function () {
    function CordovaIFrameNavigator() {
        _classCallCheck(this, CordovaIFrameNavigator);
    }

    CordovaIFrameNavigator.prototype.prepare = function prepare(params) {
        params.popupWindowFeatures = 'hidden=yes';
        var popup = new _CordovaPopupWindow.CordovaPopupWindow(params);
        return Promise.resolve(popup);
    };

    return CordovaIFrameNavigator;
}();

/***/ }),

/***/ "./src/CordovaPopupNavigator.js":
/*!**************************************!*\
  !*** ./src/CordovaPopupNavigator.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.CordovaPopupNavigator = undefined;

var _CordovaPopupWindow = __webpack_require__(/*! ./CordovaPopupWindow.js */ "./src/CordovaPopupWindow.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var CordovaPopupNavigator = exports.CordovaPopupNavigator = function () {
    function CordovaPopupNavigator() {
        _classCallCheck(this, CordovaPopupNavigator);
    }

    CordovaPopupNavigator.prototype.prepare = function prepare(params) {
        var popup = new _CordovaPopupWindow.CordovaPopupWindow(params);
        return Promise.resolve(popup);
    };

    return CordovaPopupNavigator;
}();

/***/ }),

/***/ "./src/CordovaPopupWindow.js":
/*!***********************************!*\
  !*** ./src/CordovaPopupWindow.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.CordovaPopupWindow = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DefaultPopupFeatures = 'location=no,toolbar=no,zoom=no';
var DefaultPopupTarget = "_blank";

var CordovaPopupWindow = exports.CordovaPopupWindow = function () {
    function CordovaPopupWindow(params) {
        var _this = this;

        _classCallCheck(this, CordovaPopupWindow);

        this._promise = new Promise(function (resolve, reject) {
            _this._resolve = resolve;
            _this._reject = reject;
        });

        this.features = params.popupWindowFeatures || DefaultPopupFeatures;
        this.target = params.popupWindowTarget || DefaultPopupTarget;

        this.redirect_uri = params.startUrl;
        _Log.Log.debug("CordovaPopupWindow.ctor: redirect_uri: " + this.redirect_uri);
    }

    CordovaPopupWindow.prototype._isInAppBrowserInstalled = function _isInAppBrowserInstalled(cordovaMetadata) {
        return ["cordova-plugin-inappbrowser", "cordova-plugin-inappbrowser.inappbrowser", "org.apache.cordova.inappbrowser"].some(function (name) {
            return cordovaMetadata.hasOwnProperty(name);
        });
    };

    CordovaPopupWindow.prototype.navigate = function navigate(params) {
        if (!params || !params.url) {
            this._error("No url provided");
        } else {
            if (!window.cordova) {
                return this._error("cordova is undefined");
            }

            var cordovaMetadata = window.cordova.require("cordova/plugin_list").metadata;
            if (this._isInAppBrowserInstalled(cordovaMetadata) === false) {
                return this._error("InAppBrowser plugin not found");
            }
            this._popup = cordova.InAppBrowser.open(params.url, this.target, this.features);
            if (this._popup) {
                _Log.Log.debug("CordovaPopupWindow.navigate: popup successfully created");

                this._exitCallbackEvent = this._exitCallback.bind(this);
                this._loadStartCallbackEvent = this._loadStartCallback.bind(this);

                this._popup.addEventListener("exit", this._exitCallbackEvent, false);
                this._popup.addEventListener("loadstart", this._loadStartCallbackEvent, false);
            } else {
                this._error("Error opening popup window");
            }
        }
        return this.promise;
    };

    CordovaPopupWindow.prototype._loadStartCallback = function _loadStartCallback(event) {
        if (event.url.indexOf(this.redirect_uri) === 0) {
            this._success({ url: event.url });
        }
    };

    CordovaPopupWindow.prototype._exitCallback = function _exitCallback(message) {
        this._error(message);
    };

    CordovaPopupWindow.prototype._success = function _success(data) {
        this._cleanup();

        _Log.Log.debug("CordovaPopupWindow: Successful response from cordova popup window");
        this._resolve(data);
    };

    CordovaPopupWindow.prototype._error = function _error(message) {
        this._cleanup();

        _Log.Log.error(message);
        this._reject(new Error(message));
    };

    CordovaPopupWindow.prototype.close = function close() {
        this._cleanup();
    };

    CordovaPopupWindow.prototype._cleanup = function _cleanup() {
        if (this._popup) {
            _Log.Log.debug("CordovaPopupWindow: cleaning up popup");
            this._popup.removeEventListener("exit", this._exitCallbackEvent, false);
            this._popup.removeEventListener("loadstart", this._loadStartCallbackEvent, false);
            this._popup.close();
        }
        this._popup = null;
    };

    _createClass(CordovaPopupWindow, [{
        key: 'promise',
        get: function get() {
            return this._promise;
        }
    }]);

    return CordovaPopupWindow;
}();

/***/ }),

/***/ "./src/ErrorResponse.js":
/*!******************************!*\
  !*** ./src/ErrorResponse.js ***!
  \******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
        value: true
});
exports.ErrorResponse = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var ErrorResponse = exports.ErrorResponse = function (_Error) {
        _inherits(ErrorResponse, _Error);

        function ErrorResponse() {
                var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
                    error = _ref.error,
                    error_description = _ref.error_description,
                    error_uri = _ref.error_uri,
                    state = _ref.state,
                    session_state = _ref.session_state;

                _classCallCheck(this, ErrorResponse);

                if (!error) {
                        _Log.Log.error("No error passed to ErrorResponse");
                        throw new Error("error");
                }

                var _this = _possibleConstructorReturn(this, _Error.call(this, error_description || error));

                _this.name = "ErrorResponse";

                _this.error = error;
                _this.error_description = error_description;
                _this.error_uri = error_uri;

                _this.state = state;
                _this.session_state = session_state;
                return _this;
        }

        return ErrorResponse;
}(Error);

/***/ }),

/***/ "./src/Event.js":
/*!**********************!*\
  !*** ./src/Event.js ***!
  \**********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Event = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var Event = exports.Event = function () {
    function Event(name) {
        _classCallCheck(this, Event);

        this._name = name;
        this._callbacks = [];
    }

    Event.prototype.addHandler = function addHandler(cb) {
        this._callbacks.push(cb);
    };

    Event.prototype.removeHandler = function removeHandler(cb) {
        var idx = this._callbacks.findIndex(function (item) {
            return item === cb;
        });
        if (idx >= 0) {
            this._callbacks.splice(idx, 1);
        }
    };

    Event.prototype.raise = function raise() {
        _Log.Log.debug("Event: Raising event: " + this._name);
        for (var i = 0; i < this._callbacks.length; i++) {
            var _callbacks;

            (_callbacks = this._callbacks)[i].apply(_callbacks, arguments);
        }
    };

    return Event;
}();

/***/ }),

/***/ "./src/Global.js":
/*!***********************!*\
  !*** ./src/Global.js ***!
  \***********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var timer = {
    setInterval: function (_setInterval) {
        function setInterval(_x, _x2) {
            return _setInterval.apply(this, arguments);
        }

        setInterval.toString = function () {
            return _setInterval.toString();
        };

        return setInterval;
    }(function (cb, duration) {
        return setInterval(cb, duration);
    }),
    clearInterval: function (_clearInterval) {
        function clearInterval(_x3) {
            return _clearInterval.apply(this, arguments);
        }

        clearInterval.toString = function () {
            return _clearInterval.toString();
        };

        return clearInterval;
    }(function (handle) {
        return clearInterval(handle);
    })
};

var testing = false;
var request = null;

var Global = exports.Global = function () {
    function Global() {
        _classCallCheck(this, Global);
    }

    Global._testing = function _testing() {
        testing = true;
    };

    Global.setXMLHttpRequest = function setXMLHttpRequest(newRequest) {
        request = newRequest;
    };

    _createClass(Global, null, [{
        key: 'location',
        get: function get() {
            if (!testing) {
                return location;
            }
        }
    }, {
        key: 'localStorage',
        get: function get() {
            if (!testing && typeof window !== 'undefined') {
                return localStorage;
            }
        }
    }, {
        key: 'sessionStorage',
        get: function get() {
            if (!testing && typeof window !== 'undefined') {
                return sessionStorage;
            }
        }
    }, {
        key: 'XMLHttpRequest',
        get: function get() {
            if (!testing && typeof window !== 'undefined') {
                return request || XMLHttpRequest;
            }
        }
    }, {
        key: 'timer',
        get: function get() {
            if (!testing) {
                return timer;
            }
        }
    }]);

    return Global;
}();

/***/ }),

/***/ "./src/IFrameNavigator.js":
/*!********************************!*\
  !*** ./src/IFrameNavigator.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.IFrameNavigator = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _IFrameWindow = __webpack_require__(/*! ./IFrameWindow.js */ "./src/IFrameWindow.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var IFrameNavigator = exports.IFrameNavigator = function () {
    function IFrameNavigator() {
        _classCallCheck(this, IFrameNavigator);
    }

    IFrameNavigator.prototype.prepare = function prepare(params) {
        var frame = new _IFrameWindow.IFrameWindow(params);
        return Promise.resolve(frame);
    };

    IFrameNavigator.prototype.callback = function callback(url) {
        _Log.Log.debug("IFrameNavigator.callback");

        try {
            _IFrameWindow.IFrameWindow.notifyParent(url);
            return Promise.resolve();
        } catch (e) {
            return Promise.reject(e);
        }
    };

    return IFrameNavigator;
}();

/***/ }),

/***/ "./src/IFrameWindow.js":
/*!*****************************!*\
  !*** ./src/IFrameWindow.js ***!
  \*****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.IFrameWindow = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var DefaultTimeout = 10000;

var IFrameWindow = exports.IFrameWindow = function () {
    function IFrameWindow(params) {
        var _this = this;

        _classCallCheck(this, IFrameWindow);

        this._promise = new Promise(function (resolve, reject) {
            _this._resolve = resolve;
            _this._reject = reject;
        });

        this._boundMessageEvent = this._message.bind(this);
        window.addEventListener("message", this._boundMessageEvent, false);

        this._frame = window.document.createElement("iframe");

        // shotgun approach
        this._frame.style.visibility = "hidden";
        this._frame.style.position = "absolute";
        this._frame.style.display = "none";
        this._frame.style.width = 0;
        this._frame.style.height = 0;

        window.document.body.appendChild(this._frame);
    }

    IFrameWindow.prototype.navigate = function navigate(params) {
        if (!params || !params.url) {
            this._error("No url provided");
        } else {
            var timeout = params.silentRequestTimeout || DefaultTimeout;
            _Log.Log.debug("IFrameWindow.navigate: Using timeout of:", timeout);
            this._timer = window.setTimeout(this._timeout.bind(this), timeout);
            this._frame.src = params.url;
        }

        return this.promise;
    };

    IFrameWindow.prototype._success = function _success(data) {
        this._cleanup();

        _Log.Log.debug("IFrameWindow: Successful response from frame window");
        this._resolve(data);
    };

    IFrameWindow.prototype._error = function _error(message) {
        this._cleanup();

        _Log.Log.error(message);
        this._reject(new Error(message));
    };

    IFrameWindow.prototype.close = function close() {
        this._cleanup();
    };

    IFrameWindow.prototype._cleanup = function _cleanup() {
        if (this._frame) {
            _Log.Log.debug("IFrameWindow: cleanup");

            window.removeEventListener("message", this._boundMessageEvent, false);
            window.clearTimeout(this._timer);
            window.document.body.removeChild(this._frame);

            this._timer = null;
            this._frame = null;
            this._boundMessageEvent = null;
        }
    };

    IFrameWindow.prototype._timeout = function _timeout() {
        _Log.Log.debug("IFrameWindow.timeout");
        this._error("Frame window timed out");
    };

    IFrameWindow.prototype._message = function _message(e) {
        _Log.Log.debug("IFrameWindow.message");

        if (this._timer && e.origin === this._origin && e.source === this._frame.contentWindow) {
            var url = e.data;
            if (url) {
                this._success({ url: url });
            } else {
                this._error("Invalid response from frame");
            }
        }
    };

    IFrameWindow.notifyParent = function notifyParent(url) {
        _Log.Log.debug("IFrameWindow.notifyParent");
        if (window.frameElement) {
            url = url || window.location.href;
            if (url) {
                _Log.Log.debug("IFrameWindow.notifyParent: posting url message to parent");
                window.parent.postMessage(url, location.protocol + "//" + location.host);
            }
        }
    };

    _createClass(IFrameWindow, [{
        key: "promise",
        get: function get() {
            return this._promise;
        }
    }, {
        key: "_origin",
        get: function get() {
            return location.protocol + "//" + location.host;
        }
    }]);

    return IFrameWindow;
}();

/***/ }),

/***/ "./src/InMemoryWebStorage.js":
/*!***********************************!*\
  !*** ./src/InMemoryWebStorage.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.InMemoryWebStorage = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var InMemoryWebStorage = exports.InMemoryWebStorage = function () {
    function InMemoryWebStorage() {
        _classCallCheck(this, InMemoryWebStorage);

        this._data = {};
    }

    InMemoryWebStorage.prototype.getItem = function getItem(key) {
        _Log.Log.debug("InMemoryWebStorage.getItem", key);
        return this._data[key];
    };

    InMemoryWebStorage.prototype.setItem = function setItem(key, value) {
        _Log.Log.debug("InMemoryWebStorage.setItem", key);
        this._data[key] = value;
    };

    InMemoryWebStorage.prototype.removeItem = function removeItem(key) {
        _Log.Log.debug("InMemoryWebStorage.removeItem", key);
        delete this._data[key];
    };

    InMemoryWebStorage.prototype.key = function key(index) {
        return Object.getOwnPropertyNames(this._data)[index];
    };

    _createClass(InMemoryWebStorage, [{
        key: "length",
        get: function get() {
            return Object.getOwnPropertyNames(this._data).length;
        }
    }]);

    return InMemoryWebStorage;
}();

/***/ }),

/***/ "./src/JoseUtil.js":
/*!*************************!*\
  !*** ./src/JoseUtil.js ***!
  \*************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.JoseUtil = undefined;

var _jsrsasign = __webpack_require__(/*! ./crypto/jsrsasign */ "./src/crypto/jsrsasign.js");

var _JoseUtilImpl = __webpack_require__(/*! ./JoseUtilImpl */ "./src/JoseUtilImpl.js");

var _JoseUtilImpl2 = _interopRequireDefault(_JoseUtilImpl);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var JoseUtil = exports.JoseUtil = (0, _JoseUtilImpl2.default)({ jws: _jsrsasign.jws, KeyUtil: _jsrsasign.KeyUtil, X509: _jsrsasign.X509, crypto: _jsrsasign.crypto, hextob64u: _jsrsasign.hextob64u, b64tohex: _jsrsasign.b64tohex, AllowedSigningAlgs: _jsrsasign.AllowedSigningAlgs });

/***/ }),

/***/ "./src/JoseUtilImpl.js":
/*!*****************************!*\
  !*** ./src/JoseUtilImpl.js ***!
  \*****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = getJoseUtil;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

function getJoseUtil(_ref) {
    var jws = _ref.jws,
        KeyUtil = _ref.KeyUtil,
        X509 = _ref.X509,
        crypto = _ref.crypto,
        hextob64u = _ref.hextob64u,
        b64tohex = _ref.b64tohex,
        AllowedSigningAlgs = _ref.AllowedSigningAlgs;

    return function () {
        function JoseUtil() {
            _classCallCheck(this, JoseUtil);
        }

        JoseUtil.parseJwt = function parseJwt(jwt) {
            _Log.Log.debug("JoseUtil.parseJwt");
            try {
                var token = jws.JWS.parse(jwt);
                return {
                    header: token.headerObj,
                    payload: token.payloadObj
                };
            } catch (e) {
                _Log.Log.error(e);
            }
        };

        JoseUtil.validateJwt = function validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive) {
            _Log.Log.debug("JoseUtil.validateJwt");

            try {
                if (key.kty === "RSA") {
                    if (key.e && key.n) {
                        key = KeyUtil.getKey(key);
                    } else if (key.x5c && key.x5c.length) {
                        var hex = b64tohex(key.x5c[0]);
                        key = X509.getPublicKeyFromCertHex(hex);
                    } else {
                        _Log.Log.error("JoseUtil.validateJwt: RSA key missing key material", key);
                        return Promise.reject(new Error("RSA key missing key material"));
                    }
                } else if (key.kty === "EC") {
                    if (key.crv && key.x && key.y) {
                        key = KeyUtil.getKey(key);
                    } else {
                        _Log.Log.error("JoseUtil.validateJwt: EC key missing key material", key);
                        return Promise.reject(new Error("EC key missing key material"));
                    }
                } else {
                    _Log.Log.error("JoseUtil.validateJwt: Unsupported key type", key && key.kty);
                    return Promise.reject(new Error( true && key.kty));
                }

                return JoseUtil._validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive);
            } catch (e) {
                _Log.Log.error(e && e.message || e);
                return Promise.reject("JWT validation failed");
            }
        };

        JoseUtil.validateJwtAttributes = function validateJwtAttributes(jwt, issuer, audience, clockSkew, now, timeInsensitive) {
            if (!clockSkew) {
                clockSkew = 0;
            }

            if (!now) {
                now = parseInt(Date.now() / 1000);
            }

            var payload = JoseUtil.parseJwt(jwt).payload;

            if (!payload.iss) {
                _Log.Log.error("JoseUtil._validateJwt: issuer was not provided");
                return Promise.reject(new Error("issuer was not provided"));
            }
            if (payload.iss !== issuer) {
                _Log.Log.error("JoseUtil._validateJwt: Invalid issuer in token", payload.iss);
                return Promise.reject(new Error("Invalid issuer in token: " + payload.iss));
            }

            if (!payload.aud) {
                _Log.Log.error("JoseUtil._validateJwt: aud was not provided");
                return Promise.reject(new Error("aud was not provided"));
            }
            var validAudience = payload.aud === audience || Array.isArray(payload.aud) && payload.aud.indexOf(audience) >= 0;
            if (!validAudience) {
                _Log.Log.error("JoseUtil._validateJwt: Invalid audience in token", payload.aud);
                return Promise.reject(new Error("Invalid audience in token: " + payload.aud));
            }
            if (payload.azp && payload.azp !== audience) {
                _Log.Log.error("JoseUtil._validateJwt: Invalid azp in token", payload.azp);
                return Promise.reject(new Error("Invalid azp in token: " + payload.azp));
            }

            if (!timeInsensitive) {
                var lowerNow = now + clockSkew;
                var upperNow = now - clockSkew;

                if (!payload.iat) {
                    _Log.Log.error("JoseUtil._validateJwt: iat was not provided");
                    return Promise.reject(new Error("iat was not provided"));
                }
                if (lowerNow < payload.iat) {
                    _Log.Log.error("JoseUtil._validateJwt: iat is in the future", payload.iat);
                    return Promise.reject(new Error("iat is in the future: " + payload.iat));
                }

                if (payload.nbf && lowerNow < payload.nbf) {
                    _Log.Log.error("JoseUtil._validateJwt: nbf is in the future", payload.nbf);
                    return Promise.reject(new Error("nbf is in the future: " + payload.nbf));
                }

                if (!payload.exp) {
                    _Log.Log.error("JoseUtil._validateJwt: exp was not provided");
                    return Promise.reject(new Error("exp was not provided"));
                }
                if (payload.exp < upperNow) {
                    _Log.Log.error("JoseUtil._validateJwt: exp is in the past", payload.exp);
                    return Promise.reject(new Error("exp is in the past:" + payload.exp));
                }
            }

            return Promise.resolve(payload);
        };

        JoseUtil._validateJwt = function _validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive) {

            return JoseUtil.validateJwtAttributes(jwt, issuer, audience, clockSkew, now, timeInsensitive).then(function (payload) {
                try {
                    if (!jws.JWS.verify(jwt, key, AllowedSigningAlgs)) {
                        _Log.Log.error("JoseUtil._validateJwt: signature validation failed");
                        return Promise.reject(new Error("signature validation failed"));
                    }

                    return payload;
                } catch (e) {
                    _Log.Log.error(e && e.message || e);
                    return Promise.reject(new Error("signature validation failed"));
                }
            });
        };

        JoseUtil.hashString = function hashString(value, alg) {
            try {
                return crypto.Util.hashString(value, alg);
            } catch (e) {
                _Log.Log.error(e);
            }
        };

        JoseUtil.hexToBase64Url = function hexToBase64Url(value) {
            try {
                return hextob64u(value);
            } catch (e) {
                _Log.Log.error(e);
            }
        };

        return JoseUtil;
    }();
}
module.exports = exports["default"];

/***/ }),

/***/ "./src/JsonService.js":
/*!****************************!*\
  !*** ./src/JsonService.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.JsonService = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var JsonService = exports.JsonService = function () {
    function JsonService() {
        var additionalContentTypes = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
        var XMLHttpRequestCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Global.Global.XMLHttpRequest;
        var jwtHandler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;

        _classCallCheck(this, JsonService);

        if (additionalContentTypes && Array.isArray(additionalContentTypes)) {
            this._contentTypes = additionalContentTypes.slice();
        } else {
            this._contentTypes = [];
        }
        this._contentTypes.push('application/json');
        if (jwtHandler) {
            this._contentTypes.push('application/jwt');
        }

        this._XMLHttpRequest = XMLHttpRequestCtor;
        this._jwtHandler = jwtHandler;
    }

    JsonService.prototype.getJson = function getJson(url, token) {
        var _this = this;

        if (!url) {
            _Log.Log.error("JsonService.getJson: No url passed");
            throw new Error("url");
        }

        _Log.Log.debug("JsonService.getJson, url: ", url);

        return new Promise(function (resolve, reject) {

            var req = new _this._XMLHttpRequest();
            req.open('GET', url);

            var allowedContentTypes = _this._contentTypes;
            var jwtHandler = _this._jwtHandler;

            req.onload = function () {
                _Log.Log.debug("JsonService.getJson: HTTP response received, status", req.status);

                if (req.status === 200) {

                    var contentType = req.getResponseHeader("Content-Type");
                    if (contentType) {

                        var found = allowedContentTypes.find(function (item) {
                            if (contentType.startsWith(item)) {
                                return true;
                            }
                        });

                        if (found == "application/jwt") {
                            jwtHandler(req).then(resolve, reject);
                            return;
                        }

                        if (found) {
                            try {
                                resolve(JSON.parse(req.responseText));
                                return;
                            } catch (e) {
                                _Log.Log.error("JsonService.getJson: Error parsing JSON response", e.message);
                                reject(e);
                                return;
                            }
                        }
                    }

                    reject(Error("Invalid response Content-Type: " + contentType + ", from URL: " + url));
                } else {
                    reject(Error(req.statusText + " (" + req.status + ")"));
                }
            };

            req.onerror = function () {
                _Log.Log.error("JsonService.getJson: network error");
                reject(Error("Network Error"));
            };

            if (token) {
                _Log.Log.debug("JsonService.getJson: token passed, setting Authorization header");
                req.setRequestHeader("Authorization", "Bearer " + token);
            }

            req.send();
        });
    };

    JsonService.prototype.postForm = function postForm(url, payload) {
        var _this2 = this;

        if (!url) {
            _Log.Log.error("JsonService.postForm: No url passed");
            throw new Error("url");
        }

        _Log.Log.debug("JsonService.postForm, url: ", url);

        return new Promise(function (resolve, reject) {

            var req = new _this2._XMLHttpRequest();
            req.open('POST', url);

            var allowedContentTypes = _this2._contentTypes;

            req.onload = function () {
                _Log.Log.debug("JsonService.postForm: HTTP response received, status", req.status);

                if (req.status === 200) {

                    var contentType = req.getResponseHeader("Content-Type");
                    if (contentType) {

                        var found = allowedContentTypes.find(function (item) {
                            if (contentType.startsWith(item)) {
                                return true;
                            }
                        });

                        if (found) {
                            try {
                                resolve(JSON.parse(req.responseText));
                                return;
                            } catch (e) {
                                _Log.Log.error("JsonService.postForm: Error parsing JSON response", e.message);
                                reject(e);
                                return;
                            }
                        }
                    }

                    reject(Error("Invalid response Content-Type: " + contentType + ", from URL: " + url));
                    return;
                }

                if (req.status === 400) {

                    var contentType = req.getResponseHeader("Content-Type");
                    if (contentType) {

                        var found = allowedContentTypes.find(function (item) {
                            if (contentType.startsWith(item)) {
                                return true;
                            }
                        });

                        if (found) {
                            try {
                                var payload = JSON.parse(req.responseText);
                                if (payload && payload.error) {
                                    _Log.Log.error("JsonService.postForm: Error from server: ", payload.error);
                                    reject(new Error(payload.error));
                                    return;
                                }
                            } catch (e) {
                                _Log.Log.error("JsonService.postForm: Error parsing JSON response", e.message);
                                reject(e);
                                return;
                            }
                        }
                    }
                }

                reject(Error(req.statusText + " (" + req.status + ")"));
            };

            req.onerror = function () {
                _Log.Log.error("JsonService.postForm: network error");
                reject(Error("Network Error"));
            };

            var body = "";
            for (var key in payload) {

                var value = payload[key];

                if (value) {

                    if (body.length > 0) {
                        body += "&";
                    }

                    body += encodeURIComponent(key);
                    body += "=";
                    body += encodeURIComponent(value);
                }
            }

            req.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            req.send(body);
        });
    };

    return JsonService;
}();

/***/ }),

/***/ "./src/Log.js":
/*!********************!*\
  !*** ./src/Log.js ***!
  \********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var nopLogger = {
    debug: function debug() {},
    info: function info() {},
    warn: function warn() {},
    error: function error() {}
};

var NONE = 0;
var ERROR = 1;
var WARN = 2;
var INFO = 3;
var DEBUG = 4;

var logger = void 0;
var level = void 0;

var Log = exports.Log = function () {
    function Log() {
        _classCallCheck(this, Log);
    }

    Log.reset = function reset() {
        level = INFO;
        logger = nopLogger;
    };

    Log.debug = function debug() {
        if (level >= DEBUG) {
            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
                args[_key] = arguments[_key];
            }

            logger.debug.apply(logger, Array.from(args));
        }
    };

    Log.info = function info() {
        if (level >= INFO) {
            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
                args[_key2] = arguments[_key2];
            }

            logger.info.apply(logger, Array.from(args));
        }
    };

    Log.warn = function warn() {
        if (level >= WARN) {
            for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
                args[_key3] = arguments[_key3];
            }

            logger.warn.apply(logger, Array.from(args));
        }
    };

    Log.error = function error() {
        if (level >= ERROR) {
            for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
                args[_key4] = arguments[_key4];
            }

            logger.error.apply(logger, Array.from(args));
        }
    };

    _createClass(Log, null, [{
        key: "NONE",
        get: function get() {
            return NONE;
        }
    }, {
        key: "ERROR",
        get: function get() {
            return ERROR;
        }
    }, {
        key: "WARN",
        get: function get() {
            return WARN;
        }
    }, {
        key: "INFO",
        get: function get() {
            return INFO;
        }
    }, {
        key: "DEBUG",
        get: function get() {
            return DEBUG;
        }
    }, {
        key: "level",
        get: function get() {
            return level;
        },
        set: function set(value) {
            if (NONE <= value && value <= DEBUG) {
                level = value;
            } else {
                throw new Error("Invalid log level");
            }
        }
    }, {
        key: "logger",
        get: function get() {
            return logger;
        },
        set: function set(value) {
            if (!value.debug && value.info) {
                // just to stay backwards compat. can remove in 2.0
                value.debug = value.info;
            }

            if (value.debug && value.info && value.warn && value.error) {
                logger = value;
            } else {
                throw new Error("Invalid logger");
            }
        }
    }]);

    return Log;
}();

Log.reset();

/***/ }),

/***/ "./src/MetadataService.js":
/*!********************************!*\
  !*** ./src/MetadataService.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.MetadataService = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _JsonService = __webpack_require__(/*! ./JsonService.js */ "./src/JsonService.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var OidcMetadataUrlPath = '.well-known/openid-configuration';

var MetadataService = exports.MetadataService = function () {
    function MetadataService(settings) {
        var JsonServiceCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _JsonService.JsonService;

        _classCallCheck(this, MetadataService);

        if (!settings) {
            _Log.Log.error("MetadataService: No settings passed to MetadataService");
            throw new Error("settings");
        }

        this._settings = settings;
        this._jsonService = new JsonServiceCtor(['application/jwk-set+json']);
    }

    MetadataService.prototype.getMetadata = function getMetadata() {
        var _this = this;

        if (this._settings.metadata) {
            _Log.Log.debug("MetadataService.getMetadata: Returning metadata from settings");
            return Promise.resolve(this._settings.metadata);
        }

        if (!this.metadataUrl) {
            _Log.Log.error("MetadataService.getMetadata: No authority or metadataUrl configured on settings");
            return Promise.reject(new Error("No authority or metadataUrl configured on settings"));
        }

        _Log.Log.debug("MetadataService.getMetadata: getting metadata from", this.metadataUrl);

        return this._jsonService.getJson(this.metadataUrl).then(function (metadata) {
            _Log.Log.debug("MetadataService.getMetadata: json received");
            _this._settings.metadata = metadata;
            return metadata;
        });
    };

    MetadataService.prototype.getIssuer = function getIssuer() {
        return this._getMetadataProperty("issuer");
    };

    MetadataService.prototype.getAuthorizationEndpoint = function getAuthorizationEndpoint() {
        return this._getMetadataProperty("authorization_endpoint");
    };

    MetadataService.prototype.getUserInfoEndpoint = function getUserInfoEndpoint() {
        return this._getMetadataProperty("userinfo_endpoint");
    };

    MetadataService.prototype.getTokenEndpoint = function getTokenEndpoint() {
        var optional = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

        return this._getMetadataProperty("token_endpoint", optional);
    };

    MetadataService.prototype.getCheckSessionIframe = function getCheckSessionIframe() {
        return this._getMetadataProperty("check_session_iframe", true);
    };

    MetadataService.prototype.getEndSessionEndpoint = function getEndSessionEndpoint() {
        return this._getMetadataProperty("end_session_endpoint", true);
    };

    MetadataService.prototype.getRevocationEndpoint = function getRevocationEndpoint() {
        return this._getMetadataProperty("revocation_endpoint", true);
    };

    MetadataService.prototype.getKeysEndpoint = function getKeysEndpoint() {
        return this._getMetadataProperty("jwks_uri", true);
    };

    MetadataService.prototype._getMetadataProperty = function _getMetadataProperty(name) {
        var optional = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

        _Log.Log.debug("MetadataService.getMetadataProperty for: " + name);

        return this.getMetadata().then(function (metadata) {
            _Log.Log.debug("MetadataService.getMetadataProperty: metadata recieved");

            if (metadata[name] === undefined) {

                if (optional === true) {
                    _Log.Log.warn("MetadataService.getMetadataProperty: Metadata does not contain optional property " + name);
                    return undefined;
                } else {
                    _Log.Log.error("MetadataService.getMetadataProperty: Metadata does not contain property " + name);
                    throw new Error("Metadata does not contain property " + name);
                }
            }

            return metadata[name];
        });
    };

    MetadataService.prototype.getSigningKeys = function getSigningKeys() {
        var _this2 = this;

        if (this._settings.signingKeys) {
            _Log.Log.debug("MetadataService.getSigningKeys: Returning signingKeys from settings");
            return Promise.resolve(this._settings.signingKeys);
        }

        return this._getMetadataProperty("jwks_uri").then(function (jwks_uri) {
            _Log.Log.debug("MetadataService.getSigningKeys: jwks_uri received", jwks_uri);

            return _this2._jsonService.getJson(jwks_uri).then(function (keySet) {
                _Log.Log.debug("MetadataService.getSigningKeys: key set received", keySet);

                if (!keySet.keys) {
                    _Log.Log.error("MetadataService.getSigningKeys: Missing keys on keyset");
                    throw new Error("Missing keys on keyset");
                }

                _this2._settings.signingKeys = keySet.keys;
                return _this2._settings.signingKeys;
            });
        });
    };

    _createClass(MetadataService, [{
        key: 'metadataUrl',
        get: function get() {
            if (!this._metadataUrl) {
                if (this._settings.metadataUrl) {
                    this._metadataUrl = this._settings.metadataUrl;
                } else {
                    this._metadataUrl = this._settings.authority;

                    if (this._metadataUrl && this._metadataUrl.indexOf(OidcMetadataUrlPath) < 0) {
                        if (this._metadataUrl[this._metadataUrl.length - 1] !== '/') {
                            this._metadataUrl += '/';
                        }
                        this._metadataUrl += OidcMetadataUrlPath;
                    }
                }
            }

            return this._metadataUrl;
        }
    }]);

    return MetadataService;
}();

/***/ }),

/***/ "./src/OidcClient.js":
/*!***************************!*\
  !*** ./src/OidcClient.js ***!
  \***************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.OidcClient = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _OidcClientSettings = __webpack_require__(/*! ./OidcClientSettings.js */ "./src/OidcClientSettings.js");

var _ErrorResponse = __webpack_require__(/*! ./ErrorResponse.js */ "./src/ErrorResponse.js");

var _SigninRequest = __webpack_require__(/*! ./SigninRequest.js */ "./src/SigninRequest.js");

var _SigninResponse = __webpack_require__(/*! ./SigninResponse.js */ "./src/SigninResponse.js");

var _SignoutRequest = __webpack_require__(/*! ./SignoutRequest.js */ "./src/SignoutRequest.js");

var _SignoutResponse = __webpack_require__(/*! ./SignoutResponse.js */ "./src/SignoutResponse.js");

var _SigninState = __webpack_require__(/*! ./SigninState.js */ "./src/SigninState.js");

var _State = __webpack_require__(/*! ./State.js */ "./src/State.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var OidcClient = exports.OidcClient = function () {
    function OidcClient() {
        var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        _classCallCheck(this, OidcClient);

        if (settings instanceof _OidcClientSettings.OidcClientSettings) {
            this._settings = settings;
        } else {
            this._settings = new _OidcClientSettings.OidcClientSettings(settings);
        }
    }

    OidcClient.prototype.createSigninRequest = function createSigninRequest() {
        var _this = this;

        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            response_type = _ref.response_type,
            scope = _ref.scope,
            redirect_uri = _ref.redirect_uri,
            data = _ref.data,
            state = _ref.state,
            prompt = _ref.prompt,
            display = _ref.display,
            max_age = _ref.max_age,
            ui_locales = _ref.ui_locales,
            id_token_hint = _ref.id_token_hint,
            login_hint = _ref.login_hint,
            acr_values = _ref.acr_values,
            resource = _ref.resource,
            request = _ref.request,
            request_uri = _ref.request_uri,
            response_mode = _ref.response_mode,
            extraQueryParams = _ref.extraQueryParams,
            extraTokenParams = _ref.extraTokenParams,
            request_type = _ref.request_type,
            skipUserInfo = _ref.skipUserInfo;

        var stateStore = arguments[1];

        _Log.Log.debug("OidcClient.createSigninRequest");

        var client_id = this._settings.client_id;
        response_type = response_type || this._settings.response_type;
        scope = scope || this._settings.scope;
        redirect_uri = redirect_uri || this._settings.redirect_uri;

        // id_token_hint, login_hint aren't allowed on _settings
        prompt = prompt || this._settings.prompt;
        display = display || this._settings.display;
        max_age = max_age || this._settings.max_age;
        ui_locales = ui_locales || this._settings.ui_locales;
        acr_values = acr_values || this._settings.acr_values;
        resource = resource || this._settings.resource;
        response_mode = response_mode || this._settings.response_mode;
        extraQueryParams = extraQueryParams || this._settings.extraQueryParams;
        extraTokenParams = extraTokenParams || this._settings.extraTokenParams;

        var authority = this._settings.authority;

        if (_SigninRequest.SigninRequest.isCode(response_type) && response_type !== "code") {
            return Promise.reject(new Error("OpenID Connect hybrid flow is not supported"));
        }

        return this._metadataService.getAuthorizationEndpoint().then(function (url) {
            _Log.Log.debug("OidcClient.createSigninRequest: Received authorization endpoint", url);

            var signinRequest = new _SigninRequest.SigninRequest({
                url: url,
                client_id: client_id,
                redirect_uri: redirect_uri,
                response_type: response_type,
                scope: scope,
                data: data || state,
                authority: authority,
                prompt: prompt, display: display, max_age: max_age, ui_locales: ui_locales, id_token_hint: id_token_hint, login_hint: login_hint, acr_values: acr_values,
                resource: resource, request: request, request_uri: request_uri, extraQueryParams: extraQueryParams, extraTokenParams: extraTokenParams, request_type: request_type, response_mode: response_mode,
                client_secret: _this._settings.client_secret,
                skipUserInfo: skipUserInfo
            });

            var signinState = signinRequest.state;
            stateStore = stateStore || _this._stateStore;

            return stateStore.set(signinState.id, signinState.toStorageString()).then(function () {
                return signinRequest;
            });
        });
    };

    OidcClient.prototype.readSigninResponseState = function readSigninResponseState(url, stateStore) {
        var removeState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

        _Log.Log.debug("OidcClient.readSigninResponseState");

        var useQuery = this._settings.response_mode === "query" || !this._settings.response_mode && _SigninRequest.SigninRequest.isCode(this._settings.response_type);
        var delimiter = useQuery ? "?" : "#";

        var response = new _SigninResponse.SigninResponse(url, delimiter);

        if (!response.state) {
            _Log.Log.error("OidcClient.readSigninResponseState: No state in response");
            return Promise.reject(new Error("No state in response"));
        }

        stateStore = stateStore || this._stateStore;

        var stateApi = removeState ? stateStore.remove.bind(stateStore) : stateStore.get.bind(stateStore);

        return stateApi(response.state).then(function (storedStateString) {
            if (!storedStateString) {
                _Log.Log.error("OidcClient.readSigninResponseState: No matching state found in storage");
                throw new Error("No matching state found in storage");
            }

            var state = _SigninState.SigninState.fromStorageString(storedStateString);
            return { state: state, response: response };
        });
    };

    OidcClient.prototype.processSigninResponse = function processSigninResponse(url, stateStore) {
        var _this2 = this;

        _Log.Log.debug("OidcClient.processSigninResponse");

        return this.readSigninResponseState(url, stateStore, true).then(function (_ref2) {
            var state = _ref2.state,
                response = _ref2.response;

            _Log.Log.debug("OidcClient.processSigninResponse: Received state from storage; validating response");
            return _this2._validator.validateSigninResponse(state, response);
        });
    };

    OidcClient.prototype.createSignoutRequest = function createSignoutRequest() {
        var _this3 = this;

        var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            id_token_hint = _ref3.id_token_hint,
            data = _ref3.data,
            state = _ref3.state,
            post_logout_redirect_uri = _ref3.post_logout_redirect_uri,
            extraQueryParams = _ref3.extraQueryParams,
            request_type = _ref3.request_type;

        var stateStore = arguments[1];

        _Log.Log.debug("OidcClient.createSignoutRequest");

        post_logout_redirect_uri = post_logout_redirect_uri || this._settings.post_logout_redirect_uri;
        extraQueryParams = extraQueryParams || this._settings.extraQueryParams;

        return this._metadataService.getEndSessionEndpoint().then(function (url) {
            if (!url) {
                _Log.Log.error("OidcClient.createSignoutRequest: No end session endpoint url returned");
                throw new Error("no end session endpoint");
            }

            _Log.Log.debug("OidcClient.createSignoutRequest: Received end session endpoint", url);

            var request = new _SignoutRequest.SignoutRequest({
                url: url,
                id_token_hint: id_token_hint,
                post_logout_redirect_uri: post_logout_redirect_uri,
                data: data || state,
                extraQueryParams: extraQueryParams,
                request_type: request_type
            });

            var signoutState = request.state;
            if (signoutState) {
                _Log.Log.debug("OidcClient.createSignoutRequest: Signout request has state to persist");

                stateStore = stateStore || _this3._stateStore;
                stateStore.set(signoutState.id, signoutState.toStorageString());
            }

            return request;
        });
    };

    OidcClient.prototype.readSignoutResponseState = function readSignoutResponseState(url, stateStore) {
        var removeState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;

        _Log.Log.debug("OidcClient.readSignoutResponseState");

        var response = new _SignoutResponse.SignoutResponse(url);
        if (!response.state) {
            _Log.Log.debug("OidcClient.readSignoutResponseState: No state in response");

            if (response.error) {
                _Log.Log.warn("OidcClient.readSignoutResponseState: Response was error: ", response.error);
                return Promise.reject(new _ErrorResponse.ErrorResponse(response));
            }

            return Promise.resolve({ undefined: undefined, response: response });
        }

        var stateKey = response.state;

        stateStore = stateStore || this._stateStore;

        var stateApi = removeState ? stateStore.remove.bind(stateStore) : stateStore.get.bind(stateStore);
        return stateApi(stateKey).then(function (storedStateString) {
            if (!storedStateString) {
                _Log.Log.error("OidcClient.readSignoutResponseState: No matching state found in storage");
                throw new Error("No matching state found in storage");
            }

            var state = _State.State.fromStorageString(storedStateString);

            return { state: state, response: response };
        });
    };

    OidcClient.prototype.processSignoutResponse = function processSignoutResponse(url, stateStore) {
        var _this4 = this;

        _Log.Log.debug("OidcClient.processSignoutResponse");

        return this.readSignoutResponseState(url, stateStore, true).then(function (_ref4) {
            var state = _ref4.state,
                response = _ref4.response;

            if (state) {
                _Log.Log.debug("OidcClient.processSignoutResponse: Received state from storage; validating response");
                return _this4._validator.validateSignoutResponse(state, response);
            } else {
                _Log.Log.debug("OidcClient.processSignoutResponse: No state from storage; skipping validating response");
                return response;
            }
        });
    };

    OidcClient.prototype.clearStaleState = function clearStaleState(stateStore) {
        _Log.Log.debug("OidcClient.clearStaleState");

        stateStore = stateStore || this._stateStore;

        return _State.State.clearStaleState(stateStore, this.settings.staleStateAge);
    };

    _createClass(OidcClient, [{
        key: '_stateStore',
        get: function get() {
            return this.settings.stateStore;
        }
    }, {
        key: '_validator',
        get: function get() {
            return this.settings.validator;
        }
    }, {
        key: '_metadataService',
        get: function get() {
            return this.settings.metadataService;
        }
    }, {
        key: 'settings',
        get: function get() {
            return this._settings;
        }
    }, {
        key: 'metadataService',
        get: function get() {
            return this._metadataService;
        }
    }]);

    return OidcClient;
}();

/***/ }),

/***/ "./src/OidcClientSettings.js":
/*!***********************************!*\
  !*** ./src/OidcClientSettings.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.OidcClientSettings = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _WebStorageStateStore = __webpack_require__(/*! ./WebStorageStateStore.js */ "./src/WebStorageStateStore.js");

var _ResponseValidator = __webpack_require__(/*! ./ResponseValidator.js */ "./src/ResponseValidator.js");

var _MetadataService = __webpack_require__(/*! ./MetadataService.js */ "./src/MetadataService.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var OidcMetadataUrlPath = '.well-known/openid-configuration';

var DefaultResponseType = "id_token";
var DefaultScope = "openid";
var DefaultStaleStateAge = 60 * 15; // seconds
var DefaultClockSkewInSeconds = 60 * 5;

var OidcClientSettings = exports.OidcClientSettings = function () {
    function OidcClientSettings() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            authority = _ref.authority,
            metadataUrl = _ref.metadataUrl,
            metadata = _ref.metadata,
            signingKeys = _ref.signingKeys,
            client_id = _ref.client_id,
            client_secret = _ref.client_secret,
            _ref$response_type = _ref.response_type,
            response_type = _ref$response_type === undefined ? DefaultResponseType : _ref$response_type,
            _ref$scope = _ref.scope,
            scope = _ref$scope === undefined ? DefaultScope : _ref$scope,
            redirect_uri = _ref.redirect_uri,
            post_logout_redirect_uri = _ref.post_logout_redirect_uri,
            prompt = _ref.prompt,
            display = _ref.display,
            max_age = _ref.max_age,
            ui_locales = _ref.ui_locales,
            acr_values = _ref.acr_values,
            resource = _ref.resource,
            response_mode = _ref.response_mode,
            _ref$filterProtocolCl = _ref.filterProtocolClaims,
            filterProtocolClaims = _ref$filterProtocolCl === undefined ? true : _ref$filterProtocolCl,
            _ref$loadUserInfo = _ref.loadUserInfo,
            loadUserInfo = _ref$loadUserInfo === undefined ? true : _ref$loadUserInfo,
            _ref$staleStateAge = _ref.staleStateAge,
            staleStateAge = _ref$staleStateAge === undefined ? DefaultStaleStateAge : _ref$staleStateAge,
            _ref$clockSkew = _ref.clockSkew,
            clockSkew = _ref$clockSkew === undefined ? DefaultClockSkewInSeconds : _ref$clockSkew,
            _ref$userInfoJwtIssue = _ref.userInfoJwtIssuer,
            userInfoJwtIssuer = _ref$userInfoJwtIssue === undefined ? 'OP' : _ref$userInfoJwtIssue,
            _ref$stateStore = _ref.stateStore,
            stateStore = _ref$stateStore === undefined ? new _WebStorageStateStore.WebStorageStateStore() : _ref$stateStore,
            _ref$ResponseValidato = _ref.ResponseValidatorCtor,
            ResponseValidatorCtor = _ref$ResponseValidato === undefined ? _ResponseValidator.ResponseValidator : _ref$ResponseValidato,
            _ref$MetadataServiceC = _ref.MetadataServiceCtor,
            MetadataServiceCtor = _ref$MetadataServiceC === undefined ? _MetadataService.MetadataService : _ref$MetadataServiceC,
            _ref$extraQueryParams = _ref.extraQueryParams,
            extraQueryParams = _ref$extraQueryParams === undefined ? {} : _ref$extraQueryParams,
            _ref$extraTokenParams = _ref.extraTokenParams,
            extraTokenParams = _ref$extraTokenParams === undefined ? {} : _ref$extraTokenParams;

        _classCallCheck(this, OidcClientSettings);

        this._authority = authority;
        this._metadataUrl = metadataUrl;
        this._metadata = metadata;
        this._signingKeys = signingKeys;

        this._client_id = client_id;
        this._client_secret = client_secret;
        this._response_type = response_type;
        this._scope = scope;
        this._redirect_uri = redirect_uri;
        this._post_logout_redirect_uri = post_logout_redirect_uri;

        this._prompt = prompt;
        this._display = display;
        this._max_age = max_age;
        this._ui_locales = ui_locales;
        this._acr_values = acr_values;
        this._resource = resource;
        this._response_mode = response_mode;

        this._filterProtocolClaims = !!filterProtocolClaims;
        this._loadUserInfo = !!loadUserInfo;
        this._staleStateAge = staleStateAge;
        this._clockSkew = clockSkew;
        this._userInfoJwtIssuer = userInfoJwtIssuer;

        this._stateStore = stateStore;
        this._validator = new ResponseValidatorCtor(this);
        this._metadataService = new MetadataServiceCtor(this);

        this._extraQueryParams = (typeof extraQueryParams === 'undefined' ? 'undefined' : _typeof(extraQueryParams)) === 'object' ? extraQueryParams : {};
        this._extraTokenParams = (typeof extraTokenParams === 'undefined' ? 'undefined' : _typeof(extraTokenParams)) === 'object' ? extraTokenParams : {};
    }

    // client config


    _createClass(OidcClientSettings, [{
        key: 'client_id',
        get: function get() {
            return this._client_id;
        },
        set: function set(value) {
            if (!this._client_id) {
                // one-time set only
                this._client_id = value;
            } else {
                _Log.Log.error("OidcClientSettings.set_client_id: client_id has already been assigned.");
                throw new Error("client_id has already been assigned.");
            }
        }
    }, {
        key: 'client_secret',
        get: function get() {
            return this._client_secret;
        }
    }, {
        key: 'response_type',
        get: function get() {
            return this._response_type;
        }
    }, {
        key: 'scope',
        get: function get() {
            return this._scope;
        }
    }, {
        key: 'redirect_uri',
        get: function get() {
            return this._redirect_uri;
        }
    }, {
        key: 'post_logout_redirect_uri',
        get: function get() {
            return this._post_logout_redirect_uri;
        }

        // optional protocol params

    }, {
        key: 'prompt',
        get: function get() {
            return this._prompt;
        }
    }, {
        key: 'display',
        get: function get() {
            return this._display;
        }
    }, {
        key: 'max_age',
        get: function get() {
            return this._max_age;
        }
    }, {
        key: 'ui_locales',
        get: function get() {
            return this._ui_locales;
        }
    }, {
        key: 'acr_values',
        get: function get() {
            return this._acr_values;
        }
    }, {
        key: 'resource',
        get: function get() {
            return this._resource;
        }
    }, {
        key: 'response_mode',
        get: function get() {
            return this._response_mode;
        }

        // metadata

    }, {
        key: 'authority',
        get: function get() {
            return this._authority;
        },
        set: function set(value) {
            if (!this._authority) {
                // one-time set only
                this._authority = value;
            } else {
                _Log.Log.error("OidcClientSettings.set_authority: authority has already been assigned.");
                throw new Error("authority has already been assigned.");
            }
        }
    }, {
        key: 'metadataUrl',
        get: function get() {
            if (!this._metadataUrl) {
                this._metadataUrl = this.authority;

                if (this._metadataUrl && this._metadataUrl.indexOf(OidcMetadataUrlPath) < 0) {
                    if (this._metadataUrl[this._metadataUrl.length - 1] !== '/') {
                        this._metadataUrl += '/';
                    }
                    this._metadataUrl += OidcMetadataUrlPath;
                }
            }

            return this._metadataUrl;
        }

        // settable/cachable metadata values

    }, {
        key: 'metadata',
        get: function get() {
            return this._metadata;
        },
        set: function set(value) {
            this._metadata = value;
        }
    }, {
        key: 'signingKeys',
        get: function get() {
            return this._signingKeys;
        },
        set: function set(value) {
            this._signingKeys = value;
        }

        // behavior flags

    }, {
        key: 'filterProtocolClaims',
        get: function get() {
            return this._filterProtocolClaims;
        }
    }, {
        key: 'loadUserInfo',
        get: function get() {
            return this._loadUserInfo;
        }
    }, {
        key: 'staleStateAge',
        get: function get() {
            return this._staleStateAge;
        }
    }, {
        key: 'clockSkew',
        get: function get() {
            return this._clockSkew;
        }
    }, {
        key: 'userInfoJwtIssuer',
        get: function get() {
            return this._userInfoJwtIssuer;
        }
    }, {
        key: 'stateStore',
        get: function get() {
            return this._stateStore;
        }
    }, {
        key: 'validator',
        get: function get() {
            return this._validator;
        }
    }, {
        key: 'metadataService',
        get: function get() {
            return this._metadataService;
        }

        // extra query params

    }, {
        key: 'extraQueryParams',
        get: function get() {
            return this._extraQueryParams;
        },
        set: function set(value) {
            if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                this._extraQueryParams = value;
            } else {
                this._extraQueryParams = {};
            }
        }

        // extra token params

    }, {
        key: 'extraTokenParams',
        get: function get() {
            return this._extraTokenParams;
        },
        set: function set(value) {
            if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                this._extraTokenParams = value;
            } else {
                this._extraTokenParams = {};
            }
        }
    }]);

    return OidcClientSettings;
}();

/***/ }),

/***/ "./src/PopupNavigator.js":
/*!*******************************!*\
  !*** ./src/PopupNavigator.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.PopupNavigator = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _PopupWindow = __webpack_require__(/*! ./PopupWindow.js */ "./src/PopupWindow.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var PopupNavigator = exports.PopupNavigator = function () {
    function PopupNavigator() {
        _classCallCheck(this, PopupNavigator);
    }

    PopupNavigator.prototype.prepare = function prepare(params) {
        var popup = new _PopupWindow.PopupWindow(params);
        return Promise.resolve(popup);
    };

    PopupNavigator.prototype.callback = function callback(url, keepOpen, delimiter) {
        _Log.Log.debug("PopupNavigator.callback");

        try {
            _PopupWindow.PopupWindow.notifyOpener(url, keepOpen, delimiter);
            return Promise.resolve();
        } catch (e) {
            return Promise.reject(e);
        }
    };

    return PopupNavigator;
}();

/***/ }),

/***/ "./src/PopupWindow.js":
/*!****************************!*\
  !*** ./src/PopupWindow.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.PopupWindow = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _UrlUtility = __webpack_require__(/*! ./UrlUtility.js */ "./src/UrlUtility.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var CheckForPopupClosedInterval = 500;
var DefaultPopupFeatures = 'location=no,toolbar=no,width=500,height=500,left=100,top=100;';
//const DefaultPopupFeatures = 'location=no,toolbar=no,width=500,height=500,left=100,top=100;resizable=yes';

var DefaultPopupTarget = "_blank";

var PopupWindow = exports.PopupWindow = function () {
    function PopupWindow(params) {
        var _this = this;

        _classCallCheck(this, PopupWindow);

        this._promise = new Promise(function (resolve, reject) {
            _this._resolve = resolve;
            _this._reject = reject;
        });

        var target = params.popupWindowTarget || DefaultPopupTarget;
        var features = params.popupWindowFeatures || DefaultPopupFeatures;

        this._popup = window.open('', target, features);
        if (this._popup) {
            _Log.Log.debug("PopupWindow.ctor: popup successfully created");
            this._checkForPopupClosedTimer = window.setInterval(this._checkForPopupClosed.bind(this), CheckForPopupClosedInterval);
        }
    }

    PopupWindow.prototype.navigate = function navigate(params) {
        if (!this._popup) {
            this._error("PopupWindow.navigate: Error opening popup window");
        } else if (!params || !params.url) {
            this._error("PopupWindow.navigate: no url provided");
            this._error("No url provided");
        } else {
            _Log.Log.debug("PopupWindow.navigate: Setting URL in popup");

            this._id = params.id;
            if (this._id) {
                window["popupCallback_" + params.id] = this._callback.bind(this);
            }

            this._popup.focus();
            this._popup.window.location = params.url;
        }

        return this.promise;
    };

    PopupWindow.prototype._success = function _success(data) {
        _Log.Log.debug("PopupWindow.callback: Successful response from popup window");

        this._cleanup();
        this._resolve(data);
    };

    PopupWindow.prototype._error = function _error(message) {
        _Log.Log.error("PopupWindow.error: ", message);

        this._cleanup();
        this._reject(new Error(message));
    };

    PopupWindow.prototype.close = function close() {
        this._cleanup(false);
    };

    PopupWindow.prototype._cleanup = function _cleanup(keepOpen) {
        _Log.Log.debug("PopupWindow.cleanup");

        window.clearInterval(this._checkForPopupClosedTimer);
        this._checkForPopupClosedTimer = null;

        delete window["popupCallback_" + this._id];

        if (this._popup && !keepOpen) {
            this._popup.close();
        }
        this._popup = null;
    };

    PopupWindow.prototype._checkForPopupClosed = function _checkForPopupClosed() {
        if (!this._popup || this._popup.closed) {
            this._error("Popup window closed");
        }
    };

    PopupWindow.prototype._callback = function _callback(url, keepOpen) {
        this._cleanup(keepOpen);

        if (url) {
            _Log.Log.debug("PopupWindow.callback success");
            this._success({ url: url });
        } else {
            _Log.Log.debug("PopupWindow.callback: Invalid response from popup");
            this._error("Invalid response from popup");
        }
    };

    PopupWindow.notifyOpener = function notifyOpener(url, keepOpen, delimiter) {
        if (window.opener) {
            url = url || window.location.href;
            if (url) {
                var data = _UrlUtility.UrlUtility.parseUrlFragment(url, delimiter);

                if (data.state) {
                    var name = "popupCallback_" + data.state;
                    var callback = window.opener[name];
                    if (callback) {
                        _Log.Log.debug("PopupWindow.notifyOpener: passing url message to opener");
                        callback(url, keepOpen);
                    } else {
                        _Log.Log.warn("PopupWindow.notifyOpener: no matching callback found on opener");
                    }
                } else {
                    _Log.Log.warn("PopupWindow.notifyOpener: no state found in response url");
                }
            }
        } else {
            _Log.Log.warn("PopupWindow.notifyOpener: no window.opener. Can't complete notification.");
        }
    };

    _createClass(PopupWindow, [{
        key: 'promise',
        get: function get() {
            return this._promise;
        }
    }]);

    return PopupWindow;
}();

/***/ }),

/***/ "./src/RedirectNavigator.js":
/*!**********************************!*\
  !*** ./src/RedirectNavigator.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.RedirectNavigator = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var RedirectNavigator = exports.RedirectNavigator = function () {
    function RedirectNavigator() {
        _classCallCheck(this, RedirectNavigator);
    }

    RedirectNavigator.prototype.prepare = function prepare() {
        return Promise.resolve(this);
    };

    RedirectNavigator.prototype.navigate = function navigate(params) {
        if (!params || !params.url) {
            _Log.Log.error("RedirectNavigator.navigate: No url provided");
            return Promise.reject(new Error("No url provided"));
        }

        if (params.useReplaceToNavigate) {
            window.location.replace(params.url);
        } else {
            window.location = params.url;
        }

        return Promise.resolve();
    };

    _createClass(RedirectNavigator, [{
        key: "url",
        get: function get() {
            return window.location.href;
        }
    }]);

    return RedirectNavigator;
}();

/***/ }),

/***/ "./src/ResponseValidator.js":
/*!**********************************!*\
  !*** ./src/ResponseValidator.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.ResponseValidator = undefined;

var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _MetadataService = __webpack_require__(/*! ./MetadataService.js */ "./src/MetadataService.js");

var _UserInfoService = __webpack_require__(/*! ./UserInfoService.js */ "./src/UserInfoService.js");

var _TokenClient = __webpack_require__(/*! ./TokenClient.js */ "./src/TokenClient.js");

var _ErrorResponse = __webpack_require__(/*! ./ErrorResponse.js */ "./src/ErrorResponse.js");

var _JoseUtil = __webpack_require__(/*! ./JoseUtil.js */ "./src/JoseUtil.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var ProtocolClaims = ["nonce", "at_hash", "iat", "nbf", "exp", "aud", "iss", "c_hash"];

var ResponseValidator = exports.ResponseValidator = function () {
    function ResponseValidator(settings) {
        var MetadataServiceCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _MetadataService.MetadataService;
        var UserInfoServiceCtor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _UserInfoService.UserInfoService;
        var joseUtil = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _JoseUtil.JoseUtil;
        var TokenClientCtor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _TokenClient.TokenClient;

        _classCallCheck(this, ResponseValidator);

        if (!settings) {
            _Log.Log.error("ResponseValidator.ctor: No settings passed to ResponseValidator");
            throw new Error("settings");
        }

        this._settings = settings;
        this._metadataService = new MetadataServiceCtor(this._settings);
        this._userInfoService = new UserInfoServiceCtor(this._settings);
        this._joseUtil = joseUtil;
        this._tokenClient = new TokenClientCtor(this._settings);
    }

    ResponseValidator.prototype.validateSigninResponse = function validateSigninResponse(state, response) {
        var _this = this;

        _Log.Log.debug("ResponseValidator.validateSigninResponse");

        return this._processSigninParams(state, response).then(function (response) {
            _Log.Log.debug("ResponseValidator.validateSigninResponse: state processed");
            return _this._validateTokens(state, response).then(function (response) {
                _Log.Log.debug("ResponseValidator.validateSigninResponse: tokens validated");
                return _this._processClaims(state, response).then(function (response) {
                    _Log.Log.debug("ResponseValidator.validateSigninResponse: claims processed");
                    return response;
                });
            });
        });
    };

    ResponseValidator.prototype.validateSignoutResponse = function validateSignoutResponse(state, response) {
        if (state.id !== response.state) {
            _Log.Log.error("ResponseValidator.validateSignoutResponse: State does not match");
            return Promise.reject(new Error("State does not match"));
        }

        // now that we know the state matches, take the stored data
        // and set it into the response so callers can get their state
        // this is important for both success & error outcomes
        _Log.Log.debug("ResponseValidator.validateSignoutResponse: state validated");
        response.state = state.data;

        if (response.error) {
            _Log.Log.warn("ResponseValidator.validateSignoutResponse: Response was error", response.error);
            return Promise.reject(new _ErrorResponse.ErrorResponse(response));
        }

        return Promise.resolve(response);
    };

    ResponseValidator.prototype._processSigninParams = function _processSigninParams(state, response) {
        if (state.id !== response.state) {
            _Log.Log.error("ResponseValidator._processSigninParams: State does not match");
            return Promise.reject(new Error("State does not match"));
        }

        if (!state.client_id) {
            _Log.Log.error("ResponseValidator._processSigninParams: No client_id on state");
            return Promise.reject(new Error("No client_id on state"));
        }

        if (!state.authority) {
            _Log.Log.error("ResponseValidator._processSigninParams: No authority on state");
            return Promise.reject(new Error("No authority on state"));
        }

        // this allows the authority to be loaded from the signin state
        if (!this._settings.authority) {
            this._settings.authority = state.authority;
        }
        // ensure we're using the correct authority if the authority is not loaded from signin state
        else if (this._settings.authority && this._settings.authority !== state.authority) {
                _Log.Log.error("ResponseValidator._processSigninParams: authority mismatch on settings vs. signin state");
                return Promise.reject(new Error("authority mismatch on settings vs. signin state"));
            }
        // this allows the client_id to be loaded from the signin state
        if (!this._settings.client_id) {
            this._settings.client_id = state.client_id;
        }
        // ensure we're using the correct client_id if the client_id is not loaded from signin state
        else if (this._settings.client_id && this._settings.client_id !== state.client_id) {
                _Log.Log.error("ResponseValidator._processSigninParams: client_id mismatch on settings vs. signin state");
                return Promise.reject(new Error("client_id mismatch on settings vs. signin state"));
            }

        // now that we know the state matches, take the stored data
        // and set it into the response so callers can get their state
        // this is important for both success & error outcomes
        _Log.Log.debug("ResponseValidator._processSigninParams: state validated");
        response.state = state.data;

        if (response.error) {
            _Log.Log.warn("ResponseValidator._processSigninParams: Response was error", response.error);
            return Promise.reject(new _ErrorResponse.ErrorResponse(response));
        }

        if (state.nonce && !response.id_token) {
            _Log.Log.error("ResponseValidator._processSigninParams: Expecting id_token in response");
            return Promise.reject(new Error("No id_token in response"));
        }

        if (!state.nonce && response.id_token) {
            _Log.Log.error("ResponseValidator._processSigninParams: Not expecting id_token in response");
            return Promise.reject(new Error("Unexpected id_token in response"));
        }

        if (state.code_verifier && !response.code) {
            _Log.Log.error("ResponseValidator._processSigninParams: Expecting code in response");
            return Promise.reject(new Error("No code in response"));
        }

        if (!state.code_verifier && response.code) {
            _Log.Log.error("ResponseValidator._processSigninParams: Not expecting code in response");
            return Promise.reject(new Error("Unexpected code in response"));
        }

        if (!response.scope) {
            // if there's no scope on the response, then assume all scopes granted (per-spec) and copy over scopes from original request
            response.scope = state.scope;
        }

        return Promise.resolve(response);
    };

    ResponseValidator.prototype._processClaims = function _processClaims(state, response) {
        var _this2 = this;

        if (response.isOpenIdConnect) {
            _Log.Log.debug("ResponseValidator._processClaims: response is OIDC, processing claims");

            response.profile = this._filterProtocolClaims(response.profile);

            if (state.skipUserInfo !== true && this._settings.loadUserInfo && response.access_token) {
                _Log.Log.debug("ResponseValidator._processClaims: loading user info");

                return this._userInfoService.getClaims(response.access_token).then(function (claims) {
                    _Log.Log.debug("ResponseValidator._processClaims: user info claims received from user info endpoint");

                    if (claims.sub !== response.profile.sub) {
                        _Log.Log.error("ResponseValidator._processClaims: sub from user info endpoint does not match sub in access_token");
                        return Promise.reject(new Error("sub from user info endpoint does not match sub in access_token"));
                    }

                    response.profile = _this2._mergeClaims(response.profile, claims);
                    _Log.Log.debug("ResponseValidator._processClaims: user info claims received, updated profile:", response.profile);

                    return response;
                });
            } else {
                _Log.Log.debug("ResponseValidator._processClaims: not loading user info");
            }
        } else {
            _Log.Log.debug("ResponseValidator._processClaims: response is not OIDC, not processing claims");
        }

        return Promise.resolve(response);
    };

    ResponseValidator.prototype._mergeClaims = function _mergeClaims(claims1, claims2) {
        var result = Object.assign({}, claims1);

        for (var name in claims2) {
            var values = claims2[name];
            if (!Array.isArray(values)) {
                values = [values];
            }

            for (var i = 0; i < values.length; i++) {
                var value = values[i];
                if (!result[name]) {
                    result[name] = value;
                } else if (Array.isArray(result[name])) {
                    if (result[name].indexOf(value) < 0) {
                        result[name].push(value);
                    }
                } else if (result[name] !== value) {
                    if ((typeof value === 'undefined' ? 'undefined' : _typeof(value)) === 'object') {
                        result[name] = this._mergeClaims(result[name], value);
                    } else {
                        result[name] = [result[name], value];
                    }
                }
            }
        }

        return result;
    };

    ResponseValidator.prototype._filterProtocolClaims = function _filterProtocolClaims(claims) {
        _Log.Log.debug("ResponseValidator._filterProtocolClaims, incoming claims:", claims);

        var result = Object.assign({}, claims);

        if (this._settings._filterProtocolClaims) {
            ProtocolClaims.forEach(function (type) {
                delete result[type];
            });

            _Log.Log.debug("ResponseValidator._filterProtocolClaims: protocol claims filtered", result);
        } else {
            _Log.Log.debug("ResponseValidator._filterProtocolClaims: protocol claims not filtered");
        }

        return result;
    };

    ResponseValidator.prototype._validateTokens = function _validateTokens(state, response) {
        if (response.code) {
            _Log.Log.debug("ResponseValidator._validateTokens: Validating code");
            return this._processCode(state, response);
        }

        if (response.id_token) {
            if (response.access_token) {
                _Log.Log.debug("ResponseValidator._validateTokens: Validating id_token and access_token");
                return this._validateIdTokenAndAccessToken(state, response);
            }

            _Log.Log.debug("ResponseValidator._validateTokens: Validating id_token");
            return this._validateIdToken(state, response);
        }

        _Log.Log.debug("ResponseValidator._validateTokens: No code to process or id_token to validate");
        return Promise.resolve(response);
    };

    ResponseValidator.prototype._processCode = function _processCode(state, response) {
        var _this3 = this;

        var request = {
            client_id: state.client_id,
            client_secret: state.client_secret,
            code: response.code,
            redirect_uri: state.redirect_uri,
            code_verifier: state.code_verifier
        };

        if (state.extraTokenParams && _typeof(state.extraTokenParams) === 'object') {
            Object.assign(request, state.extraTokenParams);
        }

        return this._tokenClient.exchangeCode(request).then(function (tokenResponse) {

            for (var key in tokenResponse) {
                response[key] = tokenResponse[key];
            }

            if (response.id_token) {
                _Log.Log.debug("ResponseValidator._processCode: token response successful, processing id_token");
                return _this3._validateIdTokenAttributes(state, response);
            } else {
                _Log.Log.debug("ResponseValidator._processCode: token response successful, returning response");
            }

            return response;
        });
    };

    ResponseValidator.prototype._validateIdTokenAttributes = function _validateIdTokenAttributes(state, response) {
        var _this4 = this;

        return this._metadataService.getIssuer().then(function (issuer) {

            var audience = state.client_id;
            var clockSkewInSeconds = _this4._settings.clockSkew;
            _Log.Log.debug("ResponseValidator._validateIdTokenAttributes: Validaing JWT attributes; using clock skew (in seconds) of: ", clockSkewInSeconds);

            return _this4._joseUtil.validateJwtAttributes(response.id_token, issuer, audience, clockSkewInSeconds).then(function (payload) {

                if (state.nonce && state.nonce !== payload.nonce) {
                    _Log.Log.error("ResponseValidator._validateIdTokenAttributes: Invalid nonce in id_token");
                    return Promise.reject(new Error("Invalid nonce in id_token"));
                }

                if (!payload.sub) {
                    _Log.Log.error("ResponseValidator._validateIdTokenAttributes: No sub present in id_token");
                    return Promise.reject(new Error("No sub present in id_token"));
                }

                response.profile = payload;
                return response;
            });
        });
    };

    ResponseValidator.prototype._validateIdTokenAndAccessToken = function _validateIdTokenAndAccessToken(state, response) {
        var _this5 = this;

        return this._validateIdToken(state, response).then(function (response) {
            return _this5._validateAccessToken(response);
        });
    };

    ResponseValidator.prototype._validateIdToken = function _validateIdToken(state, response) {
        var _this6 = this;

        if (!state.nonce) {
            _Log.Log.error("ResponseValidator._validateIdToken: No nonce on state");
            return Promise.reject(new Error("No nonce on state"));
        }

        var jwt = this._joseUtil.parseJwt(response.id_token);
        if (!jwt || !jwt.header || !jwt.payload) {
            _Log.Log.error("ResponseValidator._validateIdToken: Failed to parse id_token", jwt);
            return Promise.reject(new Error("Failed to parse id_token"));
        }

        if (state.nonce !== jwt.payload.nonce) {
            _Log.Log.error("ResponseValidator._validateIdToken: Invalid nonce in id_token");
            return Promise.reject(new Error("Invalid nonce in id_token"));
        }

        var kid = jwt.header.kid;

        return this._metadataService.getIssuer().then(function (issuer) {
            _Log.Log.debug("ResponseValidator._validateIdToken: Received issuer");

            return _this6._metadataService.getSigningKeys().then(function (keys) {
                if (!keys) {
                    _Log.Log.error("ResponseValidator._validateIdToken: No signing keys from metadata");
                    return Promise.reject(new Error("No signing keys from metadata"));
                }

                _Log.Log.debug("ResponseValidator._validateIdToken: Received signing keys");
                var key = void 0;
                if (!kid) {
                    keys = _this6._filterByAlg(keys, jwt.header.alg);

                    if (keys.length > 1) {
                        _Log.Log.error("ResponseValidator._validateIdToken: No kid found in id_token and more than one key found in metadata");
                        return Promise.reject(new Error("No kid found in id_token and more than one key found in metadata"));
                    } else {
                        // kid is mandatory only when there are multiple keys in the referenced JWK Set document
                        // see http://openid.net/specs/openid-connect-core-1_0.html#Signing
                        key = keys[0];
                    }
                } else {
                    key = keys.filter(function (key) {
                        return key.kid === kid;
                    })[0];
                }

                if (!key) {
                    _Log.Log.error("ResponseValidator._validateIdToken: No key matching kid or alg found in signing keys");
                    return Promise.reject(new Error("No key matching kid or alg found in signing keys"));
                }

                var audience = state.client_id;

                var clockSkewInSeconds = _this6._settings.clockSkew;
                _Log.Log.debug("ResponseValidator._validateIdToken: Validaing JWT; using clock skew (in seconds) of: ", clockSkewInSeconds);

                return _this6._joseUtil.validateJwt(response.id_token, key, issuer, audience, clockSkewInSeconds).then(function () {
                    _Log.Log.debug("ResponseValidator._validateIdToken: JWT validation successful");

                    if (!jwt.payload.sub) {
                        _Log.Log.error("ResponseValidator._validateIdToken: No sub present in id_token");
                        return Promise.reject(new Error("No sub present in id_token"));
                    }

                    response.profile = jwt.payload;

                    return response;
                });
            });
        });
    };

    ResponseValidator.prototype._filterByAlg = function _filterByAlg(keys, alg) {
        var kty = null;
        if (alg.startsWith("RS")) {
            kty = "RSA";
        } else if (alg.startsWith("PS")) {
            kty = "PS";
        } else if (alg.startsWith("ES")) {
            kty = "EC";
        } else {
            _Log.Log.debug("ResponseValidator._filterByAlg: alg not supported: ", alg);
            return [];
        }

        _Log.Log.debug("ResponseValidator._filterByAlg: Looking for keys that match kty: ", kty);

        keys = keys.filter(function (key) {
            return key.kty === kty;
        });

        _Log.Log.debug("ResponseValidator._filterByAlg: Number of keys that match kty: ", kty, keys.length);

        return keys;
    };

    ResponseValidator.prototype._validateAccessToken = function _validateAccessToken(response) {
        if (!response.profile) {
            _Log.Log.error("ResponseValidator._validateAccessToken: No profile loaded from id_token");
            return Promise.reject(new Error("No profile loaded from id_token"));
        }

        if (!response.profile.at_hash) {
            _Log.Log.error("ResponseValidator._validateAccessToken: No at_hash in id_token");
            return Promise.reject(new Error("No at_hash in id_token"));
        }

        if (!response.id_token) {
            _Log.Log.error("ResponseValidator._validateAccessToken: No id_token");
            return Promise.reject(new Error("No id_token"));
        }

        var jwt = this._joseUtil.parseJwt(response.id_token);
        if (!jwt || !jwt.header) {
            _Log.Log.error("ResponseValidator._validateAccessToken: Failed to parse id_token", jwt);
            return Promise.reject(new Error("Failed to parse id_token"));
        }

        var hashAlg = jwt.header.alg;
        if (!hashAlg || hashAlg.length !== 5) {
            _Log.Log.error("ResponseValidator._validateAccessToken: Unsupported alg:", hashAlg);
            return Promise.reject(new Error("Unsupported alg: " + hashAlg));
        }

        var hashBits = hashAlg.substr(2, 3);
        if (!hashBits) {
            _Log.Log.error("ResponseValidator._validateAccessToken: Unsupported alg:", hashAlg, hashBits);
            return Promise.reject(new Error("Unsupported alg: " + hashAlg));
        }

        hashBits = parseInt(hashBits);
        if (hashBits !== 256 && hashBits !== 384 && hashBits !== 512) {
            _Log.Log.error("ResponseValidator._validateAccessToken: Unsupported alg:", hashAlg, hashBits);
            return Promise.reject(new Error("Unsupported alg: " + hashAlg));
        }

        var sha = "sha" + hashBits;
        var hash = this._joseUtil.hashString(response.access_token, sha);
        if (!hash) {
            _Log.Log.error("ResponseValidator._validateAccessToken: access_token hash failed:", sha);
            return Promise.reject(new Error("Failed to validate at_hash"));
        }

        var left = hash.substr(0, hash.length / 2);
        var left_b64u = this._joseUtil.hexToBase64Url(left);
        if (left_b64u !== response.profile.at_hash) {
            _Log.Log.error("ResponseValidator._validateAccessToken: Failed to validate at_hash", left_b64u, response.profile.at_hash);
            return Promise.reject(new Error("Failed to validate at_hash"));
        }

        _Log.Log.debug("ResponseValidator._validateAccessToken: success");

        return Promise.resolve(response);
    };

    return ResponseValidator;
}();

/***/ }),

/***/ "./src/SessionMonitor.js":
/*!*******************************!*\
  !*** ./src/SessionMonitor.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SessionMonitor = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _CheckSessionIFrame = __webpack_require__(/*! ./CheckSessionIFrame.js */ "./src/CheckSessionIFrame.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var SessionMonitor = exports.SessionMonitor = function () {
    function SessionMonitor(userManager) {
        var _this = this;

        var CheckSessionIFrameCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _CheckSessionIFrame.CheckSessionIFrame;
        var timer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _Global.Global.timer;

        _classCallCheck(this, SessionMonitor);

        if (!userManager) {
            _Log.Log.error("SessionMonitor.ctor: No user manager passed to SessionMonitor");
            throw new Error("userManager");
        }

        this._userManager = userManager;
        this._CheckSessionIFrameCtor = CheckSessionIFrameCtor;
        this._timer = timer;

        this._userManager.events.addUserLoaded(this._start.bind(this));
        this._userManager.events.addUserUnloaded(this._stop.bind(this));

        this._userManager.getUser().then(function (user) {
            // doing this manually here since calling getUser 
            // doesn't trigger load event.
            if (user) {
                _this._start(user);
            } else if (_this._settings.monitorAnonymousSession) {
                _this._userManager.querySessionStatus().then(function (session) {
                    var tmpUser = {
                        session_state: session.session_state
                    };
                    if (session.sub && session.sid) {
                        tmpUser.profile = {
                            sub: session.sub,
                            sid: session.sid
                        };
                    }
                    _this._start(tmpUser);
                }).catch(function (err) {
                    // catch to suppress errors since we're in a ctor
                    _Log.Log.error("SessionMonitor ctor: error from querySessionStatus:", err.message);
                });
            }
        }).catch(function (err) {
            // catch to suppress errors since we're in a ctor
            _Log.Log.error("SessionMonitor ctor: error from getUser:", err.message);
        });
    }

    SessionMonitor.prototype._start = function _start(user) {
        var _this2 = this;

        var session_state = user.session_state;

        if (session_state) {
            if (user.profile) {
                this._sub = user.profile.sub;
                this._sid = user.profile.sid;
                _Log.Log.debug("SessionMonitor._start: session_state:", session_state, ", sub:", this._sub);
            } else {
                this._sub = undefined;
                this._sid = undefined;
                _Log.Log.debug("SessionMonitor._start: session_state:", session_state, ", anonymous user");
            }

            if (!this._checkSessionIFrame) {
                this._metadataService.getCheckSessionIframe().then(function (url) {
                    if (url) {
                        _Log.Log.debug("SessionMonitor._start: Initializing check session iframe");

                        var client_id = _this2._client_id;
                        var interval = _this2._checkSessionInterval;
                        var stopOnError = _this2._stopCheckSessionOnError;

                        _this2._checkSessionIFrame = new _this2._CheckSessionIFrameCtor(_this2._callback.bind(_this2), client_id, url, interval, stopOnError);
                        _this2._checkSessionIFrame.load().then(function () {
                            _this2._checkSessionIFrame.start(session_state);
                        });
                    } else {
                        _Log.Log.warn("SessionMonitor._start: No check session iframe found in the metadata");
                    }
                }).catch(function (err) {
                    // catch to suppress errors since we're in non-promise callback
                    _Log.Log.error("SessionMonitor._start: Error from getCheckSessionIframe:", err.message);
                });
            } else {
                this._checkSessionIFrame.start(session_state);
            }
        }
    };

    SessionMonitor.prototype._stop = function _stop() {
        var _this3 = this;

        this._sub = undefined;
        this._sid = undefined;

        if (this._checkSessionIFrame) {
            _Log.Log.debug("SessionMonitor._stop");
            this._checkSessionIFrame.stop();
        }

        if (this._settings.monitorAnonymousSession) {
            // using a timer to delay re-initialization to avoid race conditions during signout
            var timerHandle = this._timer.setInterval(function () {
                _this3._timer.clearInterval(timerHandle);

                _this3._userManager.querySessionStatus().then(function (session) {
                    var tmpUser = {
                        session_state: session.session_state
                    };
                    if (session.sub && session.sid) {
                        tmpUser.profile = {
                            sub: session.sub,
                            sid: session.sid
                        };
                    }
                    _this3._start(tmpUser);
                }).catch(function (err) {
                    // catch to suppress errors since we're in a callback
                    _Log.Log.error("SessionMonitor: error from querySessionStatus:", err.message);
                });
            }, 1000);
        }
    };

    SessionMonitor.prototype._callback = function _callback() {
        var _this4 = this;

        this._userManager.querySessionStatus().then(function (session) {
            var raiseEvent = true;

            if (session) {
                if (session.sub === _this4._sub) {
                    raiseEvent = false;
                    _this4._checkSessionIFrame.start(session.session_state);

                    if (session.sid === _this4._sid) {
                        _Log.Log.debug("SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:", session.session_state);
                    } else {
                        _Log.Log.debug("SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:", session.session_state);
                        _this4._userManager.events._raiseUserSessionChanged();
                    }
                } else {
                    _Log.Log.debug("SessionMonitor._callback: Different subject signed into OP:", session.sub);
                }
            } else {
                _Log.Log.debug("SessionMonitor._callback: Subject no longer signed into OP");
            }

            if (raiseEvent) {
                if (_this4._sub) {
                    _Log.Log.debug("SessionMonitor._callback: SessionMonitor._callback; raising signed out event");
                    _this4._userManager.events._raiseUserSignedOut();
                } else {
                    _Log.Log.debug("SessionMonitor._callback: SessionMonitor._callback; raising signed in event");
                    _this4._userManager.events._raiseUserSignedIn();
                }
            }
        }).catch(function (err) {
            if (_this4._sub) {
                _Log.Log.debug("SessionMonitor._callback: Error calling queryCurrentSigninSession; raising signed out event", err.message);
                _this4._userManager.events._raiseUserSignedOut();
            }
        });
    };

    _createClass(SessionMonitor, [{
        key: '_settings',
        get: function get() {
            return this._userManager.settings;
        }
    }, {
        key: '_metadataService',
        get: function get() {
            return this._userManager.metadataService;
        }
    }, {
        key: '_client_id',
        get: function get() {
            return this._settings.client_id;
        }
    }, {
        key: '_checkSessionInterval',
        get: function get() {
            return this._settings.checkSessionInterval;
        }
    }, {
        key: '_stopCheckSessionOnError',
        get: function get() {
            return this._settings.stopCheckSessionOnError;
        }
    }]);

    return SessionMonitor;
}();

/***/ }),

/***/ "./src/SigninRequest.js":
/*!******************************!*\
  !*** ./src/SigninRequest.js ***!
  \******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SigninRequest = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _UrlUtility = __webpack_require__(/*! ./UrlUtility.js */ "./src/UrlUtility.js");

var _SigninState = __webpack_require__(/*! ./SigninState.js */ "./src/SigninState.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var SigninRequest = exports.SigninRequest = function () {
    function SigninRequest(_ref) {
        var url = _ref.url,
            client_id = _ref.client_id,
            redirect_uri = _ref.redirect_uri,
            response_type = _ref.response_type,
            scope = _ref.scope,
            authority = _ref.authority,
            data = _ref.data,
            prompt = _ref.prompt,
            display = _ref.display,
            max_age = _ref.max_age,
            ui_locales = _ref.ui_locales,
            id_token_hint = _ref.id_token_hint,
            login_hint = _ref.login_hint,
            acr_values = _ref.acr_values,
            resource = _ref.resource,
            response_mode = _ref.response_mode,
            request = _ref.request,
            request_uri = _ref.request_uri,
            extraQueryParams = _ref.extraQueryParams,
            request_type = _ref.request_type,
            client_secret = _ref.client_secret,
            extraTokenParams = _ref.extraTokenParams,
            skipUserInfo = _ref.skipUserInfo;

        _classCallCheck(this, SigninRequest);

        if (!url) {
            _Log.Log.error("SigninRequest.ctor: No url passed");
            throw new Error("url");
        }
        if (!client_id) {
            _Log.Log.error("SigninRequest.ctor: No client_id passed");
            throw new Error("client_id");
        }
        if (!redirect_uri) {
            _Log.Log.error("SigninRequest.ctor: No redirect_uri passed");
            throw new Error("redirect_uri");
        }
        if (!response_type) {
            _Log.Log.error("SigninRequest.ctor: No response_type passed");
            throw new Error("response_type");
        }
        if (!scope) {
            _Log.Log.error("SigninRequest.ctor: No scope passed");
            throw new Error("scope");
        }
        if (!authority) {
            _Log.Log.error("SigninRequest.ctor: No authority passed");
            throw new Error("authority");
        }

        var oidc = SigninRequest.isOidc(response_type);
        var code = SigninRequest.isCode(response_type);

        if (!response_mode) {
            response_mode = SigninRequest.isCode(response_type) ? "query" : null;
        }

        this.state = new _SigninState.SigninState({ nonce: oidc,
            data: data, client_id: client_id, authority: authority, redirect_uri: redirect_uri,
            code_verifier: code,
            request_type: request_type, response_mode: response_mode,
            client_secret: client_secret, scope: scope, extraTokenParams: extraTokenParams, skipUserInfo: skipUserInfo });

        url = _UrlUtility.UrlUtility.addQueryParam(url, "client_id", client_id);
        url = _UrlUtility.UrlUtility.addQueryParam(url, "redirect_uri", redirect_uri);
        url = _UrlUtility.UrlUtility.addQueryParam(url, "response_type", response_type);
        url = _UrlUtility.UrlUtility.addQueryParam(url, "scope", scope);

        url = _UrlUtility.UrlUtility.addQueryParam(url, "state", this.state.id);
        if (oidc) {
            url = _UrlUtility.UrlUtility.addQueryParam(url, "nonce", this.state.nonce);
        }
        if (code) {
            url = _UrlUtility.UrlUtility.addQueryParam(url, "code_challenge", this.state.code_challenge);
            url = _UrlUtility.UrlUtility.addQueryParam(url, "code_challenge_method", "S256");
        }

        var optional = { prompt: prompt, display: display, max_age: max_age, ui_locales: ui_locales, id_token_hint: id_token_hint, login_hint: login_hint, acr_values: acr_values, resource: resource, request: request, request_uri: request_uri, response_mode: response_mode };
        for (var key in optional) {
            if (optional[key]) {
                url = _UrlUtility.UrlUtility.addQueryParam(url, key, optional[key]);
            }
        }

        for (var _key in extraQueryParams) {
            url = _UrlUtility.UrlUtility.addQueryParam(url, _key, extraQueryParams[_key]);
        }

        this.url = url;
    }

    SigninRequest.isOidc = function isOidc(response_type) {
        var result = response_type.split(/\s+/g).filter(function (item) {
            return item === "id_token";
        });
        return !!result[0];
    };

    SigninRequest.isOAuth = function isOAuth(response_type) {
        var result = response_type.split(/\s+/g).filter(function (item) {
            return item === "token";
        });
        return !!result[0];
    };

    SigninRequest.isCode = function isCode(response_type) {
        var result = response_type.split(/\s+/g).filter(function (item) {
            return item === "code";
        });
        return !!result[0];
    };

    return SigninRequest;
}();

/***/ }),

/***/ "./src/SigninResponse.js":
/*!*******************************!*\
  !*** ./src/SigninResponse.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SigninResponse = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _UrlUtility = __webpack_require__(/*! ./UrlUtility.js */ "./src/UrlUtility.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var OidcScope = "openid";

var SigninResponse = exports.SigninResponse = function () {
    function SigninResponse(url) {
        var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "#";

        _classCallCheck(this, SigninResponse);

        var values = _UrlUtility.UrlUtility.parseUrlFragment(url, delimiter);

        this.error = values.error;
        this.error_description = values.error_description;
        this.error_uri = values.error_uri;

        this.code = values.code;
        this.state = values.state;
        this.id_token = values.id_token;
        this.session_state = values.session_state;
        this.access_token = values.access_token;
        this.token_type = values.token_type;
        this.scope = values.scope;
        this.profile = undefined; // will be set from ResponseValidator

        this.expires_in = values.expires_in;
    }

    _createClass(SigninResponse, [{
        key: "expires_in",
        get: function get() {
            if (this.expires_at) {
                var now = parseInt(Date.now() / 1000);
                return this.expires_at - now;
            }
            return undefined;
        },
        set: function set(value) {
            var expires_in = parseInt(value);
            if (typeof expires_in === 'number' && expires_in > 0) {
                var now = parseInt(Date.now() / 1000);
                this.expires_at = now + expires_in;
            }
        }
    }, {
        key: "expired",
        get: function get() {
            var expires_in = this.expires_in;
            if (expires_in !== undefined) {
                return expires_in <= 0;
            }
            return undefined;
        }
    }, {
        key: "scopes",
        get: function get() {
            return (this.scope || "").split(" ");
        }
    }, {
        key: "isOpenIdConnect",
        get: function get() {
            return this.scopes.indexOf(OidcScope) >= 0 || !!this.id_token;
        }
    }]);

    return SigninResponse;
}();

/***/ }),

/***/ "./src/SigninState.js":
/*!****************************!*\
  !*** ./src/SigninState.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SigninState = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _State2 = __webpack_require__(/*! ./State.js */ "./src/State.js");

var _JoseUtil = __webpack_require__(/*! ./JoseUtil.js */ "./src/JoseUtil.js");

var _random = __webpack_require__(/*! ./random.js */ "./src/random.js");

var _random2 = _interopRequireDefault(_random);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var SigninState = exports.SigninState = function (_State) {
    _inherits(SigninState, _State);

    function SigninState() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            nonce = _ref.nonce,
            authority = _ref.authority,
            client_id = _ref.client_id,
            redirect_uri = _ref.redirect_uri,
            code_verifier = _ref.code_verifier,
            response_mode = _ref.response_mode,
            client_secret = _ref.client_secret,
            scope = _ref.scope,
            extraTokenParams = _ref.extraTokenParams,
            skipUserInfo = _ref.skipUserInfo;

        _classCallCheck(this, SigninState);

        var _this = _possibleConstructorReturn(this, _State.call(this, arguments[0]));

        if (nonce === true) {
            _this._nonce = (0, _random2.default)();
        } else if (nonce) {
            _this._nonce = nonce;
        }

        if (code_verifier === true) {
            // random() produces 32 length
            _this._code_verifier = (0, _random2.default)() + (0, _random2.default)() + (0, _random2.default)();
        } else if (code_verifier) {
            _this._code_verifier = code_verifier;
        }

        if (_this.code_verifier) {
            var hash = _JoseUtil.JoseUtil.hashString(_this.code_verifier, "SHA256");
            _this._code_challenge = _JoseUtil.JoseUtil.hexToBase64Url(hash);
        }

        _this._redirect_uri = redirect_uri;
        _this._authority = authority;
        _this._client_id = client_id;
        _this._response_mode = response_mode;
        _this._client_secret = client_secret;
        _this._scope = scope;
        _this._extraTokenParams = extraTokenParams;
        _this._skipUserInfo = skipUserInfo;
        return _this;
    }

    SigninState.prototype.toStorageString = function toStorageString() {
        _Log.Log.debug("SigninState.toStorageString");
        return JSON.stringify({
            id: this.id,
            data: this.data,
            created: this.created,
            request_type: this.request_type,
            nonce: this.nonce,
            code_verifier: this.code_verifier,
            redirect_uri: this.redirect_uri,
            authority: this.authority,
            client_id: this.client_id,
            response_mode: this.response_mode,
            client_secret: this.client_secret,
            scope: this.scope,
            extraTokenParams: this.extraTokenParams,
            skipUserInfo: this.skipUserInfo
        });
    };

    SigninState.fromStorageString = function fromStorageString(storageString) {
        _Log.Log.debug("SigninState.fromStorageString");
        var data = JSON.parse(storageString);
        return new SigninState(data);
    };

    _createClass(SigninState, [{
        key: 'nonce',
        get: function get() {
            return this._nonce;
        }
    }, {
        key: 'authority',
        get: function get() {
            return this._authority;
        }
    }, {
        key: 'client_id',
        get: function get() {
            return this._client_id;
        }
    }, {
        key: 'redirect_uri',
        get: function get() {
            return this._redirect_uri;
        }
    }, {
        key: 'code_verifier',
        get: function get() {
            return this._code_verifier;
        }
    }, {
        key: 'code_challenge',
        get: function get() {
            return this._code_challenge;
        }
    }, {
        key: 'response_mode',
        get: function get() {
            return this._response_mode;
        }
    }, {
        key: 'client_secret',
        get: function get() {
            return this._client_secret;
        }
    }, {
        key: 'scope',
        get: function get() {
            return this._scope;
        }
    }, {
        key: 'extraTokenParams',
        get: function get() {
            return this._extraTokenParams;
        }
    }, {
        key: 'skipUserInfo',
        get: function get() {
            return this._skipUserInfo;
        }
    }]);

    return SigninState;
}(_State2.State);

/***/ }),

/***/ "./src/SignoutRequest.js":
/*!*******************************!*\
  !*** ./src/SignoutRequest.js ***!
  \*******************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SignoutRequest = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _UrlUtility = __webpack_require__(/*! ./UrlUtility.js */ "./src/UrlUtility.js");

var _State = __webpack_require__(/*! ./State.js */ "./src/State.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var SignoutRequest = exports.SignoutRequest = function SignoutRequest(_ref) {
    var url = _ref.url,
        id_token_hint = _ref.id_token_hint,
        post_logout_redirect_uri = _ref.post_logout_redirect_uri,
        data = _ref.data,
        extraQueryParams = _ref.extraQueryParams,
        request_type = _ref.request_type;

    _classCallCheck(this, SignoutRequest);

    if (!url) {
        _Log.Log.error("SignoutRequest.ctor: No url passed");
        throw new Error("url");
    }

    if (id_token_hint) {
        url = _UrlUtility.UrlUtility.addQueryParam(url, "id_token_hint", id_token_hint);
    }

    if (post_logout_redirect_uri) {
        url = _UrlUtility.UrlUtility.addQueryParam(url, "post_logout_redirect_uri", post_logout_redirect_uri);

        if (data) {
            this.state = new _State.State({ data: data, request_type: request_type });

            url = _UrlUtility.UrlUtility.addQueryParam(url, "state", this.state.id);
        }
    }

    for (var key in extraQueryParams) {
        url = _UrlUtility.UrlUtility.addQueryParam(url, key, extraQueryParams[key]);
    }

    this.url = url;
};

/***/ }),

/***/ "./src/SignoutResponse.js":
/*!********************************!*\
  !*** ./src/SignoutResponse.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
        value: true
});
exports.SignoutResponse = undefined;

var _UrlUtility = __webpack_require__(/*! ./UrlUtility.js */ "./src/UrlUtility.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var SignoutResponse = exports.SignoutResponse = function SignoutResponse(url) {
        _classCallCheck(this, SignoutResponse);

        var values = _UrlUtility.UrlUtility.parseUrlFragment(url, "?");

        this.error = values.error;
        this.error_description = values.error_description;
        this.error_uri = values.error_uri;

        this.state = values.state;
};

/***/ }),

/***/ "./src/SilentRenewService.js":
/*!***********************************!*\
  !*** ./src/SilentRenewService.js ***!
  \***********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.SilentRenewService = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var SilentRenewService = exports.SilentRenewService = function () {
    function SilentRenewService(userManager) {
        _classCallCheck(this, SilentRenewService);

        this._userManager = userManager;
    }

    SilentRenewService.prototype.start = function start() {
        if (!this._callback) {
            this._callback = this._tokenExpiring.bind(this);
            this._userManager.events.addAccessTokenExpiring(this._callback);

            // this will trigger loading of the user so the expiring events can be initialized
            this._userManager.getUser().then(function (user) {
                // deliberate nop
            }).catch(function (err) {
                // catch to suppress errors since we're in a ctor
                _Log.Log.error("SilentRenewService.start: Error from getUser:", err.message);
            });
        }
    };

    SilentRenewService.prototype.stop = function stop() {
        if (this._callback) {
            this._userManager.events.removeAccessTokenExpiring(this._callback);
            delete this._callback;
        }
    };

    SilentRenewService.prototype._tokenExpiring = function _tokenExpiring() {
        var _this = this;

        this._userManager.signinSilent().then(function (user) {
            _Log.Log.debug("SilentRenewService._tokenExpiring: Silent token renewal successful");
        }, function (err) {
            _Log.Log.error("SilentRenewService._tokenExpiring: Error from signinSilent:", err.message);
            _this._userManager.events._raiseSilentRenewError(err);
        });
    };

    return SilentRenewService;
}();

/***/ }),

/***/ "./src/State.js":
/*!**********************!*\
  !*** ./src/State.js ***!
  \**********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.State = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _random = __webpack_require__(/*! ./random.js */ "./src/random.js");

var _random2 = _interopRequireDefault(_random);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var State = exports.State = function () {
    function State() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            id = _ref.id,
            data = _ref.data,
            created = _ref.created,
            request_type = _ref.request_type;

        _classCallCheck(this, State);

        this._id = id || (0, _random2.default)();
        this._data = data;

        if (typeof created === 'number' && created > 0) {
            this._created = created;
        } else {
            this._created = parseInt(Date.now() / 1000);
        }
        this._request_type = request_type;
    }

    State.prototype.toStorageString = function toStorageString() {
        _Log.Log.debug("State.toStorageString");
        return JSON.stringify({
            id: this.id,
            data: this.data,
            created: this.created,
            request_type: this.request_type
        });
    };

    State.fromStorageString = function fromStorageString(storageString) {
        _Log.Log.debug("State.fromStorageString");
        return new State(JSON.parse(storageString));
    };

    State.clearStaleState = function clearStaleState(storage, age) {

        var cutoff = Date.now() / 1000 - age;

        return storage.getAllKeys().then(function (keys) {
            _Log.Log.debug("State.clearStaleState: got keys", keys);

            var promises = [];

            var _loop = function _loop(i) {
                var key = keys[i];
                p = storage.get(key).then(function (item) {
                    var remove = false;

                    if (item) {
                        try {
                            var state = State.fromStorageString(item);

                            _Log.Log.debug("State.clearStaleState: got item from key: ", key, state.created);

                            if (state.created <= cutoff) {
                                remove = true;
                            }
                        } catch (e) {
                            _Log.Log.error("State.clearStaleState: Error parsing state for key", key, e.message);
                            remove = true;
                        }
                    } else {
                        _Log.Log.debug("State.clearStaleState: no item in storage for key: ", key);
                        remove = true;
                    }

                    if (remove) {
                        _Log.Log.debug("State.clearStaleState: removed item for key: ", key);
                        return storage.remove(key);
                    }
                });


                promises.push(p);
            };

            for (var i = 0; i < keys.length; i++) {
                var p;

                _loop(i);
            }

            _Log.Log.debug("State.clearStaleState: waiting on promise count:", promises.length);
            return Promise.all(promises);
        });
    };

    _createClass(State, [{
        key: 'id',
        get: function get() {
            return this._id;
        }
    }, {
        key: 'data',
        get: function get() {
            return this._data;
        }
    }, {
        key: 'created',
        get: function get() {
            return this._created;
        }
    }, {
        key: 'request_type',
        get: function get() {
            return this._request_type;
        }
    }]);

    return State;
}();

/***/ }),

/***/ "./src/Timer.js":
/*!**********************!*\
  !*** ./src/Timer.js ***!
  \**********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.Timer = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

var _Event2 = __webpack_require__(/*! ./Event.js */ "./src/Event.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var TimerDuration = 5; // seconds

var Timer = exports.Timer = function (_Event) {
    _inherits(Timer, _Event);

    function Timer(name) {
        var timer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Global.Global.timer;
        var nowFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : undefined;

        _classCallCheck(this, Timer);

        var _this = _possibleConstructorReturn(this, _Event.call(this, name));

        _this._timer = timer;

        if (nowFunc) {
            _this._nowFunc = nowFunc;
        } else {
            _this._nowFunc = function () {
                return Date.now() / 1000;
            };
        }
        return _this;
    }

    Timer.prototype.init = function init(duration) {
        if (duration <= 0) {
            duration = 1;
        }
        duration = parseInt(duration);

        var expiration = this.now + duration;
        if (this.expiration === expiration && this._timerHandle) {
            // no need to reinitialize to same expiration, so bail out
            _Log.Log.debug("Timer.init timer " + this._name + " skipping initialization since already initialized for expiration:", this.expiration);
            return;
        }

        this.cancel();

        _Log.Log.debug("Timer.init timer " + this._name + " for duration:", duration);
        this._expiration = expiration;

        // we're using a fairly short timer and then checking the expiration in the
        // callback to handle scenarios where the browser device sleeps, and then
        // the timers end up getting delayed.
        var timerDuration = TimerDuration;
        if (duration < timerDuration) {
            timerDuration = duration;
        }
        this._timerHandle = this._timer.setInterval(this._callback.bind(this), timerDuration * 1000);
    };

    Timer.prototype.cancel = function cancel() {
        if (this._timerHandle) {
            _Log.Log.debug("Timer.cancel: ", this._name);
            this._timer.clearInterval(this._timerHandle);
            this._timerHandle = null;
        }
    };

    Timer.prototype._callback = function _callback() {
        var diff = this._expiration - this.now;
        _Log.Log.debug("Timer.callback; " + this._name + " timer expires in:", diff);

        if (this._expiration <= this.now) {
            this.cancel();
            _Event.prototype.raise.call(this);
        }
    };

    _createClass(Timer, [{
        key: 'now',
        get: function get() {
            return parseInt(this._nowFunc());
        }
    }, {
        key: 'expiration',
        get: function get() {
            return this._expiration;
        }
    }]);

    return Timer;
}(_Event2.Event);

/***/ }),

/***/ "./src/TokenClient.js":
/*!****************************!*\
  !*** ./src/TokenClient.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.TokenClient = undefined;

var _JsonService = __webpack_require__(/*! ./JsonService.js */ "./src/JsonService.js");

var _MetadataService = __webpack_require__(/*! ./MetadataService.js */ "./src/MetadataService.js");

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var TokenClient = exports.TokenClient = function () {
    function TokenClient(settings) {
        var JsonServiceCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _JsonService.JsonService;
        var MetadataServiceCtor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _MetadataService.MetadataService;

        _classCallCheck(this, TokenClient);

        if (!settings) {
            _Log.Log.error("TokenClient.ctor: No settings passed");
            throw new Error("settings");
        }

        this._settings = settings;
        this._jsonService = new JsonServiceCtor();
        this._metadataService = new MetadataServiceCtor(this._settings);
    }

    TokenClient.prototype.exchangeCode = function exchangeCode() {
        var _this = this;

        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.grant_type = args.grant_type || "authorization_code";
        args.client_id = args.client_id || this._settings.client_id;
        args.redirect_uri = args.redirect_uri || this._settings.redirect_uri;

        if (!args.code) {
            _Log.Log.error("TokenClient.exchangeCode: No code passed");
            return Promise.reject(new Error("A code is required"));
        }
        if (!args.redirect_uri) {
            _Log.Log.error("TokenClient.exchangeCode: No redirect_uri passed");
            return Promise.reject(new Error("A redirect_uri is required"));
        }
        if (!args.code_verifier) {
            _Log.Log.error("TokenClient.exchangeCode: No code_verifier passed");
            return Promise.reject(new Error("A code_verifier is required"));
        }
        if (!args.client_id) {
            _Log.Log.error("TokenClient.exchangeCode: No client_id passed");
            return Promise.reject(new Error("A client_id is required"));
        }

        return this._metadataService.getTokenEndpoint(false).then(function (url) {
            _Log.Log.debug("TokenClient.exchangeCode: Received token endpoint");

            return _this._jsonService.postForm(url, args).then(function (response) {
                _Log.Log.debug("TokenClient.exchangeCode: response received");
                return response;
            });
        });
    };

    TokenClient.prototype.exchangeRefreshToken = function exchangeRefreshToken() {
        var _this2 = this;

        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.grant_type = args.grant_type || "refresh_token";
        args.client_id = args.client_id || this._settings.client_id;
        args.client_secret = args.client_secret || this._settings.client_secret;

        if (!args.refresh_token) {
            _Log.Log.error("TokenClient.exchangeRefreshToken: No refresh_token passed");
            return Promise.reject(new Error("A refresh_token is required"));
        }
        if (!args.client_id) {
            _Log.Log.error("TokenClient.exchangeRefreshToken: No client_id passed");
            return Promise.reject(new Error("A client_id is required"));
        }

        return this._metadataService.getTokenEndpoint(false).then(function (url) {
            _Log.Log.debug("TokenClient.exchangeRefreshToken: Received token endpoint");

            return _this2._jsonService.postForm(url, args).then(function (response) {
                _Log.Log.debug("TokenClient.exchangeRefreshToken: response received");
                return response;
            });
        });
    };

    return TokenClient;
}();

/***/ }),

/***/ "./src/TokenRevocationClient.js":
/*!**************************************!*\
  !*** ./src/TokenRevocationClient.js ***!
  \**************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.TokenRevocationClient = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _MetadataService = __webpack_require__(/*! ./MetadataService.js */ "./src/MetadataService.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var AccessTokenTypeHint = "access_token";
var RefreshTokenTypeHint = "refresh_token";

var TokenRevocationClient = exports.TokenRevocationClient = function () {
    function TokenRevocationClient(settings) {
        var XMLHttpRequestCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _Global.Global.XMLHttpRequest;
        var MetadataServiceCtor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _MetadataService.MetadataService;

        _classCallCheck(this, TokenRevocationClient);

        if (!settings) {
            _Log.Log.error("TokenRevocationClient.ctor: No settings provided");
            throw new Error("No settings provided.");
        }

        this._settings = settings;
        this._XMLHttpRequestCtor = XMLHttpRequestCtor;
        this._metadataService = new MetadataServiceCtor(this._settings);
    }

    TokenRevocationClient.prototype.revoke = function revoke(token, required) {
        var _this = this;

        var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : "access_token";

        if (!token) {
            _Log.Log.error("TokenRevocationClient.revoke: No token provided");
            throw new Error("No token provided.");
        }

        if (type !== AccessTokenTypeHint && type != RefreshTokenTypeHint) {
            _Log.Log.error("TokenRevocationClient.revoke: Invalid token type");
            throw new Error("Invalid token type.");
        }

        return this._metadataService.getRevocationEndpoint().then(function (url) {
            if (!url) {
                if (required) {
                    _Log.Log.error("TokenRevocationClient.revoke: Revocation not supported");
                    throw new Error("Revocation not supported");
                }

                // not required, so don't error and just return
                return;
            }

            _Log.Log.debug("TokenRevocationClient.revoke: Revoking " + type);
            var client_id = _this._settings.client_id;
            var client_secret = _this._settings.client_secret;
            return _this._revoke(url, client_id, client_secret, token, type);
        });
    };

    TokenRevocationClient.prototype._revoke = function _revoke(url, client_id, client_secret, token, type) {
        var _this2 = this;

        return new Promise(function (resolve, reject) {

            var xhr = new _this2._XMLHttpRequestCtor();
            xhr.open("POST", url);

            xhr.onload = function () {
                _Log.Log.debug("TokenRevocationClient.revoke: HTTP response received, status", xhr.status);

                if (xhr.status === 200) {
                    resolve();
                } else {
                    reject(Error(xhr.statusText + " (" + xhr.status + ")"));
                }
            };
            xhr.onerror = function () {
                _Log.Log.debug("TokenRevocationClient.revoke: Network Error.");
                reject("Network Error");
            };

            var body = "client_id=" + encodeURIComponent(client_id);
            if (client_secret) {
                body += "&client_secret=" + encodeURIComponent(client_secret);
            }
            body += "&token_type_hint=" + encodeURIComponent(type);
            body += "&token=" + encodeURIComponent(token);

            xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
            xhr.send(body);
        });
    };

    return TokenRevocationClient;
}();

/***/ }),

/***/ "./src/UrlUtility.js":
/*!***************************!*\
  !*** ./src/UrlUtility.js ***!
  \***************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.UrlUtility = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var UrlUtility = exports.UrlUtility = function () {
    function UrlUtility() {
        _classCallCheck(this, UrlUtility);
    }

    UrlUtility.addQueryParam = function addQueryParam(url, name, value) {
        if (url.indexOf('?') < 0) {
            url += "?";
        }

        if (url[url.length - 1] !== "?") {
            url += "&";
        }

        url += encodeURIComponent(name);
        url += "=";
        url += encodeURIComponent(value);

        return url;
    };

    UrlUtility.parseUrlFragment = function parseUrlFragment(value) {
        var delimiter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "#";
        var global = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _Global.Global;

        if (typeof value !== 'string') {
            value = global.location.href;
        }

        var idx = value.lastIndexOf(delimiter);
        if (idx >= 0) {
            value = value.substr(idx + 1);
        }

        if (delimiter === "?") {
            // if we're doing query, then strip off hash fragment before we parse
            idx = value.indexOf('#');
            if (idx >= 0) {
                value = value.substr(0, idx);
            }
        }

        var params = {},
            regex = /([^&=]+)=([^&]*)/g,
            m;

        var counter = 0;
        while (m = regex.exec(value)) {
            params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
            if (counter++ > 50) {
                _Log.Log.error("UrlUtility.parseUrlFragment: response exceeded expected number of parameters", value);
                return {
                    error: "Response exceeded expected number of parameters"
                };
            }
        }

        for (var prop in params) {
            return params;
        }

        return {};
    };

    return UrlUtility;
}();

/***/ }),

/***/ "./src/User.js":
/*!*********************!*\
  !*** ./src/User.js ***!
  \*********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.User = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var User = exports.User = function () {
    function User(_ref) {
        var id_token = _ref.id_token,
            session_state = _ref.session_state,
            access_token = _ref.access_token,
            refresh_token = _ref.refresh_token,
            token_type = _ref.token_type,
            scope = _ref.scope,
            profile = _ref.profile,
            expires_at = _ref.expires_at,
            state = _ref.state;

        _classCallCheck(this, User);

        this.id_token = id_token;
        this.session_state = session_state;
        this.access_token = access_token;
        this.refresh_token = refresh_token;
        this.token_type = token_type;
        this.scope = scope;
        this.profile = profile;
        this.expires_at = expires_at;
        this.state = state;
    }

    User.prototype.toStorageString = function toStorageString() {
        _Log.Log.debug("User.toStorageString");
        return JSON.stringify({
            id_token: this.id_token,
            session_state: this.session_state,
            access_token: this.access_token,
            refresh_token: this.refresh_token,
            token_type: this.token_type,
            scope: this.scope,
            profile: this.profile,
            expires_at: this.expires_at
        });
    };

    User.fromStorageString = function fromStorageString(storageString) {
        _Log.Log.debug("User.fromStorageString");
        return new User(JSON.parse(storageString));
    };

    _createClass(User, [{
        key: 'expires_in',
        get: function get() {
            if (this.expires_at) {
                var now = parseInt(Date.now() / 1000);
                return this.expires_at - now;
            }
            return undefined;
        },
        set: function set(value) {
            var expires_in = parseInt(value);
            if (typeof expires_in === 'number' && expires_in > 0) {
                var now = parseInt(Date.now() / 1000);
                this.expires_at = now + expires_in;
            }
        }
    }, {
        key: 'expired',
        get: function get() {
            var expires_in = this.expires_in;
            if (expires_in !== undefined) {
                return expires_in <= 0;
            }
            return undefined;
        }
    }, {
        key: 'scopes',
        get: function get() {
            return (this.scope || "").split(" ");
        }
    }]);

    return User;
}();

/***/ }),

/***/ "./src/UserInfoService.js":
/*!********************************!*\
  !*** ./src/UserInfoService.js ***!
  \********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.UserInfoService = undefined;

var _JsonService = __webpack_require__(/*! ./JsonService.js */ "./src/JsonService.js");

var _MetadataService = __webpack_require__(/*! ./MetadataService.js */ "./src/MetadataService.js");

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _JoseUtil = __webpack_require__(/*! ./JoseUtil.js */ "./src/JoseUtil.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var UserInfoService = exports.UserInfoService = function () {
    function UserInfoService(settings) {
        var JsonServiceCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _JsonService.JsonService;
        var MetadataServiceCtor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _MetadataService.MetadataService;
        var joseUtil = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _JoseUtil.JoseUtil;

        _classCallCheck(this, UserInfoService);

        if (!settings) {
            _Log.Log.error("UserInfoService.ctor: No settings passed");
            throw new Error("settings");
        }

        this._settings = settings;
        this._jsonService = new JsonServiceCtor(undefined, undefined, this._getClaimsFromJwt.bind(this));
        this._metadataService = new MetadataServiceCtor(this._settings);
        this._joseUtil = joseUtil;
    }

    UserInfoService.prototype.getClaims = function getClaims(token) {
        var _this = this;

        if (!token) {
            _Log.Log.error("UserInfoService.getClaims: No token passed");
            return Promise.reject(new Error("A token is required"));
        }

        return this._metadataService.getUserInfoEndpoint().then(function (url) {
            _Log.Log.debug("UserInfoService.getClaims: received userinfo url", url);

            return _this._jsonService.getJson(url, token).then(function (claims) {
                _Log.Log.debug("UserInfoService.getClaims: claims received", claims);
                return claims;
            });
        });
    };

    UserInfoService.prototype._getClaimsFromJwt = function _getClaimsFromJwt(req) {
        var _this2 = this;

        try {
            var jwt = this._joseUtil.parseJwt(req.responseText);
            if (!jwt || !jwt.header || !jwt.payload) {
                _Log.Log.error("UserInfoService._getClaimsFromJwt: Failed to parse JWT", jwt);
                return Promise.reject(new Error("Failed to parse id_token"));
            }

            var kid = jwt.header.kid;

            var issuerPromise = void 0;
            switch (this._settings.userInfoJwtIssuer) {
                case 'OP':
                    issuerPromise = this._metadataService.getIssuer();
                    break;
                case 'ANY':
                    issuerPromise = Promise.resolve(jwt.payload.iss);
                    break;
                default:
                    issuerPromise = Promise.resolve(this._settings.userInfoJwtIssuer);
                    break;
            }

            return issuerPromise.then(function (issuer) {
                _Log.Log.debug("UserInfoService._getClaimsFromJwt: Received issuer:" + issuer);

                return _this2._metadataService.getSigningKeys().then(function (keys) {
                    if (!keys) {
                        _Log.Log.error("UserInfoService._getClaimsFromJwt: No signing keys from metadata");
                        return Promise.reject(new Error("No signing keys from metadata"));
                    }

                    _Log.Log.debug("UserInfoService._getClaimsFromJwt: Received signing keys");
                    var key = void 0;
                    if (!kid) {
                        keys = _this2._filterByAlg(keys, jwt.header.alg);

                        if (keys.length > 1) {
                            _Log.Log.error("UserInfoService._getClaimsFromJwt: No kid found in id_token and more than one key found in metadata");
                            return Promise.reject(new Error("No kid found in id_token and more than one key found in metadata"));
                        } else {
                            // kid is mandatory only when there are multiple keys in the referenced JWK Set document
                            // see http://openid.net/specs/openid-connect-core-1_0.html#Signing
                            key = keys[0];
                        }
                    } else {
                        key = keys.filter(function (key) {
                            return key.kid === kid;
                        })[0];
                    }

                    if (!key) {
                        _Log.Log.error("UserInfoService._getClaimsFromJwt: No key matching kid or alg found in signing keys");
                        return Promise.reject(new Error("No key matching kid or alg found in signing keys"));
                    }

                    var audience = _this2._settings.client_id;

                    var clockSkewInSeconds = _this2._settings.clockSkew;
                    _Log.Log.debug("UserInfoService._getClaimsFromJwt: Validaing JWT; using clock skew (in seconds) of: ", clockSkewInSeconds);

                    return _this2._joseUtil.validateJwt(req.responseText, key, issuer, audience, clockSkewInSeconds, undefined, true).then(function () {
                        _Log.Log.debug("UserInfoService._getClaimsFromJwt: JWT validation successful");
                        return jwt.payload;
                    });
                });
            });
            return;
        } catch (e) {
            _Log.Log.error("UserInfoService._getClaimsFromJwt: Error parsing JWT response", e.message);
            reject(e);
            return;
        }
    };

    UserInfoService.prototype._filterByAlg = function _filterByAlg(keys, alg) {
        var kty = null;
        if (alg.startsWith("RS")) {
            kty = "RSA";
        } else if (alg.startsWith("PS")) {
            kty = "PS";
        } else if (alg.startsWith("ES")) {
            kty = "EC";
        } else {
            _Log.Log.debug("UserInfoService._filterByAlg: alg not supported: ", alg);
            return [];
        }

        _Log.Log.debug("UserInfoService._filterByAlg: Looking for keys that match kty: ", kty);

        keys = keys.filter(function (key) {
            return key.kty === kty;
        });

        _Log.Log.debug("UserInfoService._filterByAlg: Number of keys that match kty: ", kty, keys.length);

        return keys;
    };

    return UserInfoService;
}();

/***/ }),

/***/ "./src/UserManager.js":
/*!****************************!*\
  !*** ./src/UserManager.js ***!
  \****************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.UserManager = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _OidcClient2 = __webpack_require__(/*! ./OidcClient.js */ "./src/OidcClient.js");

var _UserManagerSettings = __webpack_require__(/*! ./UserManagerSettings.js */ "./src/UserManagerSettings.js");

var _User = __webpack_require__(/*! ./User.js */ "./src/User.js");

var _UserManagerEvents = __webpack_require__(/*! ./UserManagerEvents.js */ "./src/UserManagerEvents.js");

var _SilentRenewService = __webpack_require__(/*! ./SilentRenewService.js */ "./src/SilentRenewService.js");

var _SessionMonitor = __webpack_require__(/*! ./SessionMonitor.js */ "./src/SessionMonitor.js");

var _TokenRevocationClient = __webpack_require__(/*! ./TokenRevocationClient.js */ "./src/TokenRevocationClient.js");

var _TokenClient = __webpack_require__(/*! ./TokenClient.js */ "./src/TokenClient.js");

var _JoseUtil = __webpack_require__(/*! ./JoseUtil.js */ "./src/JoseUtil.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var UserManager = exports.UserManager = function (_OidcClient) {
    _inherits(UserManager, _OidcClient);

    function UserManager() {
        var settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
        var SilentRenewServiceCtor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _SilentRenewService.SilentRenewService;
        var SessionMonitorCtor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _SessionMonitor.SessionMonitor;
        var TokenRevocationClientCtor = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _TokenRevocationClient.TokenRevocationClient;
        var TokenClientCtor = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : _TokenClient.TokenClient;
        var joseUtil = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : _JoseUtil.JoseUtil;

        _classCallCheck(this, UserManager);

        if (!(settings instanceof _UserManagerSettings.UserManagerSettings)) {
            settings = new _UserManagerSettings.UserManagerSettings(settings);
        }

        var _this = _possibleConstructorReturn(this, _OidcClient.call(this, settings));

        _this._events = new _UserManagerEvents.UserManagerEvents(settings);
        _this._silentRenewService = new SilentRenewServiceCtor(_this);

        // order is important for the following properties; these services depend upon the events.
        if (_this.settings.automaticSilentRenew) {
            _Log.Log.debug("UserManager.ctor: automaticSilentRenew is configured, setting up silent renew");
            _this.startSilentRenew();
        }

        if (_this.settings.monitorSession) {
            _Log.Log.debug("UserManager.ctor: monitorSession is configured, setting up session monitor");
            _this._sessionMonitor = new SessionMonitorCtor(_this);
        }

        _this._tokenRevocationClient = new TokenRevocationClientCtor(_this._settings);
        _this._tokenClient = new TokenClientCtor(_this._settings);
        _this._joseUtil = joseUtil;
        return _this;
    }

    UserManager.prototype.getUser = function getUser() {
        var _this2 = this;

        return this._loadUser().then(function (user) {
            if (user) {
                _Log.Log.info("UserManager.getUser: user loaded");

                _this2._events.load(user, false);

                return user;
            } else {
                _Log.Log.info("UserManager.getUser: user not found in storage");
                return null;
            }
        });
    };

    UserManager.prototype.removeUser = function removeUser() {
        var _this3 = this;

        return this.storeUser(null).then(function () {
            _Log.Log.info("UserManager.removeUser: user removed from storage");
            _this3._events.unload();
        });
    };

    UserManager.prototype.signinRedirect = function signinRedirect() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "si:r";
        var navParams = {
            useReplaceToNavigate: args.useReplaceToNavigate
        };
        return this._signinStart(args, this._redirectNavigator, navParams).then(function () {
            _Log.Log.info("UserManager.signinRedirect: successful");
        });
    };

    UserManager.prototype.signinRedirectCallback = function signinRedirectCallback(url) {
        return this._signinEnd(url || this._redirectNavigator.url).then(function (user) {
            if (user.profile && user.profile.sub) {
                _Log.Log.info("UserManager.signinRedirectCallback: successful, signed in sub: ", user.profile.sub);
            } else {
                _Log.Log.info("UserManager.signinRedirectCallback: no sub");
            }

            return user;
        });
    };

    UserManager.prototype.signinPopup = function signinPopup() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "si:p";
        var url = args.redirect_uri || this.settings.popup_redirect_uri || this.settings.redirect_uri;
        if (!url) {
            _Log.Log.error("UserManager.signinPopup: No popup_redirect_uri or redirect_uri configured");
            return Promise.reject(new Error("No popup_redirect_uri or redirect_uri configured"));
        }

        args.redirect_uri = url;
        args.display = "popup";

        return this._signin(args, this._popupNavigator, {
            startUrl: url,
            popupWindowFeatures: args.popupWindowFeatures || this.settings.popupWindowFeatures,
            popupWindowTarget: args.popupWindowTarget || this.settings.popupWindowTarget
        }).then(function (user) {
            if (user) {
                if (user.profile && user.profile.sub) {
                    _Log.Log.info("UserManager.signinPopup: signinPopup successful, signed in sub: ", user.profile.sub);
                } else {
                    _Log.Log.info("UserManager.signinPopup: no sub");
                }
            }

            return user;
        });
    };

    UserManager.prototype.signinPopupCallback = function signinPopupCallback(url) {
        return this._signinCallback(url, this._popupNavigator).then(function (user) {
            if (user) {
                if (user.profile && user.profile.sub) {
                    _Log.Log.info("UserManager.signinPopupCallback: successful, signed in sub: ", user.profile.sub);
                } else {
                    _Log.Log.info("UserManager.signinPopupCallback: no sub");
                }
            }

            return user;
        }).catch(function (err) {
            _Log.Log.error( true && err.message);
        });
    };

    UserManager.prototype.signinSilent = function signinSilent() {
        var _this4 = this;

        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "si:s";
        // first determine if we have a refresh token, or need to use iframe
        return this._loadUser().then(function (user) {
            if (user && user.refresh_token) {
                args.refresh_token = user.refresh_token;
                return _this4._useRefreshToken(args);
            } else {
                args.id_token_hint = args.id_token_hint || _this4.settings.includeIdTokenInSilentRenew && user && user.id_token;
                if (user && _this4._settings.validateSubOnSilentRenew) {
                    _Log.Log.debug("UserManager.signinSilent, subject prior to silent renew: ", user.profile.sub);
                    args.current_sub = user.profile.sub;
                }
                return _this4._signinSilentIframe(args);
            }
        });
    };

    UserManager.prototype._useRefreshToken = function _useRefreshToken() {
        var _this5 = this;

        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        return this._tokenClient.exchangeRefreshToken(args).then(function (result) {
            if (!result) {
                _Log.Log.error("UserManager._useRefreshToken: No response returned from token endpoint");
                return Promise.reject("No response returned from token endpoint");
            }
            if (!result.access_token) {
                _Log.Log.error("UserManager._useRefreshToken: No access token returned from token endpoint");
                return Promise.reject("No access token returned from token endpoint");
            }

            return _this5._loadUser().then(function (user) {
                if (user) {
                    var idTokenValidation = Promise.resolve();
                    if (result.id_token) {
                        idTokenValidation = _this5._validateIdTokenFromTokenRefreshToken(user.profile, result.id_token);
                    }

                    return idTokenValidation.then(function () {
                        _Log.Log.debug("UserManager._useRefreshToken: refresh token response success");
                        user.id_token = result.id_token;
                        user.access_token = result.access_token;
                        user.refresh_token = result.refresh_token || user.refresh_token;
                        user.expires_in = result.expires_in;

                        return _this5.storeUser(user).then(function () {
                            _this5._events.load(user);
                            return user;
                        });
                    });
                } else {
                    return null;
                }
            });
        });
    };

    UserManager.prototype._validateIdTokenFromTokenRefreshToken = function _validateIdTokenFromTokenRefreshToken(profile, id_token) {
        var _this6 = this;

        return this._metadataService.getIssuer().then(function (issuer) {
            return _this6._joseUtil.validateJwtAttributes(id_token, issuer, _this6._settings.client_id, _this6._settings.clockSkew).then(function (payload) {
                if (!payload) {
                    _Log.Log.error("UserManager._validateIdTokenFromTokenRefreshToken: Failed to validate id_token");
                    return Promise.reject(new Error("Failed to validate id_token"));
                }
                if (payload.sub !== profile.sub) {
                    _Log.Log.error("UserManager._validateIdTokenFromTokenRefreshToken: sub in id_token does not match current sub");
                    return Promise.reject(new Error("sub in id_token does not match current sub"));
                }
                if (payload.auth_time && payload.auth_time !== profile.auth_time) {
                    _Log.Log.error("UserManager._validateIdTokenFromTokenRefreshToken: auth_time in id_token does not match original auth_time");
                    return Promise.reject(new Error("auth_time in id_token does not match original auth_time"));
                }
                if (payload.azp && payload.azp !== profile.azp) {
                    _Log.Log.error("UserManager._validateIdTokenFromTokenRefreshToken: azp in id_token does not match original azp");
                    return Promise.reject(new Error("azp in id_token does not match original azp"));
                }
                if (!payload.azp && profile.azp) {
                    _Log.Log.error("UserManager._validateIdTokenFromTokenRefreshToken: azp not in id_token, but present in original id_token");
                    return Promise.reject(new Error("azp not in id_token, but present in original id_token"));
                }
            });
        });
    };

    UserManager.prototype._signinSilentIframe = function _signinSilentIframe() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var url = args.redirect_uri || this.settings.silent_redirect_uri || this.settings.redirect_uri;
        if (!url) {
            _Log.Log.error("UserManager.signinSilent: No silent_redirect_uri configured");
            return Promise.reject(new Error("No silent_redirect_uri configured"));
        }

        args.redirect_uri = url;
        args.prompt = args.prompt || "none";

        return this._signin(args, this._iframeNavigator, {
            startUrl: url,
            silentRequestTimeout: args.silentRequestTimeout || this.settings.silentRequestTimeout
        }).then(function (user) {
            if (user) {
                if (user.profile && user.profile.sub) {
                    _Log.Log.info("UserManager.signinSilent: successful, signed in sub: ", user.profile.sub);
                } else {
                    _Log.Log.info("UserManager.signinSilent: no sub");
                }
            }

            return user;
        });
    };

    UserManager.prototype.signinSilentCallback = function signinSilentCallback(url) {
        return this._signinCallback(url, this._iframeNavigator).then(function (user) {
            if (user) {
                if (user.profile && user.profile.sub) {
                    _Log.Log.info("UserManager.signinSilentCallback: successful, signed in sub: ", user.profile.sub);
                } else {
                    _Log.Log.info("UserManager.signinSilentCallback: no sub");
                }
            }

            return user;
        });
    };

    UserManager.prototype.signinCallback = function signinCallback(url) {
        var _this7 = this;

        return this.readSigninResponseState(url).then(function (_ref) {
            var state = _ref.state,
                response = _ref.response;

            if (state.request_type === "si:r") {
                return _this7.signinRedirectCallback(url);
            }
            if (state.request_type === "si:p") {
                return _this7.signinPopupCallback(url);
            }
            if (state.request_type === "si:s") {
                return _this7.signinSilentCallback(url);
            }
            return Promise.reject(new Error("invalid response_type in state"));
        });
    };

    UserManager.prototype.signoutCallback = function signoutCallback(url, keepOpen) {
        var _this8 = this;

        return this.readSignoutResponseState(url).then(function (_ref2) {
            var state = _ref2.state,
                response = _ref2.response;

            if (state) {
                if (state.request_type === "so:r") {
                    return _this8.signoutRedirectCallback(url);
                }
                if (state.request_type === "so:p") {
                    return _this8.signoutPopupCallback(url, keepOpen);
                }
                return Promise.reject(new Error("invalid response_type in state"));
            }
            return response;
        });
    };

    UserManager.prototype.querySessionStatus = function querySessionStatus() {
        var _this9 = this;

        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "si:s"; // this acts like a signin silent
        var url = args.redirect_uri || this.settings.silent_redirect_uri || this.settings.redirect_uri;
        if (!url) {
            _Log.Log.error("UserManager.querySessionStatus: No silent_redirect_uri configured");
            return Promise.reject(new Error("No silent_redirect_uri configured"));
        }

        args.redirect_uri = url;
        args.prompt = "none";
        args.response_type = args.response_type || this.settings.query_status_response_type;
        args.scope = args.scope || "openid";
        args.skipUserInfo = true;

        return this._signinStart(args, this._iframeNavigator, {
            startUrl: url,
            silentRequestTimeout: args.silentRequestTimeout || this.settings.silentRequestTimeout
        }).then(function (navResponse) {
            return _this9.processSigninResponse(navResponse.url).then(function (signinResponse) {
                _Log.Log.debug("UserManager.querySessionStatus: got signin response");

                if (signinResponse.session_state && signinResponse.profile.sub) {
                    _Log.Log.info("UserManager.querySessionStatus: querySessionStatus success for sub: ", signinResponse.profile.sub);
                    return {
                        session_state: signinResponse.session_state,
                        sub: signinResponse.profile.sub,
                        sid: signinResponse.profile.sid
                    };
                } else {
                    _Log.Log.info("querySessionStatus successful, user not authenticated");
                }
            }).catch(function (err) {
                if (err.session_state && _this9.settings.monitorAnonymousSession) {
                    if (err.message == "login_required" || err.message == "consent_required" || err.message == "interaction_required" || err.message == "account_selection_required") {
                        _Log.Log.info("UserManager.querySessionStatus: querySessionStatus success for anonymous user");
                        return {
                            session_state: err.session_state
                        };
                    }
                }

                throw err;
            });
        });
    };

    UserManager.prototype._signin = function _signin(args, navigator) {
        var _this10 = this;

        var navigatorParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        return this._signinStart(args, navigator, navigatorParams).then(function (navResponse) {
            return _this10._signinEnd(navResponse.url, args);
        });
    };

    UserManager.prototype._signinStart = function _signinStart(args, navigator) {
        var _this11 = this;

        var navigatorParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};


        return navigator.prepare(navigatorParams).then(function (handle) {
            _Log.Log.debug("UserManager._signinStart: got navigator window handle");

            return _this11.createSigninRequest(args).then(function (signinRequest) {
                _Log.Log.debug("UserManager._signinStart: got signin request");

                navigatorParams.url = signinRequest.url;
                navigatorParams.id = signinRequest.state.id;

                return handle.navigate(navigatorParams);
            }).catch(function (err) {
                if (handle.close) {
                    _Log.Log.debug("UserManager._signinStart: Error after preparing navigator, closing navigator window");
                    handle.close();
                }
                throw err;
            });
        });
    };

    UserManager.prototype._signinEnd = function _signinEnd(url) {
        var _this12 = this;

        var args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

        return this.processSigninResponse(url).then(function (signinResponse) {
            _Log.Log.debug("UserManager._signinEnd: got signin response");

            var user = new _User.User(signinResponse);

            if (args.current_sub) {
                if (args.current_sub !== user.profile.sub) {
                    _Log.Log.debug("UserManager._signinEnd: current user does not match user returned from signin. sub from signin: ", user.profile.sub);
                    return Promise.reject(new Error("login_required"));
                } else {
                    _Log.Log.debug("UserManager._signinEnd: current user matches user returned from signin");
                }
            }

            return _this12.storeUser(user).then(function () {
                _Log.Log.debug("UserManager._signinEnd: user stored");

                _this12._events.load(user);

                return user;
            });
        });
    };

    UserManager.prototype._signinCallback = function _signinCallback(url, navigator) {
        _Log.Log.debug("UserManager._signinCallback");
        return navigator.callback(url);
    };

    UserManager.prototype.signoutRedirect = function signoutRedirect() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "so:r";
        var postLogoutRedirectUri = args.post_logout_redirect_uri || this.settings.post_logout_redirect_uri;
        if (postLogoutRedirectUri) {
            args.post_logout_redirect_uri = postLogoutRedirectUri;
        }
        var navParams = {
            useReplaceToNavigate: args.useReplaceToNavigate
        };
        return this._signoutStart(args, this._redirectNavigator, navParams).then(function () {
            _Log.Log.info("UserManager.signoutRedirect: successful");
        });
    };

    UserManager.prototype.signoutRedirectCallback = function signoutRedirectCallback(url) {
        return this._signoutEnd(url || this._redirectNavigator.url).then(function (response) {
            _Log.Log.info("UserManager.signoutRedirectCallback: successful");
            return response;
        });
    };

    UserManager.prototype.signoutPopup = function signoutPopup() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        args = Object.assign({}, args);

        args.request_type = "so:p";
        var url = args.post_logout_redirect_uri || this.settings.popup_post_logout_redirect_uri || this.settings.post_logout_redirect_uri;
        args.post_logout_redirect_uri = url;
        args.display = "popup";
        if (args.post_logout_redirect_uri) {
            // we're putting a dummy entry in here because we
            // need a unique id from the state for notification
            // to the parent window, which is necessary if we
            // plan to return back to the client after signout
            // and so we can close the popup after signout
            args.state = args.state || {};
        }

        return this._signout(args, this._popupNavigator, {
            startUrl: url,
            popupWindowFeatures: args.popupWindowFeatures || this.settings.popupWindowFeatures,
            popupWindowTarget: args.popupWindowTarget || this.settings.popupWindowTarget
        }).then(function () {
            _Log.Log.info("UserManager.signoutPopup: successful");
        });
    };

    UserManager.prototype.signoutPopupCallback = function signoutPopupCallback(url, keepOpen) {
        if (typeof keepOpen === 'undefined' && typeof url === 'boolean') {
            keepOpen = url;
            url = null;
        }

        var delimiter = '?';
        return this._popupNavigator.callback(url, keepOpen, delimiter).then(function () {
            _Log.Log.info("UserManager.signoutPopupCallback: successful");
        });
    };

    UserManager.prototype._signout = function _signout(args, navigator) {
        var _this13 = this;

        var navigatorParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        return this._signoutStart(args, navigator, navigatorParams).then(function (navResponse) {
            return _this13._signoutEnd(navResponse.url);
        });
    };

    UserManager.prototype._signoutStart = function _signoutStart() {
        var args = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};

        var _this14 = this;

        var navigator = arguments[1];
        var navigatorParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

        return navigator.prepare(navigatorParams).then(function (handle) {
            _Log.Log.debug("UserManager._signoutStart: got navigator window handle");

            return _this14._loadUser().then(function (user) {
                _Log.Log.debug("UserManager._signoutStart: loaded current user from storage");

                var revokePromise = _this14._settings.revokeAccessTokenOnSignout ? _this14._revokeInternal(user) : Promise.resolve();
                return revokePromise.then(function () {

                    var id_token = args.id_token_hint || user && user.id_token;
                    if (id_token) {
                        _Log.Log.debug("UserManager._signoutStart: Setting id_token into signout request");
                        args.id_token_hint = id_token;
                    }

                    return _this14.removeUser().then(function () {
                        _Log.Log.debug("UserManager._signoutStart: user removed, creating signout request");

                        return _this14.createSignoutRequest(args).then(function (signoutRequest) {
                            _Log.Log.debug("UserManager._signoutStart: got signout request");

                            navigatorParams.url = signoutRequest.url;
                            if (signoutRequest.state) {
                                navigatorParams.id = signoutRequest.state.id;
                            }
                            return handle.navigate(navigatorParams);
                        });
                    });
                });
            }).catch(function (err) {
                if (handle.close) {
                    _Log.Log.debug("UserManager._signoutStart: Error after preparing navigator, closing navigator window");
                    handle.close();
                }
                throw err;
            });
        });
    };

    UserManager.prototype._signoutEnd = function _signoutEnd(url) {
        return this.processSignoutResponse(url).then(function (signoutResponse) {
            _Log.Log.debug("UserManager._signoutEnd: got signout response");

            return signoutResponse;
        });
    };

    UserManager.prototype.revokeAccessToken = function revokeAccessToken() {
        var _this15 = this;

        return this._loadUser().then(function (user) {
            return _this15._revokeInternal(user, true).then(function (success) {
                if (success) {
                    _Log.Log.debug("UserManager.revokeAccessToken: removing token properties from user and re-storing");

                    user.access_token = null;
                    user.refresh_token = null;
                    user.expires_at = null;
                    user.token_type = null;

                    return _this15.storeUser(user).then(function () {
                        _Log.Log.debug("UserManager.revokeAccessToken: user stored");
                        _this15._events.load(user);
                    });
                }
            });
        }).then(function () {
            _Log.Log.info("UserManager.revokeAccessToken: access token revoked successfully");
        });
    };

    UserManager.prototype._revokeInternal = function _revokeInternal(user, required) {
        var _this16 = this;

        if (user) {
            var access_token = user.access_token;
            var refresh_token = user.refresh_token;

            return this._revokeAccessTokenInternal(access_token, required).then(function (atSuccess) {
                return _this16._revokeRefreshTokenInternal(refresh_token, required).then(function (rtSuccess) {
                    if (!atSuccess && !rtSuccess) {
                        _Log.Log.debug("UserManager.revokeAccessToken: no need to revoke due to no token(s), or JWT format");
                    }

                    return atSuccess || rtSuccess;
                });
            });
        }

        return Promise.resolve(false);
    };

    UserManager.prototype._revokeAccessTokenInternal = function _revokeAccessTokenInternal(access_token, required) {
        // check for JWT vs. reference token
        if (!access_token || access_token.indexOf('.') >= 0) {
            return Promise.resolve(false);
        }

        return this._tokenRevocationClient.revoke(access_token, required).then(function () {
            return true;
        });
    };

    UserManager.prototype._revokeRefreshTokenInternal = function _revokeRefreshTokenInternal(refresh_token, required) {
        if (!refresh_token) {
            return Promise.resolve(false);
        }

        return this._tokenRevocationClient.revoke(refresh_token, required, "refresh_token").then(function () {
            return true;
        });
    };

    UserManager.prototype.startSilentRenew = function startSilentRenew() {
        this._silentRenewService.start();
    };

    UserManager.prototype.stopSilentRenew = function stopSilentRenew() {
        this._silentRenewService.stop();
    };

    UserManager.prototype._loadUser = function _loadUser() {
        return this._userStore.get(this._userStoreKey).then(function (storageString) {
            if (storageString) {
                _Log.Log.debug("UserManager._loadUser: user storageString loaded");
                return _User.User.fromStorageString(storageString);
            }

            _Log.Log.debug("UserManager._loadUser: no user storageString");
            return null;
        });
    };

    UserManager.prototype.storeUser = function storeUser(user) {
        if (user) {
            _Log.Log.debug("UserManager.storeUser: storing user");

            var storageString = user.toStorageString();
            return this._userStore.set(this._userStoreKey, storageString);
        } else {
            _Log.Log.debug("storeUser.storeUser: removing user");
            return this._userStore.remove(this._userStoreKey);
        }
    };

    _createClass(UserManager, [{
        key: '_redirectNavigator',
        get: function get() {
            return this.settings.redirectNavigator;
        }
    }, {
        key: '_popupNavigator',
        get: function get() {
            return this.settings.popupNavigator;
        }
    }, {
        key: '_iframeNavigator',
        get: function get() {
            return this.settings.iframeNavigator;
        }
    }, {
        key: '_userStore',
        get: function get() {
            return this.settings.userStore;
        }
    }, {
        key: 'events',
        get: function get() {
            return this._events;
        }
    }, {
        key: '_userStoreKey',
        get: function get() {
            return 'user:' + this.settings.authority + ':' + this.settings.client_id;
        }
    }]);

    return UserManager;
}(_OidcClient2.OidcClient);

/***/ }),

/***/ "./src/UserManagerEvents.js":
/*!**********************************!*\
  !*** ./src/UserManagerEvents.js ***!
  \**********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.UserManagerEvents = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _AccessTokenEvents2 = __webpack_require__(/*! ./AccessTokenEvents.js */ "./src/AccessTokenEvents.js");

var _Event = __webpack_require__(/*! ./Event.js */ "./src/Event.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var UserManagerEvents = exports.UserManagerEvents = function (_AccessTokenEvents) {
    _inherits(UserManagerEvents, _AccessTokenEvents);

    function UserManagerEvents(settings) {
        _classCallCheck(this, UserManagerEvents);

        var _this = _possibleConstructorReturn(this, _AccessTokenEvents.call(this, settings));

        _this._userLoaded = new _Event.Event("User loaded");
        _this._userUnloaded = new _Event.Event("User unloaded");
        _this._silentRenewError = new _Event.Event("Silent renew error");
        _this._userSignedIn = new _Event.Event("User signed in");
        _this._userSignedOut = new _Event.Event("User signed out");
        _this._userSessionChanged = new _Event.Event("User session changed");
        return _this;
    }

    UserManagerEvents.prototype.load = function load(user) {
        var raiseEvent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

        _Log.Log.debug("UserManagerEvents.load");
        _AccessTokenEvents.prototype.load.call(this, user);
        if (raiseEvent) {
            this._userLoaded.raise(user);
        }
    };

    UserManagerEvents.prototype.unload = function unload() {
        _Log.Log.debug("UserManagerEvents.unload");
        _AccessTokenEvents.prototype.unload.call(this);
        this._userUnloaded.raise();
    };

    UserManagerEvents.prototype.addUserLoaded = function addUserLoaded(cb) {
        this._userLoaded.addHandler(cb);
    };

    UserManagerEvents.prototype.removeUserLoaded = function removeUserLoaded(cb) {
        this._userLoaded.removeHandler(cb);
    };

    UserManagerEvents.prototype.addUserUnloaded = function addUserUnloaded(cb) {
        this._userUnloaded.addHandler(cb);
    };

    UserManagerEvents.prototype.removeUserUnloaded = function removeUserUnloaded(cb) {
        this._userUnloaded.removeHandler(cb);
    };

    UserManagerEvents.prototype.addSilentRenewError = function addSilentRenewError(cb) {
        this._silentRenewError.addHandler(cb);
    };

    UserManagerEvents.prototype.removeSilentRenewError = function removeSilentRenewError(cb) {
        this._silentRenewError.removeHandler(cb);
    };

    UserManagerEvents.prototype._raiseSilentRenewError = function _raiseSilentRenewError(e) {
        _Log.Log.debug("UserManagerEvents._raiseSilentRenewError", e.message);
        this._silentRenewError.raise(e);
    };

    UserManagerEvents.prototype.addUserSignedIn = function addUserSignedIn(cb) {
        this._userSignedIn.addHandler(cb);
    };

    UserManagerEvents.prototype.removeUserSignedIn = function removeUserSignedIn(cb) {
        this._userSignedIn.removeHandler(cb);
    };

    UserManagerEvents.prototype._raiseUserSignedIn = function _raiseUserSignedIn() {
        _Log.Log.debug("UserManagerEvents._raiseUserSignedIn");
        this._userSignedIn.raise();
    };

    UserManagerEvents.prototype.addUserSignedOut = function addUserSignedOut(cb) {
        this._userSignedOut.addHandler(cb);
    };

    UserManagerEvents.prototype.removeUserSignedOut = function removeUserSignedOut(cb) {
        this._userSignedOut.removeHandler(cb);
    };

    UserManagerEvents.prototype._raiseUserSignedOut = function _raiseUserSignedOut() {
        _Log.Log.debug("UserManagerEvents._raiseUserSignedOut");
        this._userSignedOut.raise();
    };

    UserManagerEvents.prototype.addUserSessionChanged = function addUserSessionChanged(cb) {
        this._userSessionChanged.addHandler(cb);
    };

    UserManagerEvents.prototype.removeUserSessionChanged = function removeUserSessionChanged(cb) {
        this._userSessionChanged.removeHandler(cb);
    };

    UserManagerEvents.prototype._raiseUserSessionChanged = function _raiseUserSessionChanged() {
        _Log.Log.debug("UserManagerEvents._raiseUserSessionChanged");
        this._userSessionChanged.raise();
    };

    return UserManagerEvents;
}(_AccessTokenEvents2.AccessTokenEvents);

/***/ }),

/***/ "./src/UserManagerSettings.js":
/*!************************************!*\
  !*** ./src/UserManagerSettings.js ***!
  \************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.UserManagerSettings = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _OidcClientSettings2 = __webpack_require__(/*! ./OidcClientSettings.js */ "./src/OidcClientSettings.js");

var _RedirectNavigator = __webpack_require__(/*! ./RedirectNavigator.js */ "./src/RedirectNavigator.js");

var _PopupNavigator = __webpack_require__(/*! ./PopupNavigator.js */ "./src/PopupNavigator.js");

var _IFrameNavigator = __webpack_require__(/*! ./IFrameNavigator.js */ "./src/IFrameNavigator.js");

var _WebStorageStateStore = __webpack_require__(/*! ./WebStorageStateStore.js */ "./src/WebStorageStateStore.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

var _SigninRequest = __webpack_require__(/*! ./SigninRequest.js */ "./src/SigninRequest.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var DefaultAccessTokenExpiringNotificationTime = 60;
var DefaultCheckSessionInterval = 2000;

var UserManagerSettings = exports.UserManagerSettings = function (_OidcClientSettings) {
    _inherits(UserManagerSettings, _OidcClientSettings);

    function UserManagerSettings() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            popup_redirect_uri = _ref.popup_redirect_uri,
            popup_post_logout_redirect_uri = _ref.popup_post_logout_redirect_uri,
            popupWindowFeatures = _ref.popupWindowFeatures,
            popupWindowTarget = _ref.popupWindowTarget,
            silent_redirect_uri = _ref.silent_redirect_uri,
            silentRequestTimeout = _ref.silentRequestTimeout,
            _ref$automaticSilentR = _ref.automaticSilentRenew,
            automaticSilentRenew = _ref$automaticSilentR === undefined ? false : _ref$automaticSilentR,
            _ref$validateSubOnSil = _ref.validateSubOnSilentRenew,
            validateSubOnSilentRenew = _ref$validateSubOnSil === undefined ? false : _ref$validateSubOnSil,
            _ref$includeIdTokenIn = _ref.includeIdTokenInSilentRenew,
            includeIdTokenInSilentRenew = _ref$includeIdTokenIn === undefined ? true : _ref$includeIdTokenIn,
            _ref$monitorSession = _ref.monitorSession,
            monitorSession = _ref$monitorSession === undefined ? true : _ref$monitorSession,
            _ref$monitorAnonymous = _ref.monitorAnonymousSession,
            monitorAnonymousSession = _ref$monitorAnonymous === undefined ? false : _ref$monitorAnonymous,
            _ref$checkSessionInte = _ref.checkSessionInterval,
            checkSessionInterval = _ref$checkSessionInte === undefined ? DefaultCheckSessionInterval : _ref$checkSessionInte,
            _ref$stopCheckSession = _ref.stopCheckSessionOnError,
            stopCheckSessionOnError = _ref$stopCheckSession === undefined ? true : _ref$stopCheckSession,
            query_status_response_type = _ref.query_status_response_type,
            _ref$revokeAccessToke = _ref.revokeAccessTokenOnSignout,
            revokeAccessTokenOnSignout = _ref$revokeAccessToke === undefined ? false : _ref$revokeAccessToke,
            _ref$accessTokenExpir = _ref.accessTokenExpiringNotificationTime,
            accessTokenExpiringNotificationTime = _ref$accessTokenExpir === undefined ? DefaultAccessTokenExpiringNotificationTime : _ref$accessTokenExpir,
            _ref$redirectNavigato = _ref.redirectNavigator,
            redirectNavigator = _ref$redirectNavigato === undefined ? new _RedirectNavigator.RedirectNavigator() : _ref$redirectNavigato,
            _ref$popupNavigator = _ref.popupNavigator,
            popupNavigator = _ref$popupNavigator === undefined ? new _PopupNavigator.PopupNavigator() : _ref$popupNavigator,
            _ref$iframeNavigator = _ref.iframeNavigator,
            iframeNavigator = _ref$iframeNavigator === undefined ? new _IFrameNavigator.IFrameNavigator() : _ref$iframeNavigator,
            _ref$userStore = _ref.userStore,
            userStore = _ref$userStore === undefined ? new _WebStorageStateStore.WebStorageStateStore({ store: _Global.Global.sessionStorage }) : _ref$userStore;

        _classCallCheck(this, UserManagerSettings);

        var _this = _possibleConstructorReturn(this, _OidcClientSettings.call(this, arguments[0]));

        _this._popup_redirect_uri = popup_redirect_uri;
        _this._popup_post_logout_redirect_uri = popup_post_logout_redirect_uri;
        _this._popupWindowFeatures = popupWindowFeatures;
        _this._popupWindowTarget = popupWindowTarget;

        _this._silent_redirect_uri = silent_redirect_uri;
        _this._silentRequestTimeout = silentRequestTimeout;
        _this._automaticSilentRenew = automaticSilentRenew;
        _this._validateSubOnSilentRenew = validateSubOnSilentRenew;
        _this._includeIdTokenInSilentRenew = includeIdTokenInSilentRenew;
        _this._accessTokenExpiringNotificationTime = accessTokenExpiringNotificationTime;

        _this._monitorSession = monitorSession;
        _this._monitorAnonymousSession = monitorAnonymousSession;
        _this._checkSessionInterval = checkSessionInterval;
        _this._stopCheckSessionOnError = stopCheckSessionOnError;
        if (query_status_response_type) {
            _this._query_status_response_type = query_status_response_type;
        } else if (arguments[0] && arguments[0].response_type) {
            _this._query_status_response_type = _SigninRequest.SigninRequest.isOidc(arguments[0].response_type) ? "id_token" : "code";
        } else {
            _this._query_status_response_type = "id_token";
        }
        _this._revokeAccessTokenOnSignout = revokeAccessTokenOnSignout;

        _this._redirectNavigator = redirectNavigator;
        _this._popupNavigator = popupNavigator;
        _this._iframeNavigator = iframeNavigator;

        _this._userStore = userStore;
        return _this;
    }

    _createClass(UserManagerSettings, [{
        key: 'popup_redirect_uri',
        get: function get() {
            return this._popup_redirect_uri;
        }
    }, {
        key: 'popup_post_logout_redirect_uri',
        get: function get() {
            return this._popup_post_logout_redirect_uri;
        }
    }, {
        key: 'popupWindowFeatures',
        get: function get() {
            return this._popupWindowFeatures;
        }
    }, {
        key: 'popupWindowTarget',
        get: function get() {
            return this._popupWindowTarget;
        }
    }, {
        key: 'silent_redirect_uri',
        get: function get() {
            return this._silent_redirect_uri;
        }
    }, {
        key: 'silentRequestTimeout',
        get: function get() {
            return this._silentRequestTimeout;
        }
    }, {
        key: 'automaticSilentRenew',
        get: function get() {
            return this._automaticSilentRenew;
        }
    }, {
        key: 'validateSubOnSilentRenew',
        get: function get() {
            return this._validateSubOnSilentRenew;
        }
    }, {
        key: 'includeIdTokenInSilentRenew',
        get: function get() {
            return this._includeIdTokenInSilentRenew;
        }
    }, {
        key: 'accessTokenExpiringNotificationTime',
        get: function get() {
            return this._accessTokenExpiringNotificationTime;
        }
    }, {
        key: 'monitorSession',
        get: function get() {
            return this._monitorSession;
        }
    }, {
        key: 'monitorAnonymousSession',
        get: function get() {
            return this._monitorAnonymousSession;
        }
    }, {
        key: 'checkSessionInterval',
        get: function get() {
            return this._checkSessionInterval;
        }
    }, {
        key: 'stopCheckSessionOnError',
        get: function get() {
            return this._stopCheckSessionOnError;
        }
    }, {
        key: 'query_status_response_type',
        get: function get() {
            return this._query_status_response_type;
        }
    }, {
        key: 'revokeAccessTokenOnSignout',
        get: function get() {
            return this._revokeAccessTokenOnSignout;
        }
    }, {
        key: 'redirectNavigator',
        get: function get() {
            return this._redirectNavigator;
        }
    }, {
        key: 'popupNavigator',
        get: function get() {
            return this._popupNavigator;
        }
    }, {
        key: 'iframeNavigator',
        get: function get() {
            return this._iframeNavigator;
        }
    }, {
        key: 'userStore',
        get: function get() {
            return this._userStore;
        }
    }]);

    return UserManagerSettings;
}(_OidcClientSettings2.OidcClientSettings);

/***/ }),

/***/ "./src/WebStorageStateStore.js":
/*!*************************************!*\
  !*** ./src/WebStorageStateStore.js ***!
  \*************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.WebStorageStateStore = undefined;

var _Log = __webpack_require__(/*! ./Log.js */ "./src/Log.js");

var _Global = __webpack_require__(/*! ./Global.js */ "./src/Global.js");

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } // Copyright (c) Brock Allen & Dominick Baier. All rights reserved.
// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.

var WebStorageStateStore = exports.WebStorageStateStore = function () {
    function WebStorageStateStore() {
        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
            _ref$prefix = _ref.prefix,
            prefix = _ref$prefix === undefined ? "oidc." : _ref$prefix,
            _ref$store = _ref.store,
            store = _ref$store === undefined ? _Global.Global.localStorage : _ref$store;

        _classCallCheck(this, WebStorageStateStore);

        this._store = store;
        this._prefix = prefix;
    }

    WebStorageStateStore.prototype.set = function set(key, value) {
        _Log.Log.debug("WebStorageStateStore.set", key);

        key = this._prefix + key;

        this._store.setItem(key, value);

        return Promise.resolve();
    };

    WebStorageStateStore.prototype.get = function get(key) {
        _Log.Log.debug("WebStorageStateStore.get", key);

        key = this._prefix + key;

        var item = this._store.getItem(key);

        return Promise.resolve(item);
    };

    WebStorageStateStore.prototype.remove = function remove(key) {
        _Log.Log.debug("WebStorageStateStore.remove", key);

        key = this._prefix + key;

        var item = this._store.getItem(key);
        this._store.removeItem(key);

        return Promise.resolve(item);
    };

    WebStorageStateStore.prototype.getAllKeys = function getAllKeys() {
        _Log.Log.debug("WebStorageStateStore.getAllKeys");

        var keys = [];

        for (var index = 0; index < this._store.length; index++) {
            var key = this._store.key(index);

            if (key.indexOf(this._prefix) === 0) {
                keys.push(key.substr(this._prefix.length));
            }
        }

        return Promise.resolve(keys);
    };

    return WebStorageStateStore;
}();

/***/ }),

/***/ "./src/crypto/jsrsasign.js":
/*!*********************************!*\
  !*** ./src/crypto/jsrsasign.js ***!
  \*********************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.AllowedSigningAlgs = exports.b64tohex = exports.hextob64u = exports.crypto = exports.X509 = exports.KeyUtil = exports.jws = undefined;

var _jsrsasign = __webpack_require__(/*! ../../jsrsasign/dist/jsrsasign.js */ "./jsrsasign/dist/jsrsasign.js");

var AllowedSigningAlgs = ['RS256', 'RS384', 'RS512', 'PS256', 'PS384', 'PS512', 'ES256', 'ES384', 'ES512'];

exports.jws = _jsrsasign.jws;
exports.KeyUtil = _jsrsasign.KEYUTIL;
exports.X509 = _jsrsasign.X509;
exports.crypto = _jsrsasign.crypto;
exports.hextob64u = _jsrsasign.hextob64u;
exports.b64tohex = _jsrsasign.b64tohex;
exports.AllowedSigningAlgs = AllowedSigningAlgs;

/***/ }),

/***/ "./src/random.js":
/*!***********************!*\
  !*** ./src/random.js ***!
  \***********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = random;

var _v = __webpack_require__(/*! uuid/v4 */ "./node_modules/uuid/v4.js");

var _v2 = _interopRequireDefault(_v);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Generates RFC4122 version 4 guid ()
 */

function random() {
  return (0, _v2.default)().replace(/-/g, '');
}
module.exports = exports['default'];

/***/ }),

/***/ "./version.js":
/*!********************!*\
  !*** ./version.js ***!
  \********************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

"use strict";


Object.defineProperty(exports, "__esModule", {
  value: true
});
var Version = "1.10.1";exports.Version = Version;

/***/ }),

/***/ 0:
/*!***************************************!*\
  !*** multi babel-polyfill ./index.js ***!
  \***************************************/
/*! no static exports found */
/***/ (function(module, exports, __webpack_require__) {

__webpack_require__(/*! babel-polyfill */"./node_modules/babel-polyfill/lib/index.js");
module.exports = __webpack_require__(/*! ./index.js */"./index.js");


/***/ })

/******/ });
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack://Oidc/webpack/bootstrap","webpack://Oidc/./index.js","webpack://Oidc/./jsrsasign/dist/jsrsasign.js","webpack://Oidc/./node_modules/babel-polyfill/lib/index.js","webpack://Oidc/./node_modules/babel-polyfill/node_modules/regenerator-runtime/runtime.js","webpack://Oidc/./node_modules/base64-js/index.js","webpack://Oidc/./node_modules/buffer/index.js","webpack://Oidc/./node_modules/buffer/node_modules/isarray/index.js","webpack://Oidc/./node_modules/core-js/fn/regexp/escape.js","webpack://Oidc/./node_modules/core-js/modules/_a-function.js","webpack://Oidc/./node_modules/core-js/modules/_a-number-value.js","webpack://Oidc/./node_modules/core-js/modules/_add-to-unscopables.js","webpack://Oidc/./node_modules/core-js/modules/_advance-string-index.js","webpack://Oidc/./node_modules/core-js/modules/_an-instance.js","webpack://Oidc/./node_modules/core-js/modules/_an-object.js","webpack://Oidc/./node_modules/core-js/modules/_array-copy-within.js","webpack://Oidc/./node_modules/core-js/modules/_array-fill.js","webpack://Oidc/./node_modules/core-js/modules/_array-from-iterable.js","webpack://Oidc/./node_modules/core-js/modules/_array-includes.js","webpack://Oidc/./node_modules/core-js/modules/_array-methods.js","webpack://Oidc/./node_modules/core-js/modules/_array-reduce.js","webpack://Oidc/./node_modules/core-js/modules/_array-species-constructor.js","webpack://Oidc/./node_modules/core-js/modules/_array-species-create.js","webpack://Oidc/./node_modules/core-js/modules/_bind.js","webpack://Oidc/./node_modules/core-js/modules/_classof.js","webpack://Oidc/./node_modules/core-js/modules/_cof.js","webpack://Oidc/./node_modules/core-js/modules/_collection-strong.js","webpack://Oidc/./node_modules/core-js/modules/_collection-to-json.js","webpack://Oidc/./node_modules/core-js/modules/_collection-weak.js","webpack://Oidc/./node_modules/core-js/modules/_collection.js","webpack://Oidc/./node_modules/core-js/modules/_core.js","webpack://Oidc/./node_modules/core-js/modules/_create-property.js","webpack://Oidc/./node_modules/core-js/modules/_ctx.js","webpack://Oidc/./node_modules/core-js/modules/_date-to-iso-string.js","webpack://Oidc/./node_modules/core-js/modules/_date-to-primitive.js","webpack://Oidc/./node_modules/core-js/modules/_defined.js","webpack://Oidc/./node_modules/core-js/modules/_descriptors.js","webpack://Oidc/./node_modules/core-js/modules/_dom-create.js","webpack://Oidc/./node_modules/core-js/modules/_enum-bug-keys.js","webpack://Oidc/./node_modules/core-js/modules/_enum-keys.js","webpack://Oidc/./node_modules/core-js/modules/_export.js","webpack://Oidc/./node_modules/core-js/modules/_fails-is-regexp.js","webpack://Oidc/./node_modules/core-js/modules/_fails.js","webpack://Oidc/./node_modules/core-js/modules/_fix-re-wks.js","webpack://Oidc/./node_modules/core-js/modules/_flags.js","webpack://Oidc/./node_modules/core-js/modules/_flatten-into-array.js","webpack://Oidc/./node_modules/core-js/modules/_for-of.js","webpack://Oidc/./node_modules/core-js/modules/_function-to-string.js","webpack://Oidc/./node_modules/core-js/modules/_global.js","webpack://Oidc/./node_modules/core-js/modules/_has.js","webpack://Oidc/./node_modules/core-js/modules/_hide.js","webpack://Oidc/./node_modules/core-js/modules/_html.js","webpack://Oidc/./node_modules/core-js/modules/_ie8-dom-define.js","webpack://Oidc/./node_modules/core-js/modules/_inherit-if-required.js","webpack://Oidc/./node_modules/core-js/modules/_invoke.js","webpack://Oidc/./node_modules/core-js/modules/_iobject.js","webpack://Oidc/./node_modules/core-js/modules/_is-array-iter.js","webpack://Oidc/./node_modules/core-js/modules/_is-array.js","webpack://Oidc/./node_modules/core-js/modules/_is-integer.js","webpack://Oidc/./node_modules/core-js/modules/_is-object.js","webpack://Oidc/./node_modules/core-js/modules/_is-regexp.js","webpack://Oidc/./node_modules/core-js/modules/_iter-call.js","webpack://Oidc/./node_modules/core-js/modules/_iter-create.js","webpack://Oidc/./node_modules/core-js/modules/_iter-define.js","webpack://Oidc/./node_modules/core-js/modules/_iter-detect.js","webpack://Oidc/./node_modules/core-js/modules/_iter-step.js","webpack://Oidc/./node_modules/core-js/modules/_iterators.js","webpack://Oidc/./node_modules/core-js/modules/_library.js","webpack://Oidc/./node_modules/core-js/modules/_math-expm1.js","webpack://Oidc/./node_modules/core-js/modules/_math-fround.js","webpack://Oidc/./node_modules/core-js/modules/_math-log1p.js","webpack://Oidc/./node_modules/core-js/modules/_math-scale.js","webpack://Oidc/./node_modules/core-js/modules/_math-sign.js","webpack://Oidc/./node_modules/core-js/modules/_meta.js","webpack://Oidc/./node_modules/core-js/modules/_metadata.js","webpack://Oidc/./node_modules/core-js/modules/_microtask.js","webpack://Oidc/./node_modules/core-js/modules/_new-promise-capability.js","webpack://Oidc/./node_modules/core-js/modules/_object-assign.js","webpack://Oidc/./node_modules/core-js/modules/_object-create.js","webpack://Oidc/./node_modules/core-js/modules/_object-dp.js","webpack://Oidc/./node_modules/core-js/modules/_object-dps.js","webpack://Oidc/./node_modules/core-js/modules/_object-forced-pam.js","webpack://Oidc/./node_modules/core-js/modules/_object-gopd.js","webpack://Oidc/./node_modules/core-js/modules/_object-gopn-ext.js","webpack://Oidc/./node_modules/core-js/modules/_object-gopn.js","webpack://Oidc/./node_modules/core-js/modules/_object-gops.js","webpack://Oidc/./node_modules/core-js/modules/_object-gpo.js","webpack://Oidc/./node_modules/core-js/modules/_object-keys-internal.js","webpack://Oidc/./node_modules/core-js/modules/_object-keys.js","webpack://Oidc/./node_modules/core-js/modules/_object-pie.js","webpack://Oidc/./node_modules/core-js/modules/_object-sap.js","webpack://Oidc/./node_modules/core-js/modules/_object-to-array.js","webpack://Oidc/./node_modules/core-js/modules/_own-keys.js","webpack://Oidc/./node_modules/core-js/modules/_parse-float.js","webpack://Oidc/./node_modules/core-js/modules/_parse-int.js","webpack://Oidc/./node_modules/core-js/modules/_perform.js","webpack://Oidc/./node_modules/core-js/modules/_promise-resolve.js","webpack://Oidc/./node_modules/core-js/modules/_property-desc.js","webpack://Oidc/./node_modules/core-js/modules/_redefine-all.js","webpack://Oidc/./node_modules/core-js/modules/_redefine.js","webpack://Oidc/./node_modules/core-js/modules/_regexp-exec-abstract.js","webpack://Oidc/./node_modules/core-js/modules/_regexp-exec.js","webpack://Oidc/./node_modules/core-js/modules/_replacer.js","webpack://Oidc/./node_modules/core-js/modules/_same-value.js","webpack://Oidc/./node_modules/core-js/modules/_set-collection-from.js","webpack://Oidc/./node_modules/core-js/modules/_set-collection-of.js","webpack://Oidc/./node_modules/core-js/modules/_set-proto.js","webpack://Oidc/./node_modules/core-js/modules/_set-species.js","webpack://Oidc/./node_modules/core-js/modules/_set-to-string-tag.js","webpack://Oidc/./node_modules/core-js/modules/_shared-key.js","webpack://Oidc/./node_modules/core-js/modules/_shared.js","webpack://Oidc/./node_modules/core-js/modules/_species-constructor.js","webpack://Oidc/./node_modules/core-js/modules/_strict-method.js","webpack://Oidc/./node_modules/core-js/modules/_string-at.js","webpack://Oidc/./node_modules/core-js/modules/_string-context.js","webpack://Oidc/./node_modules/core-js/modules/_string-html.js","webpack://Oidc/./node_modules/core-js/modules/_string-pad.js","webpack://Oidc/./node_modules/core-js/modules/_string-repeat.js","webpack://Oidc/./node_modules/core-js/modules/_string-trim.js","webpack://Oidc/./node_modules/core-js/modules/_string-ws.js","webpack://Oidc/./node_modules/core-js/modules/_task.js","webpack://Oidc/./node_modules/core-js/modules/_to-absolute-index.js","webpack://Oidc/./node_modules/core-js/modules/_to-index.js","webpack://Oidc/./node_modules/core-js/modules/_to-integer.js","webpack://Oidc/./node_modules/core-js/modules/_to-iobject.js","webpack://Oidc/./node_modules/core-js/modules/_to-length.js","webpack://Oidc/./node_modules/core-js/modules/_to-object.js","webpack://Oidc/./node_modules/core-js/modules/_to-primitive.js","webpack://Oidc/./node_modules/core-js/modules/_typed-array.js","webpack://Oidc/./node_modules/core-js/modules/_typed-buffer.js","webpack://Oidc/./node_modules/core-js/modules/_typed.js","webpack://Oidc/./node_modules/core-js/modules/_uid.js","webpack://Oidc/./node_modules/core-js/modules/_user-agent.js","webpack://Oidc/./node_modules/core-js/modules/_validate-collection.js","webpack://Oidc/./node_modules/core-js/modules/_wks-define.js","webpack://Oidc/./node_modules/core-js/modules/_wks-ext.js","webpack://Oidc/./node_modules/core-js/modules/_wks.js","webpack://Oidc/./node_modules/core-js/modules/core.get-iterator-method.js","webpack://Oidc/./node_modules/core-js/modules/core.regexp.escape.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.copy-within.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.every.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.fill.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.filter.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.find-index.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.find.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.for-each.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.from.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.index-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.is-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.iterator.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.join.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.last-index-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.map.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.of.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.reduce-right.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.reduce.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.slice.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.some.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.sort.js","webpack://Oidc/./node_modules/core-js/modules/es6.array.species.js","webpack://Oidc/./node_modules/core-js/modules/es6.date.now.js","webpack://Oidc/./node_modules/core-js/modules/es6.date.to-iso-string.js","webpack://Oidc/./node_modules/core-js/modules/es6.date.to-json.js","webpack://Oidc/./node_modules/core-js/modules/es6.date.to-primitive.js","webpack://Oidc/./node_modules/core-js/modules/es6.date.to-string.js","webpack://Oidc/./node_modules/core-js/modules/es6.function.bind.js","webpack://Oidc/./node_modules/core-js/modules/es6.function.has-instance.js","webpack://Oidc/./node_modules/core-js/modules/es6.function.name.js","webpack://Oidc/./node_modules/core-js/modules/es6.map.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.acosh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.asinh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.atanh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.cbrt.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.clz32.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.cosh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.expm1.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.fround.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.hypot.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.imul.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.log10.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.log1p.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.log2.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.sign.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.sinh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.tanh.js","webpack://Oidc/./node_modules/core-js/modules/es6.math.trunc.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.constructor.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.epsilon.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.is-finite.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.is-integer.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.is-nan.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.is-safe-integer.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.max-safe-integer.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.min-safe-integer.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.parse-float.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.parse-int.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.to-fixed.js","webpack://Oidc/./node_modules/core-js/modules/es6.number.to-precision.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.assign.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.create.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.define-properties.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.define-property.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.freeze.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.get-own-property-descriptor.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.get-own-property-names.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.get-prototype-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.is-extensible.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.is-frozen.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.is-sealed.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.is.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.keys.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.prevent-extensions.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.seal.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.set-prototype-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.object.to-string.js","webpack://Oidc/./node_modules/core-js/modules/es6.parse-float.js","webpack://Oidc/./node_modules/core-js/modules/es6.parse-int.js","webpack://Oidc/./node_modules/core-js/modules/es6.promise.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.apply.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.construct.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.define-property.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.delete-property.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.enumerate.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.get-own-property-descriptor.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.get-prototype-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.get.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.has.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.is-extensible.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.own-keys.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.prevent-extensions.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.set-prototype-of.js","webpack://Oidc/./node_modules/core-js/modules/es6.reflect.set.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.constructor.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.exec.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.flags.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.match.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.replace.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.search.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.split.js","webpack://Oidc/./node_modules/core-js/modules/es6.regexp.to-string.js","webpack://Oidc/./node_modules/core-js/modules/es6.set.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.anchor.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.big.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.blink.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.bold.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.code-point-at.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.ends-with.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.fixed.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.fontcolor.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.fontsize.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.from-code-point.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.includes.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.italics.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.iterator.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.link.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.raw.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.repeat.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.small.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.starts-with.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.strike.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.sub.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.sup.js","webpack://Oidc/./node_modules/core-js/modules/es6.string.trim.js","webpack://Oidc/./node_modules/core-js/modules/es6.symbol.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.array-buffer.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.data-view.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.float32-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.float64-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.int16-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.int32-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.int8-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.uint16-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.uint32-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.uint8-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.typed.uint8-clamped-array.js","webpack://Oidc/./node_modules/core-js/modules/es6.weak-map.js","webpack://Oidc/./node_modules/core-js/modules/es6.weak-set.js","webpack://Oidc/./node_modules/core-js/modules/es7.array.flat-map.js","webpack://Oidc/./node_modules/core-js/modules/es7.array.flatten.js","webpack://Oidc/./node_modules/core-js/modules/es7.array.includes.js","webpack://Oidc/./node_modules/core-js/modules/es7.asap.js","webpack://Oidc/./node_modules/core-js/modules/es7.error.is-error.js","webpack://Oidc/./node_modules/core-js/modules/es7.global.js","webpack://Oidc/./node_modules/core-js/modules/es7.map.from.js","webpack://Oidc/./node_modules/core-js/modules/es7.map.of.js","webpack://Oidc/./node_modules/core-js/modules/es7.map.to-json.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.clamp.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.deg-per-rad.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.degrees.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.fscale.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.iaddh.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.imulh.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.isubh.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.rad-per-deg.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.radians.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.scale.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.signbit.js","webpack://Oidc/./node_modules/core-js/modules/es7.math.umulh.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.define-getter.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.define-setter.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.entries.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.get-own-property-descriptors.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.lookup-getter.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.lookup-setter.js","webpack://Oidc/./node_modules/core-js/modules/es7.object.values.js","webpack://Oidc/./node_modules/core-js/modules/es7.observable.js","webpack://Oidc/./node_modules/core-js/modules/es7.promise.finally.js","webpack://Oidc/./node_modules/core-js/modules/es7.promise.try.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.define-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.delete-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.get-metadata-keys.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.get-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.get-own-metadata-keys.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.get-own-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.has-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.has-own-metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.reflect.metadata.js","webpack://Oidc/./node_modules/core-js/modules/es7.set.from.js","webpack://Oidc/./node_modules/core-js/modules/es7.set.of.js","webpack://Oidc/./node_modules/core-js/modules/es7.set.to-json.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.at.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.match-all.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.pad-end.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.pad-start.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.trim-left.js","webpack://Oidc/./node_modules/core-js/modules/es7.string.trim-right.js","webpack://Oidc/./node_modules/core-js/modules/es7.symbol.async-iterator.js","webpack://Oidc/./node_modules/core-js/modules/es7.symbol.observable.js","webpack://Oidc/./node_modules/core-js/modules/es7.system.global.js","webpack://Oidc/./node_modules/core-js/modules/es7.weak-map.from.js","webpack://Oidc/./node_modules/core-js/modules/es7.weak-map.of.js","webpack://Oidc/./node_modules/core-js/modules/es7.weak-set.from.js","webpack://Oidc/./node_modules/core-js/modules/es7.weak-set.of.js","webpack://Oidc/./node_modules/core-js/modules/web.dom.iterable.js","webpack://Oidc/./node_modules/core-js/modules/web.immediate.js","webpack://Oidc/./node_modules/core-js/modules/web.timers.js","webpack://Oidc/./node_modules/core-js/shim.js","webpack://Oidc/./node_modules/ieee754/index.js","webpack://Oidc/./node_modules/uuid/lib/bytesToUuid.js","webpack://Oidc/./node_modules/uuid/lib/rng-browser.js","webpack://Oidc/./node_modules/uuid/v4.js","webpack://Oidc/(webpack)/buildin/global.js","webpack://Oidc/./src/AccessTokenEvents.js","webpack://Oidc/./src/CheckSessionIFrame.js","webpack://Oidc/./src/CordovaIFrameNavigator.js","webpack://Oidc/./src/CordovaPopupNavigator.js","webpack://Oidc/./src/CordovaPopupWindow.js","webpack://Oidc/./src/ErrorResponse.js","webpack://Oidc/./src/Event.js","webpack://Oidc/./src/Global.js","webpack://Oidc/./src/IFrameNavigator.js","webpack://Oidc/./src/IFrameWindow.js","webpack://Oidc/./src/InMemoryWebStorage.js","webpack://Oidc/./src/JoseUtil.js","webpack://Oidc/./src/JoseUtilImpl.js","webpack://Oidc/./src/JsonService.js","webpack://Oidc/./src/Log.js","webpack://Oidc/./src/MetadataService.js","webpack://Oidc/./src/OidcClient.js","webpack://Oidc/./src/OidcClientSettings.js","webpack://Oidc/./src/PopupNavigator.js","webpack://Oidc/./src/PopupWindow.js","webpack://Oidc/./src/RedirectNavigator.js","webpack://Oidc/./src/ResponseValidator.js","webpack://Oidc/./src/SessionMonitor.js","webpack://Oidc/./src/SigninRequest.js","webpack://Oidc/./src/SigninResponse.js","webpack://Oidc/./src/SigninState.js","webpack://Oidc/./src/SignoutRequest.js","webpack://Oidc/./src/SignoutResponse.js","webpack://Oidc/./src/SilentRenewService.js","webpack://Oidc/./src/State.js","webpack://Oidc/./src/Timer.js","webpack://Oidc/./src/TokenClient.js","webpack://Oidc/./src/TokenRevocationClient.js","webpack://Oidc/./src/UrlUtility.js","webpack://Oidc/./src/User.js","webpack://Oidc/./src/UserInfoService.js","webpack://Oidc/./src/UserManager.js","webpack://Oidc/./src/UserManagerEvents.js","webpack://Oidc/./src/UserManagerSettings.js","webpack://Oidc/./src/WebStorageStateStore.js","webpack://Oidc/./src/crypto/jsrsasign.js","webpack://Oidc/./src/random.js","webpack://Oidc/./version.js"],"names":["Version","Log","OidcClient","OidcClientSettings","WebStorageStateStore","InMemoryWebStorage","UserManager","AccessTokenEvents","MetadataService","CordovaPopupNavigator","CordovaIFrameNavigator","CheckSessionIFrame","TokenRevocationClient","SessionMonitor","Global","User","navigator","userAgent","window","YAHOO","undefined","lang","extend","g","h","f","Error","d","prototype","constructor","superclass","Object","b","e","c","test","j","i","length","l","k","a","CryptoJS","lib","Base","n","p","o","mixIn","hasOwnProperty","init","$super","apply","arguments","create","toString","clone","WordArray","words","sigBytes","stringify","concat","t","q","s","clamp","r","ceil","call","slice","random","push","m","enc","Hex","join","parse","parseInt","substr","Latin1","String","fromCharCode","charCodeAt","Utf8","decodeURIComponent","escape","unescape","encodeURIComponent","BufferedBlockAlgorithm","reset","_data","_nDataBytes","_append","_process","w","x","blockSize","v","u","max","_minBufferSize","min","_doProcessBlock","splice","Hasher","cfg","_doReset","update","finalize","_doFinalize","_createHelper","_createHmacHelper","HMAC","algo","Math","x64","Word","high","low","toX32","Base64","_map","charAt","indexOf","sqrt","pow","SHA256","_hash","floor","HmacSHA256","T","ea","SHA512","F","G","H","I","J","X","K","Y","L","Z","M","$","N","aa","O","ba","P","ca","Q","z","A","y","U","B","R","C","S","D","V","E","W","fa","da","HmacSHA512","SHA384","HmacSHA384","b64map","b64pad","hex2b64","substring","b64tohex","int2char","b64toBA","Array","dbits","canary","j_lm","BigInteger","fromNumber","fromString","nbi","am1","am2","am3","appName","am","DB","DM","DV","BI_FP","FV","F1","F2","BI_RM","BI_RC","rr","vv","intAt","bnpCopyTo","bnpFromInt","nbv","fromInt","bnpFromString","fromRadix","ZERO","subTo","bnpClamp","bnToString","negate","toRadix","bnNegate","bnAbs","bnCompareTo","nbits","bnBitLength","bnpDLShiftTo","bnpDRShiftTo","bnpLShiftTo","bnpRShiftTo","bnpSubTo","bnpMultiplyTo","abs","bnpSquareTo","bnpDivRemTo","copyTo","lShiftTo","dlShiftTo","compareTo","ONE","drShiftTo","rShiftTo","bnMod","divRemTo","Classic","cConvert","mod","cRevert","cReduce","cMulTo","multiplyTo","reduce","cSqrTo","squareTo","convert","revert","mulTo","sqrTo","bnpInvDigit","Montgomery","mp","invDigit","mpl","mph","um","mt2","montConvert","montRevert","montReduce","montSqrTo","montMulTo","bnpIsEven","bnpExp","bnModPowInt","isEven","exp","bitLength","modPowInt","bnClone","bnIntValue","bnByteValue","bnShortValue","bnpChunkSize","LN2","log","bnSigNum","bnpToRadix","signum","chunkSize","intValue","bnpFromRadix","dMultiply","dAddOffset","bnpFromNumber","testBit","bitwiseTo","shiftLeft","op_or","isProbablePrime","nextBytes","bnToByteArray","bnEquals","bnMin","bnMax","bnpBitwiseTo","op_and","bnAnd","bnOr","op_xor","bnXor","op_andnot","bnAndNot","bnNot","bnShiftLeft","bnShiftRight","lbit","bnGetLowestSetBit","cbit","bnBitCount","bnTestBit","bnpChangeBit","bnSetBit","changeBit","bnClearBit","bnFlipBit","bnpAddTo","bnAdd","addTo","bnSubtract","bnMultiply","bnSquare","bnDivide","bnRemainder","bnDivideAndRemainder","bnpDMultiply","bnpDAddOffset","NullExp","nNop","nMulTo","nSqrTo","bnPow","bnpMultiplyLowerTo","bnpMultiplyUpperTo","Barrett","r2","q3","mu","divide","barrettConvert","barrettRevert","barrettReduce","multiplyUpperTo","multiplyLowerTo","barrettSqrTo","barrettMulTo","bnModPow","bnGCD","getLowestSetBit","bnpModInt","bnModInverse","subtract","add","lowprimes","lplim","bnIsProbablePrime","modInt","millerRabin","bnpMillerRabin","shiftRight","modPow","byteValue","shortValue","toByteArray","equals","and","or","xor","andNot","not","bitCount","setBit","clearBit","flipBit","multiply","remainder","divideAndRemainder","modInverse","gcd","square","Arcfour","ARC4init","ARC4next","next","prng_newstate","rng_psize","rng_state","rng_pool","rng_pptr","rng_seed_int","rng_seed_time","Date","getTime","crypto","msCrypto","getRandomValues","ua","Uint8Array","appVersion","rng_get_byte","rng_get_bytes","SecureRandom","parseBigInt","linebrk","byte2Hex","pkcs1pad2","oaep_mgf1_arr","oaep_pad","KJUR","MessageDigest","Util","getCanonicalAlgName","getHashLength","hextorstr","hashHex","rstrtohex","RSAKey","dmp1","dmq1","coeff","RSASetPublic","isPublic","isPrivate","RSADoPublic","RSAEncrypt","doPublic","RSAEncryptOAEP","setPublic","encrypt","encryptOAEP","type","ECFieldElementFp","feFpEquals","feFpToBigInteger","feFpNegate","feFpAdd","toBigInteger","feFpSubtract","feFpMultiply","feFpSquare","feFpDivide","ECPointFp","curve","zinv","pointFpGetX","fromBigInteger","pointFpGetY","pointFpEquals","isInfinity","pointFpIsInfinity","pointFpNegate","pointFpAdd","twice","getInfinity","pointFpTwice","pointFpMultiply","pointFpMultiplyTwo","getX","getY","multiplyTwo","ECCurveFp","infinity","curveFpGetQ","curveFpGetA","curveFpGetB","curveFpEquals","curveFpGetInfinity","curveFpFromBigInteger","curveFpDecodePointHex","getQ","getA","getB","decodePointHex","getByteLength","getEncoded","toByteArrayUnsigned","unshift","decodeFrom","decodeFromHex","add2D","twice2D","valueOf","multiply2D","isOnCurve","validate","jsonParse","RegExp","match","replace","shift","asn1","ASN1Util","integerToByteHex","bigIntToMinTwosComplementsHex","getPEMStringFromHex","hextopem","newObject","DERBoolean","DERInteger","DERBitString","DEROctetString","DERNull","DERObjectIdentifier","DEREnumerated","DERUTF8String","DERNumericString","DERPrintableString","DERTeletexString","DERIA5String","DERUTCTime","DERGeneralizedTime","DERSequence","DERSet","DERTaggedObject","keys","array","tag","explicit","obj","jsonToASN1HEX","getEncodedHex","oidHexToInt","oidIntToHex","split","ASN1Object","getLengthHexFromValue","hV","hTLV","isModified","getFreshValueHex","hL","hT","getValueHex","DERAbstractString","getString","setString","utf8tohex","toLowerCase","setStringHex","str","hex","DERAbstractTime","localDateToUTC","utc","getTimezoneOffset","formatDate","zeroPadding","getFullYear","getMonth","getDate","getHours","getMinutes","getSeconds","getMilliseconds","stohex","setByDateValue","UTC","setByDate","DERAbstractStructured","setByASN1ObjectArray","asn1Array","appendASN1Object","setByBigInteger","setByInteger","setValueHex","bigint","setHexValueIncludingUnusedBits","setUnusedBitsAndHexValue","setByBinaryString","setByBooleanArray","newFalseArray","bin","setValueOidString","setValueName","x509","OID","name2oid","oid","name","date","withMillis","millis","sortFlag","sort","sortflag","isExplicit","asn1Object","setASN1Object","ASN1HEX","getLblen","getL","getVblen","getVidx","getV","getTLV","getNextSiblingIdx","getChildIdx","getNthChildIdx","getIdxbyList","getTLVbyList","getVbyList","hextooidstr","dump","ommit_long_octet","isASN1HEX","oid2name","hextoutf8","oidname","JSON","x509ExtName","isHex","Base64x","stoBA","BAtos","BAtohex","stob64","stob64u","b64tob64u","b64utos","b64utob64","hextob64u","b64utohex","utf8tob64u","b64utoutf8","Buffer","uricmptohex","encodeURIComponentAll","hextouricmp","utf8tob64","b64toutf8","hextob64","hextob64nl","b64nltohex","pemtohex","hextoArrayBuffer","ArrayBuffer","DataView","setUint8","ArrayBuffertohex","byteLength","getUint8","zulutomsec","zulutosec","zulutodate","datetozulu","getUTCFullYear","getUTCMonth","getUTCDate","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","ipv6tohex","repeat","hextoipv6","hextoip","iptohex","newline_toUnix","newline_toDos","isInteger","isBase64","isBase64URL","isIntegerArray","hextoposhex","intarystrtohex","map","strdiffidx","DIGESTINFOHEAD","sha1","sha224","sha256","sha384","sha512","md2","md5","ripemd160","DEFAULTPROVIDER","hmacmd5","hmacsha1","hmacsha224","hmacsha256","hmacsha384","hmacsha512","hmacripemd160","MD5withRSA","SHA1withRSA","SHA224withRSA","SHA256withRSA","SHA384withRSA","SHA512withRSA","RIPEMD160withRSA","MD5withECDSA","SHA1withECDSA","SHA224withECDSA","SHA256withECDSA","SHA384withECDSA","SHA512withECDSA","RIPEMD160withECDSA","SHA1withDSA","SHA224withDSA","SHA256withDSA","MD5withRSAandMGF1","SHA1withRSAandMGF1","SHA224withRSAandMGF1","SHA256withRSAandMGF1","SHA384withRSAandMGF1","SHA512withRSAandMGF1","RIPEMD160withRSAandMGF1","CRYPTOJSMESSAGEDIGESTNAME","MD5","SHA1","SHA224","RIPEMD160","getDigestInfoHex","getPaddedDigestInfoHex","hashString","alg","digestString","digestHex","prov","sha256Hex","sha512Hex","SECURERANDOMGEN","getRandomHexOfNbytes","getRandomBigIntegerOfNbytes","getRandomHexOfNbits","getRandomBigIntegerOfNbits","getRandomBigIntegerZeroToMax","getRandomBigIntegerMinToMax","setAlgAndProvider","md","updateString","updateHex","digest","sjcl","hash","codec","toBits","fromBits","algName","provName","HASHLENGTH","Mac","algProv","mac","pass","doFinal","doFinalString","doFinalHex","setPassword","utf8","rstr","b64","b64u","Signature","_setAlgNames","mdAlgName","pubkeyAlgName","_zeroPaddingOfSignature","KEYUTIL","getKey","prvKey","state","pubKey","sign","sHashHex","ecprvhex","eccurvename","ECDSA","hSign","signHex","signWithMessageHashPSS","pssSaltLen","signWithMessageHash","DSA","signString","verify","ecpubhex","verifyHex","verifyWithMessageHashPSS","verifyWithMessageHash","algProvName","initParams","psssaltlen","prvkeypem","prvkeypas","Cipher","getAlgByKeyAndName","decrypt","decryptOAEP","oidhex2name","getBigRandom","setNamedCurve","ecparams","ECParameterDB","getByName","prvKeyHex","pubKeyHex","curveName","setPrivateKeyHex","setPublicKeyHex","getPublicKeyXYHex","keylen","getShortNISTPCurveName","generateKeyPairHex","biRSSigToASN1Sig","fromByteArrayUnsigned","serializeSig","parseSigHex","verifyRaw","Bitcoin","isArray","parseSig","toByteArraySigned","parseSigCompact","readPKCS5PrvKeyHex","getName","readPKCS8PrvKeyHex","readPKCS8PubKeyHex","readCertPubKeyHex","prv","pub","parseSigHexInHexRS","asn1SigToConcatSig","concatSigToASN1Sig","hexRSSigToASN1Sig","regist","AES","TripleDES","DES","key","iv","ciphertext","proc","eproc","ivlen","cipher","ivsalt","data","keyhex","ivhex","version","parsePKCS5PEM","getKeyAndUnusedIvByPasscodeAndIvsalt","decryptKeyB64","getDecryptedKeyHex","getEncryptedPKCS5PEMFromPrvKeyHex","toUpperCase","parseHexOfEncryptedPKCS8","encryptionSchemeAlg","encryptionSchemeIV","pbkdf2Salt","pbkdf2Iter","getPBKDF2KeyHexFromParam","PBKDF2","keySize","iterations","_getPlainPKCS8HexFromEncryptedPKCS8PEM","getKeyFromEncryptedPKCS8PEM","getKeyFromPlainPrivatePKCS8Hex","parsePlainPrivatePKCS8Hex","algparam","algoid","keyidx","getKeyFromPlainPrivatePKCS8PEM","_getKeyFromPublicPKCS8Hex","parsePublicRawRSAKeyHex","parsePublicPKCS8Hex","xy","kty","dp","dq","co","qi","setPrivateEx","setPrivate","crv","X509","getPublicKeyFromCertHex","getPublicKeyFromCertPEM","generateKeypair","generate","prvKeyObj","pubKeyObj","getPEM","SubjectPublicKeyInfo","seq","octstr","bitstr","getKeyFromCSRPEM","getKeyFromCSRHex","parseCSRHex","p8pubkeyhex","getJWKFromKey","getPosArrayOfChildrenFromHex","getHexValueArrayOfChildrenFromHex","readPrivateKeyFromPEMString","readPKCS5PubKeyHex","readCertHex","getPublicKeyHex","_RE_HEXDECONLY","compile","_rsasign_getHexPaddedDigestInfoForString","doPrivate","pss_mgf1_str","signPSS","_rsasign_getDecryptSignatureBI","_rsasign_getHexDigestInfoFromSig","_rsasign_getAlgNameAndHashFromHexDisgestInfo","verifyPSS","SALT_LEN_HLEN","SALT_LEN_MAX","SALT_LEN_RECOVER","foffset","aExtInfo","getVersion","getSerialNumberHex","getSignatureAlgorithmField","getIssuerHex","getIssuerString","hex2dn","getSubjectHex","getSubjectString","getNotBefore","getNotAfter","getPublicKeyIdx","getPublicKeyContentIdx","getPublicKey","getSignatureAlgorithmName","getSignatureValueHex","verifySignature","parseExt","critical","vidx","getExtInfo","getExtBasicConstraints","cA","pathLen","getExtKeyUsageBin","getExtKeyUsageString","KEYUSAGE_NAME","getExtSubjectKeyIdentifier","getExtAuthorityKeyIdentifier","kid","getExtExtKeyUsageName","getExtSubjectAltName","getExtSubjectAltName2","getExtCRLDistributionPointsURI","getExtAIAInfo","ocsp","caissuer","getExtCertificatePolicies","id","cps","unotice","readCertPEM","getInfo","hex2rdn","hex2attrTypeValue","oid2atype","getPublicKeyInfoPropOfCertPEM","jws","JWS","isSafeJSONString","parseJWS","parsedJWS","sigvalH","headB64U","payloadB64U","sigvalB64U","si","sigvalBI","headS","payloadS","readSafeJSONString","jwsalg2sigalg","hASN1Sig","headerObj","payloadObj","headerPP","payloadPP","sigHex","verifyJWT","inArray","includedArray","iss","sub","aud","IntDate","getNow","verifyAt","gracePeriod","nbf","iat","jti","HS256","HS384","HS512","RS256","RS384","RS512","ES256","ES384","PS256","PS384","PS512","none","getEncodedSignatureValueFromJWS","getJWKthumbprint","get","getZulu","intDate2UTCString","toUTCString","intDate2Zulu","EDSA","_crypto","DefaultAccessTokenExpiringNotificationTime","accessTokenExpiringNotificationTime","accessTokenExpiringTimer","Timer","accessTokenExpiredTimer","_accessTokenExpiringNotificationTime","_accessTokenExpiring","_accessTokenExpired","load","container","access_token","expires_in","duration","debug","expiring","cancel","expired","unload","addAccessTokenExpiring","cb","addHandler","removeAccessTokenExpiring","removeHandler","addAccessTokenExpired","removeAccessTokenExpired","DefaultInterval","callback","client_id","url","interval","stopOnError","_callback","_client_id","_url","_interval","_stopOnError","idx","_frame_origin","_frame","document","createElement","style","visibility","position","display","width","height","src","Promise","resolve","onload","body","appendChild","_boundMessageEvent","_message","bind","addEventListener","origin","source","contentWindow","error","stop","start","session_state","_session_state","send","postMessage","_timer","setInterval","clearInterval","prepare","params","popupWindowFeatures","popup","CordovaPopupWindow","DefaultPopupFeatures","DefaultPopupTarget","_promise","reject","_resolve","_reject","features","target","popupWindowTarget","redirect_uri","startUrl","_isInAppBrowserInstalled","cordovaMetadata","some","navigate","_error","cordova","require","metadata","_popup","InAppBrowser","open","_exitCallbackEvent","_exitCallback","_loadStartCallbackEvent","_loadStartCallback","promise","event","_success","message","_cleanup","close","removeEventListener","ErrorResponse","error_description","error_uri","Event","_name","_callbacks","findIndex","item","raise","timer","handle","testing","request","_testing","setXMLHttpRequest","newRequest","location","localStorage","sessionStorage","XMLHttpRequest","IFrameNavigator","frame","IFrameWindow","notifyParent","DefaultTimeout","timeout","silentRequestTimeout","setTimeout","_timeout","clearTimeout","removeChild","_origin","frameElement","href","parent","protocol","host","getItem","setItem","value","removeItem","index","getOwnPropertyNames","JoseUtil","KeyUtil","AllowedSigningAlgs","getJoseUtil","parseJwt","jwt","token","header","payload","validateJwt","issuer","audience","clockSkew","now","timeInsensitive","x5c","_validateJwt","validateJwtAttributes","validAudience","azp","lowerNow","upperNow","then","hexToBase64Url","JsonService","additionalContentTypes","XMLHttpRequestCtor","jwtHandler","_contentTypes","_XMLHttpRequest","_jwtHandler","getJson","req","allowedContentTypes","status","contentType","getResponseHeader","found","find","startsWith","responseText","statusText","onerror","setRequestHeader","postForm","nopLogger","info","warn","NONE","ERROR","WARN","INFO","DEBUG","logger","level","args","from","OidcMetadataUrlPath","settings","JsonServiceCtor","_settings","_jsonService","getMetadata","metadataUrl","getIssuer","_getMetadataProperty","getAuthorizationEndpoint","getUserInfoEndpoint","getTokenEndpoint","optional","getCheckSessionIframe","getEndSessionEndpoint","getRevocationEndpoint","getKeysEndpoint","getSigningKeys","signingKeys","jwks_uri","keySet","_metadataUrl","authority","createSigninRequest","response_type","scope","prompt","max_age","ui_locales","id_token_hint","login_hint","acr_values","resource","request_uri","response_mode","extraQueryParams","extraTokenParams","request_type","skipUserInfo","stateStore","SigninRequest","isCode","_metadataService","signinRequest","client_secret","signinState","_stateStore","set","toStorageString","readSigninResponseState","removeState","useQuery","delimiter","response","SigninResponse","stateApi","remove","storedStateString","SigninState","fromStorageString","processSigninResponse","_validator","validateSigninResponse","createSignoutRequest","post_logout_redirect_uri","SignoutRequest","signoutState","readSignoutResponseState","SignoutResponse","stateKey","State","processSignoutResponse","validateSignoutResponse","clearStaleState","staleStateAge","validator","metadataService","DefaultResponseType","DefaultScope","DefaultStaleStateAge","DefaultClockSkewInSeconds","filterProtocolClaims","loadUserInfo","userInfoJwtIssuer","ResponseValidatorCtor","ResponseValidator","MetadataServiceCtor","_authority","_metadata","_signingKeys","_client_secret","_response_type","_scope","_redirect_uri","_post_logout_redirect_uri","_prompt","_display","_max_age","_ui_locales","_acr_values","_resource","_response_mode","_filterProtocolClaims","_loadUserInfo","_staleStateAge","_clockSkew","_userInfoJwtIssuer","_extraQueryParams","_extraTokenParams","PopupNavigator","PopupWindow","keepOpen","notifyOpener","CheckForPopupClosedInterval","_checkForPopupClosedTimer","_checkForPopupClosed","_id","focus","closed","opener","UrlUtility","parseUrlFragment","RedirectNavigator","useReplaceToNavigate","ProtocolClaims","UserInfoServiceCtor","UserInfoService","joseUtil","TokenClientCtor","TokenClient","_userInfoService","_joseUtil","_tokenClient","_processSigninParams","_validateTokens","_processClaims","nonce","id_token","code_verifier","code","isOpenIdConnect","profile","getClaims","claims","_mergeClaims","claims1","claims2","result","assign","values","forEach","_processCode","_validateIdTokenAndAccessToken","_validateIdToken","exchangeCode","tokenResponse","_validateIdTokenAttributes","clockSkewInSeconds","_validateAccessToken","_filterByAlg","filter","at_hash","hashAlg","hashBits","sha","left","left_b64u","userManager","CheckSessionIFrameCtor","_userManager","_CheckSessionIFrameCtor","events","addUserLoaded","_start","addUserUnloaded","_stop","getUser","user","monitorAnonymousSession","querySessionStatus","tmpUser","session","sid","catch","err","_sub","_sid","_checkSessionIFrame","_checkSessionInterval","_stopCheckSessionOnError","timerHandle","raiseEvent","_raiseUserSessionChanged","_raiseUserSignedOut","_raiseUserSignedIn","checkSessionInterval","stopCheckSessionOnError","oidc","isOidc","addQueryParam","code_challenge","isOAuth","OidcScope","token_type","expires_at","scopes","_nonce","_code_verifier","_code_challenge","_skipUserInfo","created","storageString","SilentRenewService","_tokenExpiring","signinSilent","_raiseSilentRenewError","_created","_request_type","storage","age","cutoff","getAllKeys","promises","all","TimerDuration","nowFunc","_nowFunc","expiration","_timerHandle","_expiration","timerDuration","diff","grant_type","exchangeRefreshToken","refresh_token","AccessTokenTypeHint","RefreshTokenTypeHint","_XMLHttpRequestCtor","revoke","required","_revoke","xhr","global","lastIndexOf","regex","counter","exec","prop","_getClaimsFromJwt","issuerPromise","SilentRenewServiceCtor","SessionMonitorCtor","TokenRevocationClientCtor","UserManagerSettings","_events","UserManagerEvents","_silentRenewService","automaticSilentRenew","startSilentRenew","monitorSession","_sessionMonitor","_tokenRevocationClient","_loadUser","removeUser","storeUser","signinRedirect","navParams","_signinStart","_redirectNavigator","signinRedirectCallback","_signinEnd","signinPopup","popup_redirect_uri","_signin","_popupNavigator","signinPopupCallback","_signinCallback","_useRefreshToken","includeIdTokenInSilentRenew","validateSubOnSilentRenew","current_sub","_signinSilentIframe","idTokenValidation","_validateIdTokenFromTokenRefreshToken","auth_time","silent_redirect_uri","_iframeNavigator","signinSilentCallback","signinCallback","signoutCallback","signoutRedirectCallback","signoutPopupCallback","query_status_response_type","navResponse","signinResponse","navigatorParams","signoutRedirect","postLogoutRedirectUri","_signoutStart","_signoutEnd","signoutPopup","popup_post_logout_redirect_uri","_signout","revokePromise","revokeAccessTokenOnSignout","_revokeInternal","signoutRequest","signoutResponse","revokeAccessToken","success","_revokeAccessTokenInternal","_revokeRefreshTokenInternal","atSuccess","rtSuccess","stopSilentRenew","_userStore","_userStoreKey","redirectNavigator","popupNavigator","iframeNavigator","userStore","_userLoaded","_userUnloaded","_silentRenewError","_userSignedIn","_userSignedOut","_userSessionChanged","removeUserLoaded","removeUserUnloaded","addSilentRenewError","removeSilentRenewError","addUserSignedIn","removeUserSignedIn","addUserSignedOut","removeUserSignedOut","addUserSessionChanged","removeUserSessionChanged","DefaultCheckSessionInterval","store","_popup_redirect_uri","_popup_post_logout_redirect_uri","_popupWindowFeatures","_popupWindowTarget","_silent_redirect_uri","_silentRequestTimeout","_automaticSilentRenew","_validateSubOnSilentRenew","_includeIdTokenInSilentRenew","_monitorSession","_monitorAnonymousSession","_query_status_response_type","_revokeAccessTokenOnSignout","prefix","_store","_prefix"],"mappings":"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IAAM+lB,UAAW/lB,KAAKf,MAAtB;QACoBA,M,GAAX8mB,O;YACe/lB,I;IAATkF,I,SAAAA,I;;aACQlF,I;IAARyiB,G,UAAAA,G;;aACSziB,I;IAATpY,I,UAAAA,I;;;;;;;;;;;;;;AC1Lf,8CAAa;;AAEb,mBAAO,CAAC,oDAAc;;AAEtB,mBAAO,CAAC,8GAA6B;;AAErC,mBAAO,CAAC,4EAA0B;;AAElC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA,CAAC,E;;;;;;;;;;;;AC3BD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,KAAK;AACL,cAAc;AACd;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,yDAAyD;AACzD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;;AAEA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA,WAAW;AACX;;AAEA;AACA;AACA,wCAAwC,WAAW;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,2BAA2B;AAC3B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;;AAEA;;AAEA,SAAS;AACT;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,oCAAoC,cAAc;AAClD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC,kBAAkB;AACnD;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,wBAAwB,iBAAiB;AACzC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,YAAY;AACZ;AACA;;AAEA;AACA,YAAY;AACZ;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA,8CAA8C,QAAQ;AACtD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa;AACb;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;;AAEA,WAAW;AACX;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C,QAAQ;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;;AC/tBY;;AAEZ;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,kCAAkC,SAAS;AAC3C;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,0CAA0C,UAAU;AACpD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;;;;;;;;;;;ACtJA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEY;;AAEZ,aAAa,mBAAO,CAAC,oDAAW;AAChC,cAAc,mBAAO,CAAC,gDAAS;AAC/B,cAAc,mBAAO,CAAC,oEAAS;;AAE/B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,qBAAqB,mDAAmD;AACxE;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,mBAAmB,UAAU;AAC7B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,0BAA0B;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA,uCAAuC,SAAS;AAChD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC;AACA;AACA;;AAEA;AACA;AACA,aAAa,iBAAiB;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gDAAgD,EAAE;AAClD;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,iBAAiB,SAAS;AAC1B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA,wBAAwB,eAAe;AACvC;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,wBAAwB,QAAQ;AAChC;AACA,qBAAqB,eAAe;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,YAAY;AAC7B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA,SAAS;AACT;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,qBAAqB,SAAS;AAC9B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,kBAAkB;AACnC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,mBAAmB,cAAc;AACjC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,uDAAuD,OAAO;AAC9D;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA,uDAAuD,OAAO;AAC9D;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB;AAClB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,qBAAqB,QAAQ;AAC7B;AACA;AACA,GAAG;AACH;AACA,eAAe,SAAS;AACxB;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,mBAAmB,SAAS;AAC5B;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,eAAe,iBAAiB;AAChC;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA,iBAAiB,YAAY;AAC7B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,iBAAiB,gBAAgB;AACjC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,iBAAiB,gBAAgB;AACjC;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AA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A2B,kBAAkB,EAAE;;AAE/C;AACA;AACA;AACA;AACA,GAAG,YAAY;AACf;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACtBA,iBAAiB;;AAEjB;AACA;AACA;;;;;;;;;;;;;ACJa;AACb,SAAS,mBAAO,CAAC,kEAAc;AAC/B,aAAa,mBAAO,CAAC,0EAAkB;AACvC,kBAAkB,mBAAO,CAAC,wEAAiB;AAC3C,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,YAAY,mBAAO,CAAC,4DAAW;AAC/B,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C,WAAW,mBAAO,CAAC,kEAAc;AACjC,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C,cAAc,mBAAO,CAAC,wDAAS;AAC/B,eAAe,mBAAO,CAAC,sFAAwB;AAC/C;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,OAAO;AAC9B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,6BAA6B;AAC7B,0BAA0B;AAC1B,0BAA0B;AAC1B,qBAAqB;AACrB;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,8EAA8E,OAAO;AACrF;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC,qBAAqB;AACrB,0BAA0B;AAC1B,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;;;;;;;;;;;AC/IA;AACA,cAAc,mBAAO,CAAC,8DAAY;AAClC,WAAW,mBAAO,CAAC,sFAAwB;AAC3C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACRa;AACb,kBAAkB,mBAAO,CAAC,wEAAiB;AAC3C,cAAc,mBAAO,CAAC,wDAAS;AAC/B,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,YAAY,mBAAO,CAAC,4DAAW;AAC/B,wBAAwB,mBAAO,CAAC,0EAAkB;AAClD,WAAW,mBAAO,CAAC,sDAAQ;AAC3B,eAAe,mBAAO,CAAC,sFAAwB;AAC/C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,qBAAqB;AACrB,qBAAqB;AACrB,0BAA0B;AAC1B;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;;;;;;;;;;;;;ACpFa;AACb,aAAa,mBAAO,CAAC,4DAAW;AAChC,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,gEAAa;AACpC,kBAAkB,mBAAO,CAAC,wEAAiB;AAC3C,WAAW,mBAAO,CAAC,wDAAS;AAC5B,YAAY,mBAAO,CAAC,4DAAW;AAC/B,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,eAAe,mBAAO,CAAC,kEAAc;AACrC,YAAY,mBAAO,CAAC,0DAAU;AAC9B,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C,qBAAqB,mBAAO,CAAC,kFAAsB;AACnD,wBAAwB,mBAAO,CAAC,sFAAwB;;AAExD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO,mCAAmC,gCAAgC,aAAa;AACvF,8BAA8B,mCAAmC,aAAa;AAC9E;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,qDAAqD;AACrD;AACA,kDAAkD,iBAAiB,EAAE;AACrE;AACA,wDAAwD,aAAa,EAAE,EAAE;AACzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;;AAEA;AACA;;;;;;;;;;;;ACpFA,6BAA6B;AAC7B,uCAAuC;;;;;;;;;;;;;ACD1B;AACb,sBAAsB,mBAAO,CAAC,kEAAc;AAC5C,iBAAiB,mBAAO,CAAC,0EAAkB;;AAE3C;AACA;AACA;AACA;;;;;;;;;;;;ACPA;AACA,gBAAgB,mBAAO,CAAC,oEAAe;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACnBa;AACb;AACA,YAAY,mBAAO,CAAC,0DAAU;AAC9B;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;ACzBY;AACb,eAAe,mBAAO,CAAC,kEAAc;AACrC,kBAAkB,mBAAO,CAAC,wEAAiB;AAC3C;;AAEA;AACA;AACA;AACA;;;;;;;;;;;;ACRA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACJA;AACA,kBAAkB,mBAAO,CAAC,0DAAU;AACpC,iCAAiC,QAAQ,mBAAmB,UAAU,EAAE,EAAE;AAC1E,CAAC;;;;;;;;;;;;ACHD,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,4DAAW;AAClC;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACNA;AACA;AACA;AACA;;;;;;;;;;;;ACHA;AACA,cAAc,mBAAO,CAAC,sEAAgB;AACtC,WAAW,mBAAO,CAAC,sEAAgB;AACnC,UAAU,mBAAO,CAAC,oEAAe;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;;;;;;;;;;;ACdA,aAAa,mBAAO,CAAC,4DAAW;AAChC,WAAW,mBAAO,CAAC,wDAAS;AAC5B,WAAW,mBAAO,CAAC,wDAAS;AAC5B,eAAe,mBAAO,CAAC,gEAAa;AACpC,UAAU,mBAAO,CAAC,sDAAQ;AAC1B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,kFAAkF,uBAAuB;AACzG,iEAAiE;AACjE,+DAA+D;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,eAAe;AACf,eAAe;AACf,eAAe;AACf,gBAAgB;AAChB;;;;;;;;;;;;AC1CA,YAAY,mBAAO,CAAC,sDAAQ;AAC5B;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK,YAAY;AACjB,GAAG;AACH;;;;;;;;;;;;ACXA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;;;;;;;;;;;;ACNa;AACb,mBAAO,CAAC,4EAAmB;AAC3B,eAAe,mBAAO,CAAC,gEAAa;AACpC,WAAW,mBAAO,CAAC,wDAAS;AAC5B,YAAY,mBAAO,CAAC,0DAAU;AAC9B,cAAc,mBAAO,CAAC,8DAAY;AAClC,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,iBAAiB,mBAAO,CAAC,sEAAgB;;AAEzC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,yBAAyB,4CAA4C;AACrE;AACA;AACA,CAAC;;AAED;AACA;;AAEA;AACA;AACA;AACA,6BAA6B,UAAU;AACvC;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,2BAA2B,mBAAmB,aAAa;AAC3D;AACA;AACA;AACA;AACA,6CAA6C,WAAW;AACxD;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,kBAAkB;AAClB;AACA,gBAAgB;AAChB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gCAAgC,qCAAqC;AACrE;AACA;AACA,2BAA2B,gCAAgC;AAC3D;AACA;AACA;;;;;;;;;;;;;AC/Fa;AACb;AACA,eAAe,mBAAO,CAAC,kEAAc;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA,cAAc,mBAAO,CAAC,gEAAa;AACnC,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,2BAA2B,mBAAO,CAAC,sDAAQ;;AAE3C;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACtCA,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,WAAW,mBAAO,CAAC,kEAAc;AACjC,kBAAkB,mBAAO,CAAC,0EAAkB;AAC5C,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,gBAAgB,mBAAO,CAAC,8FAA4B;AACpD;AACA;AACA;AACA,uCAAuC,iBAAiB,EAAE;AAC1D;AACA;AACA;AACA;AACA;AACA,mEAAmE,gBAAgB;AACnF;AACA;AACA,GAAG,4CAA4C,gCAAgC;AAC/E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AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACTD;AACA,WAAW,mBAAO,CAAC,kEAAc;AACjC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACtBA;AACA;AACA;AACA;;;;;;;;;;;;ACHA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACjBA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACJA,WAAW,mBAAO,CAAC,sDAAQ;AAC3B,eAAe,mBAAO,CAAC,kEAAc;AACrC,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,cAAc,mBAAO,CAAC,kEAAc;AACpC;AACA;AACA;AACA;AACA,cAAc,mBAAO,CAAC,0DAAU;AAChC,iDAAiD;AACjD,CAAC;AACD;AACA,qBAAqB;AACrB;AACA,SAAS;AACT,GAAG,EAAE;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACpDA,UAAU,mBAAO,CAAC,4DAAW;AAC7B,cAAc,mBAAO,CAAC,4DAAW;AACjC,aAAa,mBAAO,CAAC,4DAAW;AAChC,iDAAiD,mBAAO,CAAC,sEAAgB;;AAEzE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D,gBAAgB,EAAE;AAC5E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;AClDA,aAAa,mBAAO,CAAC,4DAAW;AAChC,gBAAgB,mBAAO,CAAC,wDAAS;AACjC;AACA;AACA;AACA,aAAa,mBAAO,CAAC,sDAAQ;;AAE7B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,uCAAuC,sBAAsB,EAAE;AAC/D;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;;;;;;;;;;;;ACpEa;AACb;AACA,gBAAgB,mBAAO,CAAC,oEAAe;;AAEvC;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA,cAAc,mBAAO,CAAC,sEAAgB;AACtC,WAAW,mBAAO,CAAC,sEAAgB;AACnC,UAAU,mBAAO,CAAC,oEAAe;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC,cAAc,mBAAO,CAAC,8DAAY;AAClC;;AAEA;AACA,6BAA6B,mBAAO,CAAC,0DAAU;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC,UAAU,EAAE;AAChD,mBAAmB,sCAAsC;AACzD,CAAC,qCAAqC;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,CAAC;;;;;;;;;;;;ACjCD;AACA,eAAe,mBAAO,CAAC,kEAAc;AACrC,UAAU,mBAAO,CAAC,oEAAe;AACjC,kBAAkB,mBAAO,CAAC,0EAAkB;AAC5C,eAAe,mBAAO,CAAC,oEAAe;AACtC,yBAAyB;AACzB;;AAEA;AACA;AACA;AACA,eAAe,mBAAO,CAAC,oEAAe;AACtC;AACA;AACA;AACA;AACA;AACA,EAAE,mBAAO,CAAC,wDAAS;AACnB,6BAA6B;AA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B,UAAU,mBAAO,CAAC,oEAAe;AACjC,aAAa,mBAAO,CAAC,4DAAW;AAChC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAM,mBAAO,CAAC,sDAAQ;AACtB;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACnFA,gBAAgB,mBAAO,CAAC,oEAAe;AACvC;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACNA;AACA,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,eAAe,mBAAO,CAAC,kEAAc;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACTA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACLA;AACA,cAAc,mBAAO,CAAC,8DAAY;AAClC,cAAc,mBAAO,CAAC,8DAAY;AAClC;AACA;AACA;;;;;;;;;;;;ACLA;AACA,gBAAgB,mBAAO,CAAC,oEAAe;AACvC;AACA;AACA,2DAA2D;AAC3D;;;;;;;;;;;;ACLA;AACA,cAAc,mBAAO,CAAC,8DAAY;AAClC;AACA;AACA;;;;;;;;;;;;ACJA;AACA,eAAe,mBAAO,CAAC,kEAAc;AACrC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACXa;AACb,IAAI,mBAAO,CAAC,sEAAgB;AAC5B,gBAAgB,mBAAO,CAAC,8DAAY;AACpC,eAAe,mBAAO,CAAC,4DAAW;AAClC,cAAc,mBAAO,CAAC,0DAAU;AAChC,gBAAgB,mBAAO,CAAC,4DAAW;AACnC,eAAe,mBAAO,CAAC,0DAAU;AACjC,gBAAgB,mBAAO,CAAC,wEAAiB;AACzC,YAAY,mBAAO,CAAC,sDAAQ;AAC5B,mBAAmB,mBAAO,CAAC,sEAAgB;AAC3C,qBAAqB,mBAAO,CAAC,0EAAkB;AAC/C,aAAa,mBAAO,CAAC,wDAAS;AAC9B,oBAAoB,mBAAO,CAAC,wEAAiB;AAC7C,kBAAkB,mBAAO,CAAC,oEAAe;AACzC,iBAAiB,mBAAO,CAAC,kEAAc;AACvC,gBAAgB,mBAAO,CAAC,gEAAa;AACrC,wBAAwB,mBAAO,CAAC,kFAAsB;AACtD,oBAAoB,mBAAO,CAAC,wEAAiB;AAC7C,YAAY,mBAAO,CAAC,sDAAQ;AAC5B,gBAAgB,mBAAO,CAAC,8DAAY;AACpC,iBAAiB,mBAAO,CAAC,kEAAc;AACvC,iBAAiB,mBAAO,CAAC,kEAAc;AACvC,oBAAoB,mBAAO,CAAC,0EAAkB;AAC9C,eAAe,mBAAO,CAAC,0EAAkB;AACzC,uBAAuB,mBAAO,CAAC,oEAAe;AAC9C,aAAa,mBAAO,CAAC,sEAAgB;AACrC,kBAAkB,mBAAO,CAAC,8FAA4B;AACtD,YAAY,mBAAO,CAAC,sDAAQ;AAC5B,YAAY,mBAAO,CAAC,sDAAQ;AAC5B,0BAA0B,mBAAO,CAAC,0EAAkB;AACpD,4BAA4B,mBAAO,CAAC,4EAAmB;AACvD,2BAA2B,mBAAO,CAAC,sFAAwB;AAC3D,uBAAuB,mBAAO,CAAC,kFAAsB;AACrD,kBAAkB,mBAAO,CAAC,kEAAc;AACxC,oBAAoB,mBAAO,CAAC,sEAAgB;AAC5C,mBAAmB,mBAAO,CAAC,sEAAgB;AAC3C,kBAAkB,mBAAO,CAAC,oEAAe;AACzC,wBAAwB,mBAAO,CAAC,kFAAsB;AACtD,YAAY,mBAAO,CAAC,kEAAc;AAClC,cAAc,mBAAO,CAAC,sEAAgB;AACtC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA,4BAA4B;AAC5B,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,iBAAiB,mBAAmB,0BAA0B,EAAE,EAAE;AAClE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yDAAyD,gCAAgC;AACzF;AACA,OAAO;AACP;AACA;AACA,6EAA6E,YAAY;AACzF;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yDAAyD,6CAA6C,EAAE;;AAExG;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL,mDAAmD;AACnD;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL,oCAAoC;AACpC;AACA,KAAK;AACL,wEAAwE;AACxE;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL,8DAA8D;AAC9D;AACA,KAAK;AACL,wEAAwE;AACxE;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;AAEH,yBAAyB,sBAAsB,EAAE,EAAE;AACnD;AACA;AACA;AACA;;AAEA,4CAA4C;AAC5C;AACA;AACA;AACA;AACA;AACA,8BAA8B,aAAa;AAC3C;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,sBAAsB,0BAA0B;AAChD,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,SAAS;AACT;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL,yBAAyB;AACzB,KAAK;AACL,uBAAuB;AACvB,2BAA2B;AAC3B,0BAA0B;AAC1B,2BAA2B;AAC3B,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,0BAA0B,aAAa;AACvC,OAAO;AACP;;AAEA;;AAEA;;AAEA;AACA;AACA,KAAK;;AAEL,uDAAuD,6BAA6B,EAAE;AACtF;AACA;AACA,KAAK;;AAEL;;AAEA;;AAEA;;AAEA,uDAAuD,YAAY;;AAEnE;;AAEA;;AAEA;AACA;AACA,KAAK,UAAU,gBAAgB;;AAE/B;AACA;AACA,KAAK;AACL;AACA,KAAK,WAAW,kCAAkC;;AAElD;AACA;AACA;AACA,CAAC,oCAAoC;;;;;;;;;;;;;AC/dxB;AACb,aAAa,mBAAO,CAAC,4DAAW;AAChC,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C,cAAc,mBAAO,CAAC,8DAAY;AAClC,aAAa,mBAAO,CAAC,0DAAU;AAC/B,WAAW,mBAAO,CAAC,wDAAS;AAC5B,kBAAkB,mBAAO,CAAC,wEAAiB;AAC3C,YAAY,mBAAO,CAAC,0DAAU;AAC9B,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,eAAe,mBAAO,CAAC,kEAAc;AACrC,cAAc,mBAAO,CAAC,gEAAa;AACnC,WAAW,mBAAO,CAAC,sEAAgB;AACnC,SAAS,mBAAO,CAAC,kEAAc;AAC/B,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,qBAAqB,mBAAO,CAAC,kFAAsB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,QAAQ,WAAW;AACnB;AACA;AACA,QAAQ,UAAU;AAClB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,WAAW;AACnB;AACA;AACA;AACA,QAAQ,WAAW;AACnB;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,yBAAyB,mBAAmB,uBAAuB,EAAE,EAAE;AACvE;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,WAAW;AAC5B;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,GAAG;AACH,CAAC;AACD;AACA;AACA,GAAG;AACH,yBAAyB;AACzB,GAAG;AACH,uBAAuB;AACvB,0BAA0B;AAC1B,0BAA0B;AAC1B;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,iDAAiD,iBAAiB;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACnRA,aAAa,mBAAO,CAAC,4DAAW;AAChC,WAAW,mBAAO,CAAC,wDAAS;AAC5B,UAAU,mBAAO,CAAC,sDAAQ;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;AC3BA;AACA;AACA;AACA;AACA;;;;;;;;;;;;ACJA,aAAa,mBAAO,CAAC,4DAAW;AAChC;;AAEA;;;;;;;;;;;;ACHA,eAAe,mBAAO,CAAC,kEAAc;AACrC;AACA;AACA;AACA;;;;;;;;;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AAC,4DAAW;;AAEjC,8BAA8B,YAAY,mBAAO,CAAC,oEAAe,GAAG;;;;;;;;;;;;ACHpE;AACA,cAAc,mBAAO,CAAC,4DAAW;;AAEjC;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACRD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC;;AAEA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACTD;AACA,cAAc,mBAAO,CAAC,4DAAW;;AAEjC,8BAA8B,qCAAqC;;;;;;;;;;;;ACHnE;AACA,cAAc,mBAAO,CAAC,4DAAW;;AAEjC,8BAA8B,sCAAsC;;;;;;;;;;;;ACHpE,cAAc,mBAAO,CAAC,4DAAW;AACjC,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C;AACA,+EAA+E,0BAA0B;;;;;;;;;;;;ACHzG,cAAc,mBAAO,CAAC,4DAAW;AACjC,gBAAgB,mBAAO,CAAC,kEAAc;AACtC;AACA,2EAA2E,sBAAsB;;;;;;;;;;;;;ACHpF;AACb,cAAc,mBAAO,CAAC,4DAAW;AACjC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,mBAAmB,mBAAO,CAAC,4EAAmB;AAC9C,aAAa,mBAAO,CAAC,0EAAkB;AACvC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA,MAAM,mBAAO,CAAC,0DAAU;AACxB;AACA,kBAAkB;AAClB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;A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lC,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,YAAY,mBAAO,CAAC,4DAAW;AAC/B,yBAAyB,mBAAO,CAAC,sFAAwB;AACzD,WAAW,mBAAO,CAAC,wDAAS;AAC5B,gBAAgB,mBAAO,CAAC,kEAAc;AACtC,iCAAiC,mBAAO,CAAC,4FAA2B;AACpE,cAAc,mBAAO,CAAC,8DAAY;AAClC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,qBAAqB,mBAAO,CAAC,8EAAoB;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;AACzB;AACA;;AAEA;AACA;AACA;AACA;AACA,+CAA+C,EAAE,mBAAO,CAAC,sDAAQ;AACjE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,YAAY;AACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oCAAoC;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA,WAAW;AACX,SAAS;AACT,OAAO;AACP;AACA;AACA;AACA;AACA,6CAA6C;AAC7C;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,mBAAmB,kCAAkC;AACrD,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,eAAe,uCAAuC;AACtD;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA,uBAAuB,0BAA0B;AACjD;AACA;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;AACH,kBAAkB,yBAAyB,KAAK;AAChD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,iBAAiB;AACjB,wBAAwB;AACxB,gBAAgB;AAChB,oBAAoB;AACpB,wBAAwB;AACxB,gBAAgB;AAChB,oBAAoB;AACpB;AACA,uBAAuB,mBAAO,CAAC,wEAAiB;AAChD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,0DAA0D,oBAAoB;AAC9E,mBAAO,CAAC,kFAAsB;AAC9B,mBAAO,CAAC,sEAAgB;AACxB,UAAU,mBAAO,CAAC,wDAAS;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,gDAAgD,mBAAO,CAAC,sEAAgB;AACxE;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;AC7RD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,eAAe,mBAAO,CAAC,kEAAc;AACrC,cAAc,mBAAO,CAAC,4DAAW,eAAe;AAChD;AACA;AACA,iCAAiC,mBAAO,CAAC,0DAAU;AACnD,sBAAsB,cAAc;AACpC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACfD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,aAAa,mBAAO,CAAC,0EAAkB;AACvC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,YAAY,mBAAO,CAAC,0DAAU;AAC9B,WAAW,mBAAO,CAAC,wDAAS;AAC5B,kBAAkB,mBAAO,CAAC,4DAAW,eAAe;;AAEpD;AACA;AACA;AACA,gBAAgB;AAChB,mCAAmC,cAAc;AACjD,CAAC;AACD;AACA,0BAA0B,cAAc;AACxC,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;AC9CD;AACA,SAAS,mBAAO,CAAC,kEAAc;AAC/B,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC,kBAAkB,mBAAO,CAAC,wEAAiB;;AAE3C;AACA,gCAAgC,mBAAO,CAAC,0DAAU;AAClD;AACA,gCAAgC,MAAM,WAAW,OAAO,WAAW;AACnE,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACtBD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,WAAW,mBAAO,CAAC,sEAAgB;AACnC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;ACVY;AACb;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC;AACA,+BAA+B;AAC/B,cAAc;AACd,0BAA0B;AAC1B;AACA;AACA;AACA,mBAAO,CAAC,sEAAgB;AACxB;AACA;AACA;AACA;AACA,wCAAwC;AACxC,GAAG;AACH,UAAU;AACV,CAAC;;AAED;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACzBD;AACA,WAAW,mBAAO,CAAC,sEAAgB;AACnC,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACTD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,oEAAe;AACtC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACTD;AACA,WAAW,mBAAO,CAAC,sEAAgB;AACnC,qBAAqB,mBAAO,CAAC,oEAAe;AAC5C,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,+BAA+B,WAAW;;;;;;;;;;;;ACpB1C;AACA,cAAc,mBAAO,CAAC,4DAAW;;AAEjC;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACPD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACVD;AACA,cAAc,mBAAO,CAAC,4DAAW;;AAEjC,+BAA+B,UAAU,mBAAO,CAAC,gEAAa,GAAG;;;;;;;;;;;;ACHjE;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;AACrC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACfD;AACA,cAAc,mBAAO,CAAC,4DAAW;AACjC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,CAAC;;;;;;;;;;;;ACdD;AACA,SAAS,mBAAO,CAAC,kEAAc;AAC/B,WAAW,mBAAO,CAAC,sEAAgB;AACnC,qBAAqB,mBAAO,CAAC,oEAAe;AAC5C,UAAU,mBAAO,CAAC,sDAAQ;AAC1B,cAAc,mBAAO,CAAC,4DAAW;AACjC,iBAAiB,mBAAO,CAAC,0EAAkB;AAC3C,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;;AAErC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA,+BAA+B,WAAW;;;;;;;;;;;;AChC1C,aAAa,mBAAO,CAAC,4DAAW;AAChC,wBAAwB,mBAAO,CAAC,sFAAwB;AACxD,SAAS,mBAAO,CAAC,kEAAc;AAC/B,WAAW,mBAAO,CAAC,sEAAgB;AACnC,eAAe,mBAAO,CAAC,kEAAc;AACrC,aAAa,mBAAO,CAAC,0DAAU;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,IAAI,mBAAO,CAAC,sEAAgB,sBAAsB,mBAAO,CAAC,0DAAU;AACpE,MAAM,mBAAO,CAAC,sDAAQ;AACtB;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,kBAAkB,EAAE;AAC5C,0BAA0B,gBAAgB;AAC1C,KAAK;AACL;AACA,oCAAoC,iBAAiB;AACrD;AACA;AACA,EAAE,mBAAO,CAAC,gEAAa;AACvB;;AAEA,mBAAO,CAAC,sEAAgB;;;;;;;;;;;;;AC1CX;AACb,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,mBAAO,CAAC,4DAAW;AACnB;AACA;AACA;AACA,CAAC;AACD;AACA,CAAC;;;;;;;;;;;;ACRD;AACA,IAAI,mBAAO,CAAC,sEAAgB,wBAAwB,mBAAO,CAAC,kEAAc;AAC1E;AACA,OAAO,mBAAO,CAAC,0DAAU;AACzB,CAAC;;;;;;;;;;;;;ACJY;;AAEb,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,yBAAyB,mBAAO,CAAC,wFAAyB;AAC1D,iBAAiB,mBAAO,CAAC,wFAAyB;;AAElD;AACA,mBAAO,CAAC,oEAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;ACvCY;;AAEb,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,yBAAyB,mBAAO,CAAC,wFAAyB;AAC1D,iBAAiB,mBAAO,CAAC,wFAAyB;AAClD;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,mBAAO,CAAC,oEAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,oBAAoB;AACzC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;;;;;;;;;;;;;ACrHY;;AAEb,eAAe,mBAAO,CAAC,kEAAc;AACrC,gBAAgB,mBAAO,CAAC,oEAAe;AACvC,iBAAiB,mBAAO,CAAC,wFAAyB;;AAElD;AACA,mBAAO,CAAC,oEAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;AC9BY;;AAEb,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,yBAAyB,mBAAO,CAAC,sFAAwB;AACzD,yBAAyB,mBAAO,CAAC,wFAAyB;AAC1D,eAAe,mBAAO,CAAC,kEAAc;AACrC,qBAAqB,mBAAO,CAAC,wFAAyB;AACtD,iBAAiB,mBAAO,CAAC,sEAAgB;AACzC,YAAY,mBAAO,CAAC,0DAAU;AAC9B;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,qCAAqC,yBAAyB,EAAE;;AAEhE;AACA,mBAAO,CAAC,oEAAe;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mFAAmF;AACnF;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,yBAAyB,mBAAmB;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;;;;;;;;;;;;ACrIY;AACb,mBAAO,CAAC,8EAAoB;AAC5B,eAAe,mBAAO,CAAC,kEAAc;AACrC,aAAa,mBAAO,CAAC,0DAAU;AAC/B,kBAAkB,mBAAO,CAAC,sEAAgB;AAC1C;AACA;;AAEA;AACA,EAAE,mBAAO,CAAC,gEAAa;AACvB;;AAEA;AACA,IAAI,mBAAO,CAAC,0DAAU,eAAe,wBAAwB,0BAA0B,YAAY,EAAE;AACrG;AACA;AACA;AACA;AACA,GAAG;AACH;AACA,CAAC;AACD;AACA;AACA,GAAG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CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gEAAgE,gCAAgC;AAChG;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,EAAE,mBAAO,CAAC,sEAAgB;AAC1B,EAAE,mBAAO,CAAC,oEAAe;AACzB,EAAE,mBAAO,CAAC,sEAAgB;;AAE1B,sBAAsB,mBAAO,CAAC,8DAAY;AAC1C;AACA;;AAEA;AACA;AACA;AACA;;AAEA,0DAA0D,kBAAkB;;AAE5E;AACA;AACA;AACA,oBAAoB,uBAAuB;;AAE3C,oDAAoD,6BAA6B;;AAEjF;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH,0BAA0B,eAAe,EAAE;AAC3C,0BAA0B,gBAAgB;AAC1C,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,OAAO,QAAQ,iCAAiC;AACpG,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,wEAAwE;AACxE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA,oCAAoC,mBAAO,CAAC,wDAAS;AACrD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACzOa;AACb,cAAc,mBAAO,CAAC,4DAAW;AACjC,aAAa,mBAAO,CAAC,0DAAU;AAC/B,aAAa,mBAAO,CAAC,wEAAiB;AACtC,eAAe,mBAAO,CAAC,kEAAc;AACrC,sBAAsB,mBAAO,CAAC,kFAAsB;AACpD,eAAe,mBAAO,CAAC,kEAAc;AACrC,eAAe,mBAAO,CAAC,kEAAc;AACrC,k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AAEA,uCAAuC;AACvC,uCAAuC,yBAAyB;AAChE,CAAC;;AAED;AACA;AACA;;AAEA,+CAA+C;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,OAAO;AACP;AACA;AACA,KAAK;AACL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb,WAAW;AACX;AACA;AACA;AACA,WAAW;AACX;AACA,OAAO;AACP,0BAA0B,aAAa;AACvC,KAAK;AACL,GAAG;AACH;AACA,+DAA+D,OAAO;AACtE;AACA;AACA;AACA;AACA,yBAAyB,kBAAkB;AAC3C;AACA;AACA,WAAW;AACX;AACA,OAAO;AACP,0BAA0B,aAAa;AACvC,KAAK;AACL;AACA,CAAC;;AAED,qDAAqD,aAAa,EAAE;;AAEpE,oBAAoB,0BAA0B;;AAE9C,mBAAO,CAAC,sEAAgB;;;;;;;;;;;;;ACtMxB;AACa;AACb,cAAc,mBAAO,CAAC,4DAAW;AACjC,WAAW,mBAAO,CAAC,wDAAS;AAC5B,aAAa,mBAAO,CAAC,4DAAW;AAChC,yBAAyB,mBAAO,CAAC,sFAAwB;AACzD,qBAAqB,mBAAO,CAAC,8EAAoB;;AAEjD,2CAA2C;AAC3C;AACA;AACA;AACA;AACA,8DAA8D,UAAU,EAAE;AAC1E,KAAK;AACL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;;;;;;;;;;;ACrM1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,QAAQ,WAAW;;AAEnB;AACA;AACA;AACA,QAAQ,WAAW;;AAEnB;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA,QAAQ,WAAW;;AAEnB;AACA;AACA,QAAQ,UAAU;;AAElB;AACA;;;;;;;;;;;;ACnFA;AACA;AACA;AACA;AACA;AACA,eAAe,SAAS;AACxB;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;;;;;;;;;;;ACvBA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,iCAAiC;;AAEjC;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;;AAEA;AACA,sBAAsB,QAAQ;AAC9B;AACA;AACA;;AAEA;AACA;AACA;;;;;;;;;;;;ACjCA,UAAU,mBAAO,CAAC,yDAAW;AAC7B,kBAAkB,mBAAO,CAAC,iEAAmB;;AAE7C;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,oBAAoB,SAAS;AAC7B;AACA;AACA;;AAEA;AACA;;AAEA;;;;;;;;;;;;AC5BA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA,4CAA4C;;AAE5C;;;;;;;;;;;;;;;;;;;;AChBA;;AACA;;0JAJA;AACA;;AAKA,IAAMo+B,6CAA6C,EAAnD,C,CAAuD;;IAE1Cl/B,iB,WAAAA,iB;AAET,iCAI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","file":"oidc-client.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 0);\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './src/Log.js';\r\nimport { OidcClient } from './src/OidcClient.js';\r\nimport { OidcClientSettings } from './src/OidcClientSettings.js';\r\nimport { WebStorageStateStore } from './src/WebStorageStateStore.js';\r\nimport { InMemoryWebStorage } from './src/InMemoryWebStorage.js';\r\nimport { UserManager } from './src/UserManager.js';\r\nimport { AccessTokenEvents } from './src/AccessTokenEvents.js';\r\nimport { MetadataService } from './src/MetadataService.js';\r\nimport { CordovaPopupNavigator } from './src/CordovaPopupNavigator.js';\r\nimport { CordovaIFrameNavigator } from './src/CordovaIFrameNavigator.js';\r\nimport { CheckSessionIFrame } from './src/CheckSessionIFrame.js';\r\nimport { TokenRevocationClient } from './src/TokenRevocationClient.js';\r\nimport { SessionMonitor } from './src/SessionMonitor.js';\r\nimport { Global } from './src/Global.js';\r\nimport { User } from './src/User.js';\r\n\r\nimport { Version } from './version.js';\r\n\r\nexport default {\r\n    Version,\r\n    Log,\r\n    OidcClient,\r\n    OidcClientSettings,\r\n    WebStorageStateStore,\r\n    InMemoryWebStorage,\r\n    UserManager,\r\n    AccessTokenEvents,\r\n    MetadataService,\r\n    CordovaPopupNavigator,\r\n    CordovaIFrameNavigator,\r\n    CheckSessionIFrame,\r\n    TokenRevocationClient,\r\n    SessionMonitor,\r\n    Global,\r\n    User\r\n};\r\n","/*\r\n * jsrsasign(all) 8.0.12 (2018-04-22) (c) 2010-2018 Kenji Urushima | kjur.github.com/jsrsasign/license\r\n */\r\n\r\nvar navigator = {};\r\nnavigator.userAgent = false;\r\n\r\nvar window = {};\r\n\n/*!\r\nCopyright (c) 2011, Yahoo! Inc. All rights reserved.\r\nCode licensed under the BSD License:\r\nhttp://developer.yahoo.com/yui/license.html\r\nversion: 2.9.0\r\n*/\r\nif(YAHOO===undefined){var YAHOO={}}YAHOO.lang={extend:function(g,h,f){if(!h||!g){throw new Error(\"YAHOO.lang.extend failed, please check that all dependencies are included.\")}var d=function(){};d.prototype=h.prototype;g.prototype=new d();g.prototype.constructor=g;g.superclass=h.prototype;if(h.prototype.constructor==Object.prototype.constructor){h.prototype.constructor=h}if(f){var b;for(b in f){g.prototype[b]=f[b]}var e=function(){},c=[\"toString\",\"valueOf\"];try{if(/MSIE/.test(navigator.userAgent)){e=function(j,i){for(b=0;b<c.length;b=b+1){var l=c[b],k=i[l];if(typeof k===\"function\"&&k!=Object.prototype[l]){j[l]=k}}}}}catch(a){}e(g.prototype,f)}}};\n/*! CryptoJS v3.1.2 core-fix.js\r\n * code.google.com/p/crypto-js\r\n * (c) 2009-2013 by Jeff Mott. All rights reserved.\r\n * code.google.com/p/crypto-js/wiki/License\r\n * THIS IS FIX of 'core.js' to fix Hmac issue.\r\n * https://code.google.com/p/crypto-js/issues/detail?id=84\r\n * https://crypto-js.googlecode.com/svn-history/r667/branches/3.x/src/core.js\r\n */\r\nvar CryptoJS=CryptoJS||(function(e,g){var a={};var b=a.lib={};var j=b.Base=(function(){function n(){}return{extend:function(p){n.prototype=this;var o=new n();if(p){o.mixIn(p)}if(!o.hasOwnProperty(\"init\")){o.init=function(){o.$super.init.apply(this,arguments)}}o.init.prototype=o;o.$super=this;return o},create:function(){var o=this.extend();o.init.apply(o,arguments);return o},init:function(){},mixIn:function(p){for(var o in p){if(p.hasOwnProperty(o)){this[o]=p[o]}}if(p.hasOwnProperty(\"toString\")){this.toString=p.toString}},clone:function(){return this.init.prototype.extend(this)}}}());var l=b.WordArray=j.extend({init:function(o,n){o=this.words=o||[];if(n!=g){this.sigBytes=n}else{this.sigBytes=o.length*4}},toString:function(n){return(n||h).stringify(this)},concat:function(t){var q=this.words;var p=t.words;var n=this.sigBytes;var s=t.sigBytes;this.clamp();if(n%4){for(var r=0;r<s;r++){var o=(p[r>>>2]>>>(24-(r%4)*8))&255;q[(n+r)>>>2]|=o<<(24-((n+r)%4)*8)}}else{for(var r=0;r<s;r+=4){q[(n+r)>>>2]=p[r>>>2]}}this.sigBytes+=s;return this},clamp:function(){var o=this.words;var n=this.sigBytes;o[n>>>2]&=4294967295<<(32-(n%4)*8);o.length=e.ceil(n/4)},clone:function(){var n=j.clone.call(this);n.words=this.words.slice(0);return n},random:function(p){var o=[];for(var n=0;n<p;n+=4){o.push((e.random()*4294967296)|0)}return new l.init(o,p)}});var m=a.enc={};var h=m.Hex={stringify:function(p){var r=p.words;var o=p.sigBytes;var q=[];for(var n=0;n<o;n++){var s=(r[n>>>2]>>>(24-(n%4)*8))&255;q.push((s>>>4).toString(16));q.push((s&15).toString(16))}return q.join(\"\")},parse:function(p){var n=p.length;var q=[];for(var o=0;o<n;o+=2){q[o>>>3]|=parseInt(p.substr(o,2),16)<<(24-(o%8)*4)}return new l.init(q,n/2)}};var d=m.Latin1={stringify:function(q){var r=q.words;var p=q.sigBytes;var n=[];for(var o=0;o<p;o++){var s=(r[o>>>2]>>>(24-(o%4)*8))&255;n.push(String.fromCharCode(s))}return n.join(\"\")},parse:function(p){var n=p.length;var q=[];for(var o=0;o<n;o++){q[o>>>2]|=(p.charCodeAt(o)&255)<<(24-(o%4)*8)}return new l.init(q,n)}};var c=m.Utf8={stringify:function(n){try{return decodeURIComponent(escape(d.stringify(n)))}catch(o){throw new Error(\"Malformed UTF-8 data\")}},parse:function(n){return d.parse(unescape(encodeURIComponent(n)))}};var i=b.BufferedBlockAlgorithm=j.extend({reset:function(){this._data=new l.init();this._nDataBytes=0},_append:function(n){if(typeof n==\"string\"){n=c.parse(n)}this._data.concat(n);this._nDataBytes+=n.sigBytes},_process:function(w){var q=this._data;var x=q.words;var n=q.sigBytes;var t=this.blockSize;var v=t*4;var u=n/v;if(w){u=e.ceil(u)}else{u=e.max((u|0)-this._minBufferSize,0)}var s=u*t;var r=e.min(s*4,n);if(s){for(var p=0;p<s;p+=t){this._doProcessBlock(x,p)}var o=x.splice(0,s);q.sigBytes-=r}return new l.init(o,r)},clone:function(){var n=j.clone.call(this);n._data=this._data.clone();return n},_minBufferSize:0});var f=b.Hasher=i.extend({cfg:j.extend(),init:function(n){this.cfg=this.cfg.extend(n);this.reset()},reset:function(){i.reset.call(this);this._doReset()},update:function(n){this._append(n);this._process();return this},finalize:function(n){if(n){this._append(n)}var o=this._doFinalize();return o},blockSize:512/32,_createHelper:function(n){return function(p,o){return new n.init(o).finalize(p)}},_createHmacHelper:function(n){return function(p,o){return new k.HMAC.init(n,o).finalize(p)}}});var k=a.algo={};return a}(Math));\n/*\r\nCryptoJS v3.1.2 x64-core-min.js\r\ncode.google.com/p/crypto-js\r\n(c) 2009-2013 by Jeff Mott. All rights reserved.\r\ncode.google.com/p/crypto-js/wiki/License\r\n*/\r\n(function(g){var a=CryptoJS,f=a.lib,e=f.Base,h=f.WordArray,a=a.x64={};a.Word=e.extend({init:function(b,c){this.high=b;this.low=c}});a.WordArray=e.extend({init:function(b,c){b=this.words=b||[];this.sigBytes=c!=g?c:8*b.length},toX32:function(){for(var b=this.words,c=b.length,a=[],d=0;d<c;d++){var e=b[d];a.push(e.high);a.push(e.low)}return h.create(a,this.sigBytes)},clone:function(){for(var b=e.clone.call(this),c=b.words=this.words.slice(0),a=c.length,d=0;d<a;d++)c[d]=c[d].clone();return b}})})();\r\n\n/*\r\nCryptoJS v3.1.2 enc-base64.js\r\ncode.google.com/p/crypto-js\r\n(c) 2009-2013 by Jeff Mott. All rights reserved.\r\ncode.google.com/p/crypto-js/wiki/License\r\n*/\r\n(function(){var h=CryptoJS,j=h.lib.WordArray;h.enc.Base64={stringify:function(b){var e=b.words,f=b.sigBytes,c=this._map;b.clamp();b=[];for(var a=0;a<f;a+=3)for(var d=(e[a>>>2]>>>24-8*(a%4)&255)<<16|(e[a+1>>>2]>>>24-8*((a+1)%4)&255)<<8|e[a+2>>>2]>>>24-8*((a+2)%4)&255,g=0;4>g&&a+0.75*g<f;g++)b.push(c.charAt(d>>>6*(3-g)&63));if(e=c.charAt(64))for(;b.length%4;)b.push(e);return b.join(\"\")},parse:function(b){var e=b.length,f=this._map,c=f.charAt(64);c&&(c=b.indexOf(c),-1!=c&&(e=c));for(var c=[],a=0,d=0;d<\r\ne;d++)if(d%4){var g=f.indexOf(b.charAt(d-1))<<2*(d%4),h=f.indexOf(b.charAt(d))>>>6-2*(d%4);c[a>>>2]|=(g|h)<<24-8*(a%4);a++}return j.create(c,a)},_map:\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\"}})();\r\n\n/*\r\nCryptoJS v3.1.2 sha256-min.js\r\ncode.google.com/p/crypto-js\r\n(c) 2009-2013 by Jeff Mott. All rights reserved.\r\ncode.google.com/p/crypto-js/wiki/License\r\n*/\r\n(function(k){for(var g=CryptoJS,h=g.lib,v=h.WordArray,j=h.Hasher,h=g.algo,s=[],t=[],u=function(q){return 4294967296*(q-(q|0))|0},l=2,b=0;64>b;){var d;a:{d=l;for(var w=k.sqrt(d),r=2;r<=w;r++)if(!(d%r)){d=!1;break a}d=!0}d&&(8>b&&(s[b]=u(k.pow(l,0.5))),t[b]=u(k.pow(l,1/3)),b++);l++}var n=[],h=h.SHA256=j.extend({_doReset:function(){this._hash=new v.init(s.slice(0))},_doProcessBlock:function(q,h){for(var a=this._hash.words,c=a[0],d=a[1],b=a[2],k=a[3],f=a[4],g=a[5],j=a[6],l=a[7],e=0;64>e;e++){if(16>e)n[e]=\r\nq[h+e]|0;else{var m=n[e-15],p=n[e-2];n[e]=((m<<25|m>>>7)^(m<<14|m>>>18)^m>>>3)+n[e-7]+((p<<15|p>>>17)^(p<<13|p>>>19)^p>>>10)+n[e-16]}m=l+((f<<26|f>>>6)^(f<<21|f>>>11)^(f<<7|f>>>25))+(f&g^~f&j)+t[e]+n[e];p=((c<<30|c>>>2)^(c<<19|c>>>13)^(c<<10|c>>>22))+(c&d^c&b^d&b);l=j;j=g;g=f;f=k+m|0;k=b;b=d;d=c;c=m+p|0}a[0]=a[0]+c|0;a[1]=a[1]+d|0;a[2]=a[2]+b|0;a[3]=a[3]+k|0;a[4]=a[4]+f|0;a[5]=a[5]+g|0;a[6]=a[6]+j|0;a[7]=a[7]+l|0},_doFinalize:function(){var d=this._data,b=d.words,a=8*this._nDataBytes,c=8*d.sigBytes;\r\nb[c>>>5]|=128<<24-c%32;b[(c+64>>>9<<4)+14]=k.floor(a/4294967296);b[(c+64>>>9<<4)+15]=a;d.sigBytes=4*b.length;this._process();return this._hash},clone:function(){var b=j.clone.call(this);b._hash=this._hash.clone();return b}});g.SHA256=j._createHelper(h);g.HmacSHA256=j._createHmacHelper(h)})(Math);\r\n\n/*\r\nCryptoJS v3.1.2 sha512-min.js\r\ncode.google.com/p/crypto-js\r\n(c) 2009-2013 by Jeff Mott. All rights reserved.\r\ncode.google.com/p/crypto-js/wiki/License\r\n*/\r\n(function(){function a(){return d.create.apply(d,arguments)}for(var n=CryptoJS,r=n.lib.Hasher,e=n.x64,d=e.Word,T=e.WordArray,e=n.algo,ea=[a(1116352408,3609767458),a(1899447441,602891725),a(3049323471,3964484399),a(3921009573,2173295548),a(961987163,4081628472),a(1508970993,3053834265),a(2453635748,2937671579),a(2870763221,3664609560),a(3624381080,2734883394),a(310598401,1164996542),a(607225278,1323610764),a(1426881987,3590304994),a(1925078388,4068182383),a(2162078206,991336113),a(2614888103,633803317),\r\na(3248222580,3479774868),a(3835390401,2666613458),a(4022224774,944711139),a(264347078,2341262773),a(604807628,2007800933),a(770255983,1495990901),a(1249150122,1856431235),a(1555081692,3175218132),a(1996064986,2198950837),a(2554220882,3999719339),a(2821834349,766784016),a(2952996808,2566594879),a(3210313671,3203337956),a(3336571891,1034457026),a(3584528711,2466948901),a(113926993,3758326383),a(338241895,168717936),a(666307205,1188179964),a(773529912,1546045734),a(1294757372,1522805485),a(1396182291,\r\n2643833823),a(1695183700,2343527390),a(1986661051,1014477480),a(2177026350,1206759142),a(2456956037,344077627),a(2730485921,1290863460),a(2820302411,3158454273),a(3259730800,3505952657),a(3345764771,106217008),a(3516065817,3606008344),a(3600352804,1432725776),a(4094571909,1467031594),a(275423344,851169720),a(430227734,3100823752),a(506948616,1363258195),a(659060556,3750685593),a(883997877,3785050280),a(958139571,3318307427),a(1322822218,3812723403),a(1537002063,2003034995),a(1747873779,3602036899),\r\na(1955562222,1575990012),a(2024104815,1125592928),a(2227730452,2716904306),a(2361852424,442776044),a(2428436474,593698344),a(2756734187,3733110249),a(3204031479,2999351573),a(3329325298,3815920427),a(3391569614,3928383900),a(3515267271,566280711),a(3940187606,3454069534),a(4118630271,4000239992),a(116418474,1914138554),a(174292421,2731055270),a(289380356,3203993006),a(460393269,320620315),a(685471733,587496836),a(852142971,1086792851),a(1017036298,365543100),a(1126000580,2618297676),a(1288033470,\r\n3409855158),a(1501505948,4234509866),a(1607167915,987167468),a(1816402316,1246189591)],v=[],w=0;80>w;w++)v[w]=a();e=e.SHA512=r.extend({_doReset:function(){this._hash=new T.init([new d.init(1779033703,4089235720),new d.init(3144134277,2227873595),new d.init(1013904242,4271175723),new d.init(2773480762,1595750129),new d.init(1359893119,2917565137),new d.init(2600822924,725511199),new d.init(528734635,4215389547),new d.init(1541459225,327033209)])},_doProcessBlock:function(a,d){for(var f=this._hash.words,\r\nF=f[0],e=f[1],n=f[2],r=f[3],G=f[4],H=f[5],I=f[6],f=f[7],w=F.high,J=F.low,X=e.high,K=e.low,Y=n.high,L=n.low,Z=r.high,M=r.low,$=G.high,N=G.low,aa=H.high,O=H.low,ba=I.high,P=I.low,ca=f.high,Q=f.low,k=w,g=J,z=X,x=K,A=Y,y=L,U=Z,B=M,l=$,h=N,R=aa,C=O,S=ba,D=P,V=ca,E=Q,m=0;80>m;m++){var s=v[m];if(16>m)var j=s.high=a[d+2*m]|0,b=s.low=a[d+2*m+1]|0;else{var j=v[m-15],b=j.high,p=j.low,j=(b>>>1|p<<31)^(b>>>8|p<<24)^b>>>7,p=(p>>>1|b<<31)^(p>>>8|b<<24)^(p>>>7|b<<25),u=v[m-2],b=u.high,c=u.low,u=(b>>>19|c<<13)^(b<<\r\n3|c>>>29)^b>>>6,c=(c>>>19|b<<13)^(c<<3|b>>>29)^(c>>>6|b<<26),b=v[m-7],W=b.high,t=v[m-16],q=t.high,t=t.low,b=p+b.low,j=j+W+(b>>>0<p>>>0?1:0),b=b+c,j=j+u+(b>>>0<c>>>0?1:0),b=b+t,j=j+q+(b>>>0<t>>>0?1:0);s.high=j;s.low=b}var W=l&R^~l&S,t=h&C^~h&D,s=k&z^k&A^z&A,T=g&x^g&y^x&y,p=(k>>>28|g<<4)^(k<<30|g>>>2)^(k<<25|g>>>7),u=(g>>>28|k<<4)^(g<<30|k>>>2)^(g<<25|k>>>7),c=ea[m],fa=c.high,da=c.low,c=E+((h>>>14|l<<18)^(h>>>18|l<<14)^(h<<23|l>>>9)),q=V+((l>>>14|h<<18)^(l>>>18|h<<14)^(l<<23|h>>>9))+(c>>>0<E>>>0?1:\r\n0),c=c+t,q=q+W+(c>>>0<t>>>0?1:0),c=c+da,q=q+fa+(c>>>0<da>>>0?1:0),c=c+b,q=q+j+(c>>>0<b>>>0?1:0),b=u+T,s=p+s+(b>>>0<u>>>0?1:0),V=S,E=D,S=R,D=C,R=l,C=h,h=B+c|0,l=U+q+(h>>>0<B>>>0?1:0)|0,U=A,B=y,A=z,y=x,z=k,x=g,g=c+b|0,k=q+s+(g>>>0<c>>>0?1:0)|0}J=F.low=J+g;F.high=w+k+(J>>>0<g>>>0?1:0);K=e.low=K+x;e.high=X+z+(K>>>0<x>>>0?1:0);L=n.low=L+y;n.high=Y+A+(L>>>0<y>>>0?1:0);M=r.low=M+B;r.high=Z+U+(M>>>0<B>>>0?1:0);N=G.low=N+h;G.high=$+l+(N>>>0<h>>>0?1:0);O=H.low=O+C;H.high=aa+R+(O>>>0<C>>>0?1:0);P=I.low=P+D;\r\nI.high=ba+S+(P>>>0<D>>>0?1:0);Q=f.low=Q+E;f.high=ca+V+(Q>>>0<E>>>0?1:0)},_doFinalize:function(){var a=this._data,d=a.words,f=8*this._nDataBytes,e=8*a.sigBytes;d[e>>>5]|=128<<24-e%32;d[(e+128>>>10<<5)+30]=Math.floor(f/4294967296);d[(e+128>>>10<<5)+31]=f;a.sigBytes=4*d.length;this._process();return this._hash.toX32()},clone:function(){var a=r.clone.call(this);a._hash=this._hash.clone();return a},blockSize:32});n.SHA512=r._createHelper(e);n.HmacSHA512=r._createHmacHelper(e)})();\r\n\n/*\r\nCryptoJS v3.1.2 sha384-min.js\r\ncode.google.com/p/crypto-js\r\n(c) 2009-2013 by Jeff Mott. All rights reserved.\r\ncode.google.com/p/crypto-js/wiki/License\r\n*/\r\n(function(){var c=CryptoJS,a=c.x64,b=a.Word,e=a.WordArray,a=c.algo,d=a.SHA512,a=a.SHA384=d.extend({_doReset:function(){this._hash=new e.init([new b.init(3418070365,3238371032),new b.init(1654270250,914150663),new b.init(2438529370,812702999),new b.init(355462360,4144912697),new b.init(1731405415,4290775857),new b.init(2394180231,1750603025),new b.init(3675008525,1694076839),new b.init(1203062813,3204075428)])},_doFinalize:function(){var a=d._doFinalize.call(this);a.sigBytes-=16;return a}});c.SHA384=\r\nd._createHelper(a);c.HmacSHA384=d._createHmacHelper(a)})();\r\n\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nvar b64map=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\";var b64pad=\"=\";function hex2b64(d){var b;var e;var a=\"\";for(b=0;b+3<=d.length;b+=3){e=parseInt(d.substring(b,b+3),16);a+=b64map.charAt(e>>6)+b64map.charAt(e&63)}if(b+1==d.length){e=parseInt(d.substring(b,b+1),16);a+=b64map.charAt(e<<2)}else{if(b+2==d.length){e=parseInt(d.substring(b,b+2),16);a+=b64map.charAt(e>>2)+b64map.charAt((e&3)<<4)}}if(b64pad){while((a.length&3)>0){a+=b64pad}}return a}function b64tohex(f){var d=\"\";var e;var b=0;var c;var a;for(e=0;e<f.length;++e){if(f.charAt(e)==b64pad){break}a=b64map.indexOf(f.charAt(e));if(a<0){continue}if(b==0){d+=int2char(a>>2);c=a&3;b=1}else{if(b==1){d+=int2char((c<<2)|(a>>4));c=a&15;b=2}else{if(b==2){d+=int2char(c);d+=int2char(a>>2);c=a&3;b=3}else{d+=int2char((c<<2)|(a>>4));d+=int2char(a&15);b=0}}}}if(b==1){d+=int2char(c<<2)}return d}function b64toBA(e){var d=b64tohex(e);var c;var b=new Array();for(c=0;2*c<d.length;++c){b[c]=parseInt(d.substring(2*c,2*c+2),16)}return b};\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nvar dbits;var canary=244837814094590;var j_lm=((canary&16777215)==15715070);function BigInteger(e,d,f){if(e!=null){if(\"number\"==typeof e){this.fromNumber(e,d,f)}else{if(d==null&&\"string\"!=typeof e){this.fromString(e,256)}else{this.fromString(e,d)}}}}function nbi(){return new BigInteger(null)}function am1(f,a,b,e,h,g){while(--g>=0){var d=a*this[f++]+b[e]+h;h=Math.floor(d/67108864);b[e++]=d&67108863}return h}function am2(f,q,r,e,o,a){var k=q&32767,p=q>>15;while(--a>=0){var d=this[f]&32767;var g=this[f++]>>15;var b=p*d+g*k;d=k*d+((b&32767)<<15)+r[e]+(o&1073741823);o=(d>>>30)+(b>>>15)+p*g+(o>>>30);r[e++]=d&1073741823}return o}function am3(f,q,r,e,o,a){var k=q&16383,p=q>>14;while(--a>=0){var d=this[f]&16383;var g=this[f++]>>14;var b=p*d+g*k;d=k*d+((b&16383)<<14)+r[e]+o;o=(d>>28)+(b>>14)+p*g;r[e++]=d&268435455}return o}if(j_lm&&(navigator.appName==\"Microsoft Internet Explorer\")){BigInteger.prototype.am=am2;dbits=30}else{if(j_lm&&(navigator.appName!=\"Netscape\")){BigInteger.prototype.am=am1;dbits=26}else{BigInteger.prototype.am=am3;dbits=28}}BigInteger.prototype.DB=dbits;BigInteger.prototype.DM=((1<<dbits)-1);BigInteger.prototype.DV=(1<<dbits);var BI_FP=52;BigInteger.prototype.FV=Math.pow(2,BI_FP);BigInteger.prototype.F1=BI_FP-dbits;BigInteger.prototype.F2=2*dbits-BI_FP;var BI_RM=\"0123456789abcdefghijklmnopqrstuvwxyz\";var BI_RC=new Array();var rr,vv;rr=\"0\".charCodeAt(0);for(vv=0;vv<=9;++vv){BI_RC[rr++]=vv}rr=\"a\".charCodeAt(0);for(vv=10;vv<36;++vv){BI_RC[rr++]=vv}rr=\"A\".charCodeAt(0);for(vv=10;vv<36;++vv){BI_RC[rr++]=vv}function int2char(a){return BI_RM.charAt(a)}function intAt(b,a){var d=BI_RC[b.charCodeAt(a)];return(d==null)?-1:d}function bnpCopyTo(b){for(var a=this.t-1;a>=0;--a){b[a]=this[a]}b.t=this.t;b.s=this.s}function bnpFromInt(a){this.t=1;this.s=(a<0)?-1:0;if(a>0){this[0]=a}else{if(a<-1){this[0]=a+this.DV}else{this.t=0}}}function nbv(a){var b=nbi();b.fromInt(a);return b}function bnpFromString(h,c){var e;if(c==16){e=4}else{if(c==8){e=3}else{if(c==256){e=8}else{if(c==2){e=1}else{if(c==32){e=5}else{if(c==4){e=2}else{this.fromRadix(h,c);return}}}}}}this.t=0;this.s=0;var g=h.length,d=false,f=0;while(--g>=0){var a=(e==8)?h[g]&255:intAt(h,g);if(a<0){if(h.charAt(g)==\"-\"){d=true}continue}d=false;if(f==0){this[this.t++]=a}else{if(f+e>this.DB){this[this.t-1]|=(a&((1<<(this.DB-f))-1))<<f;this[this.t++]=(a>>(this.DB-f))}else{this[this.t-1]|=a<<f}}f+=e;if(f>=this.DB){f-=this.DB}}if(e==8&&(h[0]&128)!=0){this.s=-1;if(f>0){this[this.t-1]|=((1<<(this.DB-f))-1)<<f}}this.clamp();if(d){BigInteger.ZERO.subTo(this,this)}}function bnpClamp(){var a=this.s&this.DM;while(this.t>0&&this[this.t-1]==a){--this.t}}function bnToString(c){if(this.s<0){return\"-\"+this.negate().toString(c)}var e;if(c==16){e=4}else{if(c==8){e=3}else{if(c==2){e=1}else{if(c==32){e=5}else{if(c==4){e=2}else{return this.toRadix(c)}}}}}var g=(1<<e)-1,l,a=false,h=\"\",f=this.t;var j=this.DB-(f*this.DB)%e;if(f-->0){if(j<this.DB&&(l=this[f]>>j)>0){a=true;h=int2char(l)}while(f>=0){if(j<e){l=(this[f]&((1<<j)-1))<<(e-j);l|=this[--f]>>(j+=this.DB-e)}else{l=(this[f]>>(j-=e))&g;if(j<=0){j+=this.DB;--f}}if(l>0){a=true}if(a){h+=int2char(l)}}}return a?h:\"0\"}function bnNegate(){var a=nbi();BigInteger.ZERO.subTo(this,a);return a}function bnAbs(){return(this.s<0)?this.negate():this}function bnCompareTo(b){var d=this.s-b.s;if(d!=0){return d}var c=this.t;d=c-b.t;if(d!=0){return(this.s<0)?-d:d}while(--c>=0){if((d=this[c]-b[c])!=0){return d}}return 0}function nbits(a){var c=1,b;if((b=a>>>16)!=0){a=b;c+=16}if((b=a>>8)!=0){a=b;c+=8}if((b=a>>4)!=0){a=b;c+=4}if((b=a>>2)!=0){a=b;c+=2}if((b=a>>1)!=0){a=b;c+=1}return c}function bnBitLength(){if(this.t<=0){return 0}return this.DB*(this.t-1)+nbits(this[this.t-1]^(this.s&this.DM))}function bnpDLShiftTo(c,b){var a;for(a=this.t-1;a>=0;--a){b[a+c]=this[a]}for(a=c-1;a>=0;--a){b[a]=0}b.t=this.t+c;b.s=this.s}function bnpDRShiftTo(c,b){for(var a=c;a<this.t;++a){b[a-c]=this[a]}b.t=Math.max(this.t-c,0);b.s=this.s}function bnpLShiftTo(j,e){var b=j%this.DB;var a=this.DB-b;var g=(1<<a)-1;var f=Math.floor(j/this.DB),h=(this.s<<b)&this.DM,d;for(d=this.t-1;d>=0;--d){e[d+f+1]=(this[d]>>a)|h;h=(this[d]&g)<<b}for(d=f-1;d>=0;--d){e[d]=0}e[f]=h;e.t=this.t+f+1;e.s=this.s;e.clamp()}function bnpRShiftTo(g,d){d.s=this.s;var e=Math.floor(g/this.DB);if(e>=this.t){d.t=0;return}var b=g%this.DB;var a=this.DB-b;var f=(1<<b)-1;d[0]=this[e]>>b;for(var c=e+1;c<this.t;++c){d[c-e-1]|=(this[c]&f)<<a;d[c-e]=this[c]>>b}if(b>0){d[this.t-e-1]|=(this.s&f)<<a}d.t=this.t-e;d.clamp()}function bnpSubTo(d,f){var e=0,g=0,b=Math.min(d.t,this.t);while(e<b){g+=this[e]-d[e];f[e++]=g&this.DM;g>>=this.DB}if(d.t<this.t){g-=d.s;while(e<this.t){g+=this[e];f[e++]=g&this.DM;g>>=this.DB}g+=this.s}else{g+=this.s;while(e<d.t){g-=d[e];f[e++]=g&this.DM;g>>=this.DB}g-=d.s}f.s=(g<0)?-1:0;if(g<-1){f[e++]=this.DV+g}else{if(g>0){f[e++]=g}}f.t=e;f.clamp()}function bnpMultiplyTo(c,e){var b=this.abs(),f=c.abs();var d=b.t;e.t=d+f.t;while(--d>=0){e[d]=0}for(d=0;d<f.t;++d){e[d+b.t]=b.am(0,f[d],e,d,0,b.t)}e.s=0;e.clamp();if(this.s!=c.s){BigInteger.ZERO.subTo(e,e)}}function bnpSquareTo(d){var a=this.abs();var b=d.t=2*a.t;while(--b>=0){d[b]=0}for(b=0;b<a.t-1;++b){var e=a.am(b,a[b],d,2*b,0,1);if((d[b+a.t]+=a.am(b+1,2*a[b],d,2*b+1,e,a.t-b-1))>=a.DV){d[b+a.t]-=a.DV;d[b+a.t+1]=1}}if(d.t>0){d[d.t-1]+=a.am(b,a[b],d,2*b,0,1)}d.s=0;d.clamp()}function bnpDivRemTo(n,h,g){var w=n.abs();if(w.t<=0){return}var k=this.abs();if(k.t<w.t){if(h!=null){h.fromInt(0)}if(g!=null){this.copyTo(g)}return}if(g==null){g=nbi()}var d=nbi(),a=this.s,l=n.s;var v=this.DB-nbits(w[w.t-1]);if(v>0){w.lShiftTo(v,d);k.lShiftTo(v,g)}else{w.copyTo(d);k.copyTo(g)}var p=d.t;var b=d[p-1];if(b==0){return}var o=b*(1<<this.F1)+((p>1)?d[p-2]>>this.F2:0);var A=this.FV/o,z=(1<<this.F1)/o,x=1<<this.F2;var u=g.t,s=u-p,f=(h==null)?nbi():h;d.dlShiftTo(s,f);if(g.compareTo(f)>=0){g[g.t++]=1;g.subTo(f,g)}BigInteger.ONE.dlShiftTo(p,f);f.subTo(d,d);while(d.t<p){d[d.t++]=0}while(--s>=0){var c=(g[--u]==b)?this.DM:Math.floor(g[u]*A+(g[u-1]+x)*z);if((g[u]+=d.am(0,c,g,s,0,p))<c){d.dlShiftTo(s,f);g.subTo(f,g);while(g[u]<--c){g.subTo(f,g)}}}if(h!=null){g.drShiftTo(p,h);if(a!=l){BigInteger.ZERO.subTo(h,h)}}g.t=p;g.clamp();if(v>0){g.rShiftTo(v,g)}if(a<0){BigInteger.ZERO.subTo(g,g)}}function bnMod(b){var c=nbi();this.abs().divRemTo(b,null,c);if(this.s<0&&c.compareTo(BigInteger.ZERO)>0){b.subTo(c,c)}return c}function Classic(a){this.m=a}function cConvert(a){if(a.s<0||a.compareTo(this.m)>=0){return a.mod(this.m)}else{return a}}function cRevert(a){return a}function cReduce(a){a.divRemTo(this.m,null,a)}function cMulTo(a,c,b){a.multiplyTo(c,b);this.reduce(b)}function cSqrTo(a,b){a.squareTo(b);this.reduce(b)}Classic.prototype.convert=cConvert;Classic.prototype.revert=cRevert;Classic.prototype.reduce=cReduce;Classic.prototype.mulTo=cMulTo;Classic.prototype.sqrTo=cSqrTo;function bnpInvDigit(){if(this.t<1){return 0}var a=this[0];if((a&1)==0){return 0}var b=a&3;b=(b*(2-(a&15)*b))&15;b=(b*(2-(a&255)*b))&255;b=(b*(2-(((a&65535)*b)&65535)))&65535;b=(b*(2-a*b%this.DV))%this.DV;return(b>0)?this.DV-b:-b}function Montgomery(a){this.m=a;this.mp=a.invDigit();this.mpl=this.mp&32767;this.mph=this.mp>>15;this.um=(1<<(a.DB-15))-1;this.mt2=2*a.t}function montConvert(a){var b=nbi();a.abs().dlShiftTo(this.m.t,b);b.divRemTo(this.m,null,b);if(a.s<0&&b.compareTo(BigInteger.ZERO)>0){this.m.subTo(b,b)}return b}function montRevert(a){var b=nbi();a.copyTo(b);this.reduce(b);return b}function montReduce(a){while(a.t<=this.mt2){a[a.t++]=0}for(var c=0;c<this.m.t;++c){var b=a[c]&32767;var d=(b*this.mpl+(((b*this.mph+(a[c]>>15)*this.mpl)&this.um)<<15))&a.DM;b=c+this.m.t;a[b]+=this.m.am(0,d,a,c,0,this.m.t);while(a[b]>=a.DV){a[b]-=a.DV;a[++b]++}}a.clamp();a.drShiftTo(this.m.t,a);if(a.compareTo(this.m)>=0){a.subTo(this.m,a)}}function montSqrTo(a,b){a.squareTo(b);this.reduce(b)}function montMulTo(a,c,b){a.multiplyTo(c,b);this.reduce(b)}Montgomery.prototype.convert=montConvert;Montgomery.prototype.revert=montRevert;Montgomery.prototype.reduce=montReduce;Montgomery.prototype.mulTo=montMulTo;Montgomery.prototype.sqrTo=montSqrTo;function bnpIsEven(){return((this.t>0)?(this[0]&1):this.s)==0}function bnpExp(h,j){if(h>4294967295||h<1){return BigInteger.ONE}var f=nbi(),a=nbi(),d=j.convert(this),c=nbits(h)-1;d.copyTo(f);while(--c>=0){j.sqrTo(f,a);if((h&(1<<c))>0){j.mulTo(a,d,f)}else{var b=f;f=a;a=b}}return j.revert(f)}function bnModPowInt(b,a){var c;if(b<256||a.isEven()){c=new Classic(a)}else{c=new Montgomery(a)}return this.exp(b,c)}BigInteger.prototype.copyTo=bnpCopyTo;BigInteger.prototype.fromInt=bnpFromInt;BigInteger.prototype.fromString=bnpFromString;BigInteger.prototype.clamp=bnpClamp;BigInteger.prototype.dlShiftTo=bnpDLShiftTo;BigInteger.prototype.drShiftTo=bnpDRShiftTo;BigInteger.prototype.lShiftTo=bnpLShiftTo;BigInteger.prototype.rShiftTo=bnpRShiftTo;BigInteger.prototype.subTo=bnpSubTo;BigInteger.prototype.multiplyTo=bnpMultiplyTo;BigInteger.prototype.squareTo=bnpSquareTo;BigInteger.prototype.divRemTo=bnpDivRemTo;BigInteger.prototype.invDigit=bnpInvDigit;BigInteger.prototype.isEven=bnpIsEven;BigInteger.prototype.exp=bnpExp;BigInteger.prototype.toString=bnToString;BigInteger.prototype.negate=bnNegate;BigInteger.prototype.abs=bnAbs;BigInteger.prototype.compareTo=bnCompareTo;BigInteger.prototype.bitLength=bnBitLength;BigInteger.prototype.mod=bnMod;BigInteger.prototype.modPowInt=bnModPowInt;BigInteger.ZERO=nbv(0);BigInteger.ONE=nbv(1);\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nfunction bnClone(){var a=nbi();this.copyTo(a);return a}function bnIntValue(){if(this.s<0){if(this.t==1){return this[0]-this.DV}else{if(this.t==0){return -1}}}else{if(this.t==1){return this[0]}else{if(this.t==0){return 0}}}return((this[1]&((1<<(32-this.DB))-1))<<this.DB)|this[0]}function bnByteValue(){return(this.t==0)?this.s:(this[0]<<24)>>24}function bnShortValue(){return(this.t==0)?this.s:(this[0]<<16)>>16}function bnpChunkSize(a){return Math.floor(Math.LN2*this.DB/Math.log(a))}function bnSigNum(){if(this.s<0){return -1}else{if(this.t<=0||(this.t==1&&this[0]<=0)){return 0}else{return 1}}}function bnpToRadix(c){if(c==null){c=10}if(this.signum()==0||c<2||c>36){return\"0\"}var f=this.chunkSize(c);var e=Math.pow(c,f);var i=nbv(e),j=nbi(),h=nbi(),g=\"\";this.divRemTo(i,j,h);while(j.signum()>0){g=(e+h.intValue()).toString(c).substr(1)+g;j.divRemTo(i,j,h)}return h.intValue().toString(c)+g}function bnpFromRadix(m,h){this.fromInt(0);if(h==null){h=10}var f=this.chunkSize(h);var g=Math.pow(h,f),e=false,a=0,l=0;for(var c=0;c<m.length;++c){var k=intAt(m,c);if(k<0){if(m.charAt(c)==\"-\"&&this.signum()==0){e=true}continue}l=h*l+k;if(++a>=f){this.dMultiply(g);this.dAddOffset(l,0);a=0;l=0}}if(a>0){this.dMultiply(Math.pow(h,a));this.dAddOffset(l,0)}if(e){BigInteger.ZERO.subTo(this,this)}}function bnpFromNumber(f,e,h){if(\"number\"==typeof e){if(f<2){this.fromInt(1)}else{this.fromNumber(f,h);if(!this.testBit(f-1)){this.bitwiseTo(BigInteger.ONE.shiftLeft(f-1),op_or,this)}if(this.isEven()){this.dAddOffset(1,0)}while(!this.isProbablePrime(e)){this.dAddOffset(2,0);if(this.bitLength()>f){this.subTo(BigInteger.ONE.shiftLeft(f-1),this)}}}}else{var d=new Array(),g=f&7;d.length=(f>>3)+1;e.nextBytes(d);if(g>0){d[0]&=((1<<g)-1)}else{d[0]=0}this.fromString(d,256)}}function bnToByteArray(){var b=this.t,c=new Array();c[0]=this.s;var e=this.DB-(b*this.DB)%8,f,a=0;if(b-->0){if(e<this.DB&&(f=this[b]>>e)!=(this.s&this.DM)>>e){c[a++]=f|(this.s<<(this.DB-e))}while(b>=0){if(e<8){f=(this[b]&((1<<e)-1))<<(8-e);f|=this[--b]>>(e+=this.DB-8)}else{f=(this[b]>>(e-=8))&255;if(e<=0){e+=this.DB;--b}}if((f&128)!=0){f|=-256}if(a==0&&(this.s&128)!=(f&128)){++a}if(a>0||f!=this.s){c[a++]=f}}}return c}function bnEquals(b){return(this.compareTo(b)==0)}function bnMin(b){return(this.compareTo(b)<0)?this:b}function bnMax(b){return(this.compareTo(b)>0)?this:b}function bnpBitwiseTo(c,h,e){var d,g,b=Math.min(c.t,this.t);for(d=0;d<b;++d){e[d]=h(this[d],c[d])}if(c.t<this.t){g=c.s&this.DM;for(d=b;d<this.t;++d){e[d]=h(this[d],g)}e.t=this.t}else{g=this.s&this.DM;for(d=b;d<c.t;++d){e[d]=h(g,c[d])}e.t=c.t}e.s=h(this.s,c.s);e.clamp()}function op_and(a,b){return a&b}function bnAnd(b){var c=nbi();this.bitwiseTo(b,op_and,c);return c}function op_or(a,b){return a|b}function bnOr(b){var c=nbi();this.bitwiseTo(b,op_or,c);return c}function op_xor(a,b){return a^b}function bnXor(b){var c=nbi();this.bitwiseTo(b,op_xor,c);return c}function op_andnot(a,b){return a&~b}function bnAndNot(b){var c=nbi();this.bitwiseTo(b,op_andnot,c);return c}function bnNot(){var b=nbi();for(var a=0;a<this.t;++a){b[a]=this.DM&~this[a]}b.t=this.t;b.s=~this.s;return b}function bnShiftLeft(b){var a=nbi();if(b<0){this.rShiftTo(-b,a)}else{this.lShiftTo(b,a)}return a}function bnShiftRight(b){var a=nbi();if(b<0){this.lShiftTo(-b,a)}else{this.rShiftTo(b,a)}return a}function lbit(a){if(a==0){return -1}var b=0;if((a&65535)==0){a>>=16;b+=16}if((a&255)==0){a>>=8;b+=8}if((a&15)==0){a>>=4;b+=4}if((a&3)==0){a>>=2;b+=2}if((a&1)==0){++b}return b}function bnGetLowestSetBit(){for(var a=0;a<this.t;++a){if(this[a]!=0){return a*this.DB+lbit(this[a])}}if(this.s<0){return this.t*this.DB}return -1}function cbit(a){var b=0;while(a!=0){a&=a-1;++b}return b}function bnBitCount(){var c=0,a=this.s&this.DM;for(var b=0;b<this.t;++b){c+=cbit(this[b]^a)}return c}function bnTestBit(b){var a=Math.floor(b/this.DB);if(a>=this.t){return(this.s!=0)}return((this[a]&(1<<(b%this.DB)))!=0)}function bnpChangeBit(c,b){var a=BigInteger.ONE.shiftLeft(c);this.bitwiseTo(a,b,a);return a}function bnSetBit(a){return this.changeBit(a,op_or)}function bnClearBit(a){return this.changeBit(a,op_andnot)}function bnFlipBit(a){return this.changeBit(a,op_xor)}function bnpAddTo(d,f){var e=0,g=0,b=Math.min(d.t,this.t);while(e<b){g+=this[e]+d[e];f[e++]=g&this.DM;g>>=this.DB}if(d.t<this.t){g+=d.s;while(e<this.t){g+=this[e];f[e++]=g&this.DM;g>>=this.DB}g+=this.s}else{g+=this.s;while(e<d.t){g+=d[e];f[e++]=g&this.DM;g>>=this.DB}g+=d.s}f.s=(g<0)?-1:0;if(g>0){f[e++]=g}else{if(g<-1){f[e++]=this.DV+g}}f.t=e;f.clamp()}function bnAdd(b){var c=nbi();this.addTo(b,c);return c}function bnSubtract(b){var c=nbi();this.subTo(b,c);return c}function bnMultiply(b){var c=nbi();this.multiplyTo(b,c);return c}function bnSquare(){var a=nbi();this.squareTo(a);return a}function bnDivide(b){var c=nbi();this.divRemTo(b,c,null);return c}function bnRemainder(b){var c=nbi();this.divRemTo(b,null,c);return c}function bnDivideAndRemainder(b){var d=nbi(),c=nbi();this.divRemTo(b,d,c);return new Array(d,c)}function bnpDMultiply(a){this[this.t]=this.am(0,a-1,this,0,0,this.t);++this.t;this.clamp()}function bnpDAddOffset(b,a){if(b==0){return}while(this.t<=a){this[this.t++]=0}this[a]+=b;while(this[a]>=this.DV){this[a]-=this.DV;if(++a>=this.t){this[this.t++]=0}++this[a]}}function NullExp(){}function nNop(a){return a}function nMulTo(a,c,b){a.multiplyTo(c,b)}function nSqrTo(a,b){a.squareTo(b)}NullExp.prototype.convert=nNop;NullExp.prototype.revert=nNop;NullExp.prototype.mulTo=nMulTo;NullExp.prototype.sqrTo=nSqrTo;function bnPow(a){return this.exp(a,new NullExp())}function bnpMultiplyLowerTo(b,f,e){var d=Math.min(this.t+b.t,f);e.s=0;e.t=d;while(d>0){e[--d]=0}var c;for(c=e.t-this.t;d<c;++d){e[d+this.t]=this.am(0,b[d],e,d,0,this.t)}for(c=Math.min(b.t,f);d<c;++d){this.am(0,b[d],e,d,0,f-d)}e.clamp()}function bnpMultiplyUpperTo(b,e,d){--e;var c=d.t=this.t+b.t-e;d.s=0;while(--c>=0){d[c]=0}for(c=Math.max(e-this.t,0);c<b.t;++c){d[this.t+c-e]=this.am(e-c,b[c],d,0,0,this.t+c-e)}d.clamp();d.drShiftTo(1,d)}function Barrett(a){this.r2=nbi();this.q3=nbi();BigInteger.ONE.dlShiftTo(2*a.t,this.r2);this.mu=this.r2.divide(a);this.m=a}function barrettConvert(a){if(a.s<0||a.t>2*this.m.t){return a.mod(this.m)}else{if(a.compareTo(this.m)<0){return a}else{var b=nbi();a.copyTo(b);this.reduce(b);return b}}}function barrettRevert(a){return a}function barrettReduce(a){a.drShiftTo(this.m.t-1,this.r2);if(a.t>this.m.t+1){a.t=this.m.t+1;a.clamp()}this.mu.multiplyUpperTo(this.r2,this.m.t+1,this.q3);this.m.multiplyLowerTo(this.q3,this.m.t+1,this.r2);while(a.compareTo(this.r2)<0){a.dAddOffset(1,this.m.t+1)}a.subTo(this.r2,a);while(a.compareTo(this.m)>=0){a.subTo(this.m,a)}}function barrettSqrTo(a,b){a.squareTo(b);this.reduce(b)}function barrettMulTo(a,c,b){a.multiplyTo(c,b);this.reduce(b)}Barrett.prototype.convert=barrettConvert;Barrett.prototype.revert=barrettRevert;Barrett.prototype.reduce=barrettReduce;Barrett.prototype.mulTo=barrettMulTo;Barrett.prototype.sqrTo=barrettSqrTo;function bnModPow(q,f){var o=q.bitLength(),h,b=nbv(1),v;if(o<=0){return b}else{if(o<18){h=1}else{if(o<48){h=3}else{if(o<144){h=4}else{if(o<768){h=5}else{h=6}}}}}if(o<8){v=new Classic(f)}else{if(f.isEven()){v=new Barrett(f)}else{v=new Montgomery(f)}}var p=new Array(),d=3,s=h-1,a=(1<<h)-1;p[1]=v.convert(this);if(h>1){var A=nbi();v.sqrTo(p[1],A);while(d<=a){p[d]=nbi();v.mulTo(A,p[d-2],p[d]);d+=2}}var l=q.t-1,x,u=true,c=nbi(),y;o=nbits(q[l])-1;while(l>=0){if(o>=s){x=(q[l]>>(o-s))&a}else{x=(q[l]&((1<<(o+1))-1))<<(s-o);if(l>0){x|=q[l-1]>>(this.DB+o-s)}}d=h;while((x&1)==0){x>>=1;--d}if((o-=d)<0){o+=this.DB;--l}if(u){p[x].copyTo(b);u=false}else{while(d>1){v.sqrTo(b,c);v.sqrTo(c,b);d-=2}if(d>0){v.sqrTo(b,c)}else{y=b;b=c;c=y}v.mulTo(c,p[x],b)}while(l>=0&&(q[l]&(1<<o))==0){v.sqrTo(b,c);y=b;b=c;c=y;if(--o<0){o=this.DB-1;--l}}}return v.revert(b)}function bnGCD(c){var b=(this.s<0)?this.negate():this.clone();var h=(c.s<0)?c.negate():c.clone();if(b.compareTo(h)<0){var e=b;b=h;h=e}var d=b.getLowestSetBit(),f=h.getLowestSetBit();if(f<0){return b}if(d<f){f=d}if(f>0){b.rShiftTo(f,b);h.rShiftTo(f,h)}while(b.signum()>0){if((d=b.getLowestSetBit())>0){b.rShiftTo(d,b)}if((d=h.getLowestSetBit())>0){h.rShiftTo(d,h)}if(b.compareTo(h)>=0){b.subTo(h,b);b.rShiftTo(1,b)}else{h.subTo(b,h);h.rShiftTo(1,h)}}if(f>0){h.lShiftTo(f,h)}return h}function bnpModInt(e){if(e<=0){return 0}var c=this.DV%e,b=(this.s<0)?e-1:0;if(this.t>0){if(c==0){b=this[0]%e}else{for(var a=this.t-1;a>=0;--a){b=(c*b+this[a])%e}}}return b}function bnModInverse(f){var j=f.isEven();if((this.isEven()&&j)||f.signum()==0){return BigInteger.ZERO}var i=f.clone(),h=this.clone();var g=nbv(1),e=nbv(0),l=nbv(0),k=nbv(1);while(i.signum()!=0){while(i.isEven()){i.rShiftTo(1,i);if(j){if(!g.isEven()||!e.isEven()){g.addTo(this,g);e.subTo(f,e)}g.rShiftTo(1,g)}else{if(!e.isEven()){e.subTo(f,e)}}e.rShiftTo(1,e)}while(h.isEven()){h.rShiftTo(1,h);if(j){if(!l.isEven()||!k.isEven()){l.addTo(this,l);k.subTo(f,k)}l.rShiftTo(1,l)}else{if(!k.isEven()){k.subTo(f,k)}}k.rShiftTo(1,k)}if(i.compareTo(h)>=0){i.subTo(h,i);if(j){g.subTo(l,g)}e.subTo(k,e)}else{h.subTo(i,h);if(j){l.subTo(g,l)}k.subTo(e,k)}}if(h.compareTo(BigInteger.ONE)!=0){return BigInteger.ZERO}if(k.compareTo(f)>=0){return k.subtract(f)}if(k.signum()<0){k.addTo(f,k)}else{return k}if(k.signum()<0){return k.add(f)}else{return k}}var lowprimes=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997];var lplim=(1<<26)/lowprimes[lowprimes.length-1];function bnIsProbablePrime(e){var d,b=this.abs();if(b.t==1&&b[0]<=lowprimes[lowprimes.length-1]){for(d=0;d<lowprimes.length;++d){if(b[0]==lowprimes[d]){return true}}return false}if(b.isEven()){return false}d=1;while(d<lowprimes.length){var a=lowprimes[d],c=d+1;while(c<lowprimes.length&&a<lplim){a*=lowprimes[c++]}a=b.modInt(a);while(d<c){if(a%lowprimes[d++]==0){return false}}}return b.millerRabin(e)}function bnpMillerRabin(f){var g=this.subtract(BigInteger.ONE);var c=g.getLowestSetBit();if(c<=0){return false}var h=g.shiftRight(c);f=(f+1)>>1;if(f>lowprimes.length){f=lowprimes.length}var b=nbi();for(var e=0;e<f;++e){b.fromInt(lowprimes[Math.floor(Math.random()*lowprimes.length)]);var l=b.modPow(h,this);if(l.compareTo(BigInteger.ONE)!=0&&l.compareTo(g)!=0){var d=1;while(d++<c&&l.compareTo(g)!=0){l=l.modPowInt(2,this);if(l.compareTo(BigInteger.ONE)==0){return false}}if(l.compareTo(g)!=0){return false}}}return true}BigInteger.prototype.chunkSize=bnpChunkSize;BigInteger.prototype.toRadix=bnpToRadix;BigInteger.prototype.fromRadix=bnpFromRadix;BigInteger.prototype.fromNumber=bnpFromNumber;BigInteger.prototype.bitwiseTo=bnpBitwiseTo;BigInteger.prototype.changeBit=bnpChangeBit;BigInteger.prototype.addTo=bnpAddTo;BigInteger.prototype.dMultiply=bnpDMultiply;BigInteger.prototype.dAddOffset=bnpDAddOffset;BigInteger.prototype.multiplyLowerTo=bnpMultiplyLowerTo;BigInteger.prototype.multiplyUpperTo=bnpMultiplyUpperTo;BigInteger.prototype.modInt=bnpModInt;BigInteger.prototype.millerRabin=bnpMillerRabin;BigInteger.prototype.clone=bnClone;BigInteger.prototype.intValue=bnIntValue;BigInteger.prototype.byteValue=bnByteValue;BigInteger.prototype.shortValue=bnShortValue;BigInteger.prototype.signum=bnSigNum;BigInteger.prototype.toByteArray=bnToByteArray;BigInteger.prototype.equals=bnEquals;BigInteger.prototype.min=bnMin;BigInteger.prototype.max=bnMax;BigInteger.prototype.and=bnAnd;BigInteger.prototype.or=bnOr;BigInteger.prototype.xor=bnXor;BigInteger.prototype.andNot=bnAndNot;BigInteger.prototype.not=bnNot;BigInteger.prototype.shiftLeft=bnShiftLeft;BigInteger.prototype.shiftRight=bnShiftRight;BigInteger.prototype.getLowestSetBit=bnGetLowestSetBit;BigInteger.prototype.bitCount=bnBitCount;BigInteger.prototype.testBit=bnTestBit;BigInteger.prototype.setBit=bnSetBit;BigInteger.prototype.clearBit=bnClearBit;BigInteger.prototype.flipBit=bnFlipBit;BigInteger.prototype.add=bnAdd;BigInteger.prototype.subtract=bnSubtract;BigInteger.prototype.multiply=bnMultiply;BigInteger.prototype.divide=bnDivide;BigInteger.prototype.remainder=bnRemainder;BigInteger.prototype.divideAndRemainder=bnDivideAndRemainder;BigInteger.prototype.modPow=bnModPow;BigInteger.prototype.modInverse=bnModInverse;BigInteger.prototype.pow=bnPow;BigInteger.prototype.gcd=bnGCD;BigInteger.prototype.isProbablePrime=bnIsProbablePrime;BigInteger.prototype.square=bnSquare;\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nfunction Arcfour(){this.i=0;this.j=0;this.S=new Array()}function ARC4init(d){var c,a,b;for(c=0;c<256;++c){this.S[c]=c}a=0;for(c=0;c<256;++c){a=(a+this.S[c]+d[c%d.length])&255;b=this.S[c];this.S[c]=this.S[a];this.S[a]=b}this.i=0;this.j=0}function ARC4next(){var a;this.i=(this.i+1)&255;this.j=(this.j+this.S[this.i])&255;a=this.S[this.i];this.S[this.i]=this.S[this.j];this.S[this.j]=a;return this.S[(a+this.S[this.i])&255]}Arcfour.prototype.init=ARC4init;Arcfour.prototype.next=ARC4next;function prng_newstate(){return new Arcfour()}var rng_psize=256;\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nvar rng_state;var rng_pool;var rng_pptr;function rng_seed_int(a){rng_pool[rng_pptr++]^=a&255;rng_pool[rng_pptr++]^=(a>>8)&255;rng_pool[rng_pptr++]^=(a>>16)&255;rng_pool[rng_pptr++]^=(a>>24)&255;if(rng_pptr>=rng_psize){rng_pptr-=rng_psize}}function rng_seed_time(){rng_seed_int(new Date().getTime())}if(rng_pool==null){rng_pool=new Array();rng_pptr=0;var t;if(window!==undefined&&(window.crypto!==undefined||window.msCrypto!==undefined)){var crypto=window.crypto||window.msCrypto;if(crypto.getRandomValues){var ua=new Uint8Array(32);crypto.getRandomValues(ua);for(t=0;t<32;++t){rng_pool[rng_pptr++]=ua[t]}}else{if(navigator.appName==\"Netscape\"&&navigator.appVersion<\"5\"){var z=window.crypto.random(32);for(t=0;t<z.length;++t){rng_pool[rng_pptr++]=z.charCodeAt(t)&255}}}}while(rng_pptr<rng_psize){t=Math.floor(65536*Math.random());rng_pool[rng_pptr++]=t>>>8;rng_pool[rng_pptr++]=t&255}rng_pptr=0;rng_seed_time()}function rng_get_byte(){if(rng_state==null){rng_seed_time();rng_state=prng_newstate();rng_state.init(rng_pool);for(rng_pptr=0;rng_pptr<rng_pool.length;++rng_pptr){rng_pool[rng_pptr]=0}rng_pptr=0}return rng_state.next()}function rng_get_bytes(b){var a;for(a=0;a<b.length;++a){b[a]=rng_get_byte()}}function SecureRandom(){}SecureRandom.prototype.nextBytes=rng_get_bytes;\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nfunction parseBigInt(b,a){return new BigInteger(b,a)}function linebrk(c,d){var a=\"\";var b=0;while(b+d<c.length){a+=c.substring(b,b+d)+\"\\n\";b+=d}return a+c.substring(b,c.length)}function byte2Hex(a){if(a<16){return\"0\"+a.toString(16)}else{return a.toString(16)}}function pkcs1pad2(e,h){if(h<e.length+11){throw\"Message too long for RSA\";return null}var g=new Array();var d=e.length-1;while(d>=0&&h>0){var f=e.charCodeAt(d--);if(f<128){g[--h]=f}else{if((f>127)&&(f<2048)){g[--h]=(f&63)|128;g[--h]=(f>>6)|192}else{g[--h]=(f&63)|128;g[--h]=((f>>6)&63)|128;g[--h]=(f>>12)|224}}}g[--h]=0;var b=new SecureRandom();var a=new Array();while(h>2){a[0]=0;while(a[0]==0){b.nextBytes(a)}g[--h]=a[0]}g[--h]=2;g[--h]=0;return new BigInteger(g)}function oaep_mgf1_arr(c,a,e){var b=\"\",d=0;while(b.length<a){b+=e(String.fromCharCode.apply(String,c.concat([(d&4278190080)>>24,(d&16711680)>>16,(d&65280)>>8,d&255])));d+=1}return b}function oaep_pad(q,a,f,l){var c=KJUR.crypto.MessageDigest;var o=KJUR.crypto.Util;var b=null;if(!f){f=\"sha1\"}if(typeof f===\"string\"){b=c.getCanonicalAlgName(f);l=c.getHashLength(b);f=function(i){return hextorstr(o.hashHex(rstrtohex(i),b))}}if(q.length+2*l+2>a){throw\"Message too long for RSA\"}var k=\"\",e;for(e=0;e<a-q.length-2*l-2;e+=1){k+=\"\\x00\"}var h=f(\"\")+k+\"\\x01\"+q;var g=new Array(l);new SecureRandom().nextBytes(g);var j=oaep_mgf1_arr(g,h.length,f);var p=[];for(e=0;e<h.length;e+=1){p[e]=h.charCodeAt(e)^j.charCodeAt(e)}var m=oaep_mgf1_arr(p,g.length,f);var d=[0];for(e=0;e<g.length;e+=1){d[e+1]=g[e]^m.charCodeAt(e)}return new BigInteger(d.concat(p))}function RSAKey(){this.n=null;this.e=0;this.d=null;this.p=null;this.q=null;this.dmp1=null;this.dmq1=null;this.coeff=null}function RSASetPublic(b,a){this.isPublic=true;this.isPrivate=false;if(typeof b!==\"string\"){this.n=b;this.e=a}else{if(b!=null&&a!=null&&b.length>0&&a.length>0){this.n=parseBigInt(b,16);this.e=parseInt(a,16)}else{throw\"Invalid RSA public key\"}}}function RSADoPublic(a){return a.modPowInt(this.e,this.n)}function RSAEncrypt(d){var a=pkcs1pad2(d,(this.n.bitLength()+7)>>3);if(a==null){return null}var e=this.doPublic(a);if(e==null){return null}var b=e.toString(16);if((b.length&1)==0){return b}else{return\"0\"+b}}function RSAEncryptOAEP(f,e,b){var a=oaep_pad(f,(this.n.bitLength()+7)>>3,e,b);if(a==null){return null}var g=this.doPublic(a);if(g==null){return null}var d=g.toString(16);if((d.length&1)==0){return d}else{return\"0\"+d}}RSAKey.prototype.doPublic=RSADoPublic;RSAKey.prototype.setPublic=RSASetPublic;RSAKey.prototype.encrypt=RSAEncrypt;RSAKey.prototype.encryptOAEP=RSAEncryptOAEP;RSAKey.prototype.type=\"RSA\";\n/*! (c) Tom Wu | http://www-cs-students.stanford.edu/~tjw/jsbn/\r\n */\r\nfunction ECFieldElementFp(b,a){this.x=a;this.q=b}function feFpEquals(a){if(a==this){return true}return(this.q.equals(a.q)&&this.x.equals(a.x))}function feFpToBigInteger(){return this.x}function feFpNegate(){return new ECFieldElementFp(this.q,this.x.negate().mod(this.q))}function feFpAdd(a){return new ECFieldElementFp(this.q,this.x.add(a.toBigInteger()).mod(this.q))}function feFpSubtract(a){return new ECFieldElementFp(this.q,this.x.subtract(a.toBigInteger()).mod(this.q))}function feFpMultiply(a){return new ECFieldElementFp(this.q,this.x.multiply(a.toBigInteger()).mod(this.q))}function feFpSquare(){return new ECFieldElementFp(this.q,this.x.square().mod(this.q))}function feFpDivide(a){return new ECFieldElementFp(this.q,this.x.multiply(a.toBigInteger().modInverse(this.q)).mod(this.q))}ECFieldElementFp.prototype.equals=feFpEquals;ECFieldElementFp.prototype.toBigInteger=feFpToBigInteger;ECFieldElementFp.prototype.negate=feFpNegate;ECFieldElementFp.prototype.add=feFpAdd;ECFieldElementFp.prototype.subtract=feFpSubtract;ECFieldElementFp.prototype.multiply=feFpMultiply;ECFieldElementFp.prototype.square=feFpSquare;ECFieldElementFp.prototype.divide=feFpDivide;function ECPointFp(c,a,d,b){this.curve=c;this.x=a;this.y=d;if(b==null){this.z=BigInteger.ONE}else{this.z=b}this.zinv=null}function pointFpGetX(){if(this.zinv==null){this.zinv=this.z.modInverse(this.curve.q)}return this.curve.fromBigInteger(this.x.toBigInteger().multiply(this.zinv).mod(this.curve.q))}function pointFpGetY(){if(this.zinv==null){this.zinv=this.z.modInverse(this.curve.q)}return this.curve.fromBigInteger(this.y.toBigInteger().multiply(this.zinv).mod(this.curve.q))}function pointFpEquals(a){if(a==this){return true}if(this.isInfinity()){return a.isInfinity()}if(a.isInfinity()){return this.isInfinity()}var c,b;c=a.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(a.z)).mod(this.curve.q);if(!c.equals(BigInteger.ZERO)){return false}b=a.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(a.z)).mod(this.curve.q);return b.equals(BigInteger.ZERO)}function pointFpIsInfinity(){if((this.x==null)&&(this.y==null)){return true}return this.z.equals(BigInteger.ZERO)&&!this.y.toBigInteger().equals(BigInteger.ZERO)}function pointFpNegate(){return new ECPointFp(this.curve,this.x,this.y.negate(),this.z)}function pointFpAdd(l){if(this.isInfinity()){return l}if(l.isInfinity()){return this}var p=l.y.toBigInteger().multiply(this.z).subtract(this.y.toBigInteger().multiply(l.z)).mod(this.curve.q);var o=l.x.toBigInteger().multiply(this.z).subtract(this.x.toBigInteger().multiply(l.z)).mod(this.curve.q);if(BigInteger.ZERO.equals(o)){if(BigInteger.ZERO.equals(p)){return this.twice()}return this.curve.getInfinity()}var j=new BigInteger(\"3\");var e=this.x.toBigInteger();var n=this.y.toBigInteger();var c=l.x.toBigInteger();var k=l.y.toBigInteger();var m=o.square();var i=m.multiply(o);var d=e.multiply(m);var g=p.square().multiply(this.z);var a=g.subtract(d.shiftLeft(1)).multiply(l.z).subtract(i).multiply(o).mod(this.curve.q);var h=d.multiply(j).multiply(p).subtract(n.multiply(i)).subtract(g.multiply(p)).multiply(l.z).add(p.multiply(i)).mod(this.curve.q);var f=i.multiply(this.z).multiply(l.z).mod(this.curve.q);return new ECPointFp(this.curve,this.curve.fromBigInteger(a),this.curve.fromBigInteger(h),f)}function pointFpTwice(){if(this.isInfinity()){return this}if(this.y.toBigInteger().signum()==0){return this.curve.getInfinity()}var g=new BigInteger(\"3\");var c=this.x.toBigInteger();var h=this.y.toBigInteger();var e=h.multiply(this.z);var j=e.multiply(h).mod(this.curve.q);var i=this.curve.a.toBigInteger();var k=c.square().multiply(g);if(!BigInteger.ZERO.equals(i)){k=k.add(this.z.square().multiply(i))}k=k.mod(this.curve.q);var b=k.square().subtract(c.shiftLeft(3).multiply(j)).shiftLeft(1).multiply(e).mod(this.curve.q);var f=k.multiply(g).multiply(c).subtract(j.shiftLeft(1)).shiftLeft(2).multiply(j).subtract(k.square().multiply(k)).mod(this.curve.q);var d=e.square().multiply(e).shiftLeft(3).mod(this.curve.q);return new ECPointFp(this.curve,this.curve.fromBigInteger(b),this.curve.fromBigInteger(f),d)}function pointFpMultiply(b){if(this.isInfinity()){return this}if(b.signum()==0){return this.curve.getInfinity()}var g=b;var f=g.multiply(new BigInteger(\"3\"));var l=this.negate();var d=this;var c;for(c=f.bitLength()-2;c>0;--c){d=d.twice();var a=f.testBit(c);var j=g.testBit(c);if(a!=j){d=d.add(a?this:l)}}return d}function pointFpMultiplyTwo(c,a,b){var d;if(c.bitLength()>b.bitLength()){d=c.bitLength()-1}else{d=b.bitLength()-1}var f=this.curve.getInfinity();var e=this.add(a);while(d>=0){f=f.twice();if(c.testBit(d)){if(b.testBit(d)){f=f.add(e)}else{f=f.add(this)}}else{if(b.testBit(d)){f=f.add(a)}}--d}return f}ECPointFp.prototype.getX=pointFpGetX;ECPointFp.prototype.getY=pointFpGetY;ECPointFp.prototype.equals=pointFpEquals;ECPointFp.prototype.isInfinity=pointFpIsInfinity;ECPointFp.prototype.negate=pointFpNegate;ECPointFp.prototype.add=pointFpAdd;ECPointFp.prototype.twice=pointFpTwice;ECPointFp.prototype.multiply=pointFpMultiply;ECPointFp.prototype.multiplyTwo=pointFpMultiplyTwo;function ECCurveFp(e,d,c){this.q=e;this.a=this.fromBigInteger(d);this.b=this.fromBigInteger(c);this.infinity=new ECPointFp(this,null,null)}function curveFpGetQ(){return this.q}function curveFpGetA(){return this.a}function curveFpGetB(){return this.b}function curveFpEquals(a){if(a==this){return true}return(this.q.equals(a.q)&&this.a.equals(a.a)&&this.b.equals(a.b))}function curveFpGetInfinity(){return this.infinity}function curveFpFromBigInteger(a){return new ECFieldElementFp(this.q,a)}function curveFpDecodePointHex(d){switch(parseInt(d.substr(0,2),16)){case 0:return this.infinity;case 2:case 3:return null;case 4:case 6:case 7:var a=(d.length-2)/2;var c=d.substr(2,a);var b=d.substr(a+2,a);return new ECPointFp(this,this.fromBigInteger(new BigInteger(c,16)),this.fromBigInteger(new BigInteger(b,16)));default:return null}}ECCurveFp.prototype.getQ=curveFpGetQ;ECCurveFp.prototype.getA=curveFpGetA;ECCurveFp.prototype.getB=curveFpGetB;ECCurveFp.prototype.equals=curveFpEquals;ECCurveFp.prototype.getInfinity=curveFpGetInfinity;ECCurveFp.prototype.fromBigInteger=curveFpFromBigInteger;ECCurveFp.prototype.decodePointHex=curveFpDecodePointHex;\n/*! (c) Stefan Thomas | https://github.com/bitcoinjs/bitcoinjs-lib\r\n */\r\nECFieldElementFp.prototype.getByteLength=function(){return Math.floor((this.toBigInteger().bitLength()+7)/8)};ECPointFp.prototype.getEncoded=function(c){var d=function(h,f){var g=h.toByteArrayUnsigned();if(f<g.length){g=g.slice(g.length-f)}else{while(f>g.length){g.unshift(0)}}return g};var a=this.getX().toBigInteger();var e=this.getY().toBigInteger();var b=d(a,32);if(c){if(e.isEven()){b.unshift(2)}else{b.unshift(3)}}else{b.unshift(4);b=b.concat(d(e,32))}return b};ECPointFp.decodeFrom=function(g,c){var f=c[0];var e=c.length-1;var d=c.slice(1,1+e/2);var b=c.slice(1+e/2,1+e);d.unshift(0);b.unshift(0);var a=new BigInteger(d);var h=new BigInteger(b);return new ECPointFp(g,g.fromBigInteger(a),g.fromBigInteger(h))};ECPointFp.decodeFromHex=function(g,c){var f=c.substr(0,2);var e=c.length-2;var d=c.substr(2,e/2);var b=c.substr(2+e/2,e/2);var a=new BigInteger(d,16);var h=new BigInteger(b,16);return new ECPointFp(g,g.fromBigInteger(a),g.fromBigInteger(h))};ECPointFp.prototype.add2D=function(c){if(this.isInfinity()){return c}if(c.isInfinity()){return this}if(this.x.equals(c.x)){if(this.y.equals(c.y)){return this.twice()}return this.curve.getInfinity()}var g=c.x.subtract(this.x);var e=c.y.subtract(this.y);var a=e.divide(g);var d=a.square().subtract(this.x).subtract(c.x);var f=a.multiply(this.x.subtract(d)).subtract(this.y);return new ECPointFp(this.curve,d,f)};ECPointFp.prototype.twice2D=function(){if(this.isInfinity()){return this}if(this.y.toBigInteger().signum()==0){return this.curve.getInfinity()}var b=this.curve.fromBigInteger(BigInteger.valueOf(2));var e=this.curve.fromBigInteger(BigInteger.valueOf(3));var a=this.x.square().multiply(e).add(this.curve.a).divide(this.y.multiply(b));var c=a.square().subtract(this.x.multiply(b));var d=a.multiply(this.x.subtract(c)).subtract(this.y);return new ECPointFp(this.curve,c,d)};ECPointFp.prototype.multiply2D=function(b){if(this.isInfinity()){return this}if(b.signum()==0){return this.curve.getInfinity()}var g=b;var f=g.multiply(new BigInteger(\"3\"));var l=this.negate();var d=this;var c;for(c=f.bitLength()-2;c>0;--c){d=d.twice();var a=f.testBit(c);var j=g.testBit(c);if(a!=j){d=d.add2D(a?this:l)}}return d};ECPointFp.prototype.isOnCurve=function(){var d=this.getX().toBigInteger();var i=this.getY().toBigInteger();var f=this.curve.getA().toBigInteger();var c=this.curve.getB().toBigInteger();var h=this.curve.getQ();var e=i.multiply(i).mod(h);var g=d.multiply(d).multiply(d).add(f.multiply(d)).add(c).mod(h);return e.equals(g)};ECPointFp.prototype.toString=function(){return\"(\"+this.getX().toBigInteger().toString()+\",\"+this.getY().toBigInteger().toString()+\")\"};ECPointFp.prototype.validate=function(){var c=this.curve.getQ();if(this.isInfinity()){throw new Error(\"Point is at infinity.\")}var a=this.getX().toBigInteger();var b=this.getY().toBigInteger();if(a.compareTo(BigInteger.ONE)<0||a.compareTo(c.subtract(BigInteger.ONE))>0){throw new Error(\"x coordinate out of bounds\")}if(b.compareTo(BigInteger.ONE)<0||b.compareTo(c.subtract(BigInteger.ONE))>0){throw new Error(\"y coordinate out of bounds\")}if(!this.isOnCurve()){throw new Error(\"Point is not on the curve.\")}if(this.multiply(c).isInfinity()){throw new Error(\"Point is not a scalar multiple of G.\")}return true};\n/*! Mike Samuel (c) 2009 | code.google.com/p/json-sans-eval\r\n */\r\nvar jsonParse=(function(){var e=\"(?:-?\\\\b(?:0|[1-9][0-9]*)(?:\\\\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\\\\b)\";var j='(?:[^\\\\0-\\\\x08\\\\x0a-\\\\x1f\"\\\\\\\\]|\\\\\\\\(?:[\"/\\\\\\\\bfnrt]|u[0-9A-Fa-f]{4}))';var i='(?:\"'+j+'*\")';var d=new RegExp(\"(?:false|true|null|[\\\\{\\\\}\\\\[\\\\]]|\"+e+\"|\"+i+\")\",\"g\");var k=new RegExp(\"\\\\\\\\(?:([^u])|u(.{4}))\",\"g\");var g={'\"':'\"',\"/\":\"/\",\"\\\\\":\"\\\\\",b:\"\\b\",f:\"\\f\",n:\"\\n\",r:\"\\r\",t:\"\\t\"};function h(l,m,n){return m?g[m]:String.fromCharCode(parseInt(n,16))}var c=new String(\"\");var a=\"\\\\\";var f={\"{\":Object,\"[\":Array};var b=Object.hasOwnProperty;return function(u,q){var p=u.match(d);var x;var v=p[0];var l=false;if(\"{\"===v){x={}}else{if(\"[\"===v){x=[]}else{x=[];l=true}}var t;var r=[x];for(var o=1-l,m=p.length;o<m;++o){v=p[o];var w;switch(v.charCodeAt(0)){default:w=r[0];w[t||w.length]=+(v);t=void 0;break;case 34:v=v.substring(1,v.length-1);if(v.indexOf(a)!==-1){v=v.replace(k,h)}w=r[0];if(!t){if(w instanceof Array){t=w.length}else{t=v||c;break}}w[t]=v;t=void 0;break;case 91:w=r[0];r.unshift(w[t||w.length]=[]);t=void 0;break;case 93:r.shift();break;case 102:w=r[0];w[t||w.length]=false;t=void 0;break;case 110:w=r[0];w[t||w.length]=null;t=void 0;break;case 116:w=r[0];w[t||w.length]=true;t=void 0;break;case 123:w=r[0];r.unshift(w[t||w.length]={});t=void 0;break;case 125:r.shift();break}}if(l){if(r.length!==1){throw new Error()}x=x[0]}else{if(r.length){throw new Error()}}if(q){var s=function(C,B){var D=C[B];if(D&&typeof D===\"object\"){var n=null;for(var z in D){if(b.call(D,z)&&D!==C){var y=s(D,z);if(y!==void 0){D[z]=y}else{if(!n){n=[]}n.push(z)}}}if(n){for(var A=n.length;--A>=0;){delete D[n[A]]}}}return q.call(C,B,D)};x=s({\"\":x},\"\")}return x}})();\nif(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.asn1==\"undefined\"||!KJUR.asn1){KJUR.asn1={}}KJUR.asn1.ASN1Util=new function(){this.integerToByteHex=function(a){var b=a.toString(16);if((b.length%2)==1){b=\"0\"+b}return b};this.bigIntToMinTwosComplementsHex=function(j){var f=j.toString(16);if(f.substr(0,1)!=\"-\"){if(f.length%2==1){f=\"0\"+f}else{if(!f.match(/^[0-7]/)){f=\"00\"+f}}}else{var a=f.substr(1);var e=a.length;if(e%2==1){e+=1}else{if(!f.match(/^[0-7]/)){e+=2}}var g=\"\";for(var d=0;d<e;d++){g+=\"f\"}var c=new BigInteger(g,16);var b=c.xor(j).add(BigInteger.ONE);f=b.toString(16).replace(/^-/,\"\")}return f};this.getPEMStringFromHex=function(a,b){return hextopem(a,b)};this.newObject=function(k){var D=KJUR,n=D.asn1,z=n.DERBoolean,e=n.DERInteger,s=n.DERBitString,h=n.DEROctetString,v=n.DERNull,w=n.DERObjectIdentifier,l=n.DEREnumerated,g=n.DERUTF8String,f=n.DERNumericString,y=n.DERPrintableString,u=n.DERTeletexString,p=n.DERIA5String,C=n.DERUTCTime,j=n.DERGeneralizedTime,m=n.DERSequence,c=n.DERSet,r=n.DERTaggedObject,o=n.ASN1Util.newObject;var t=Object.keys(k);if(t.length!=1){throw\"key of param shall be only one.\"}var F=t[0];if(\":bool:int:bitstr:octstr:null:oid:enum:utf8str:numstr:prnstr:telstr:ia5str:utctime:gentime:seq:set:tag:\".indexOf(\":\"+F+\":\")==-1){throw\"undefined key: \"+F}if(F==\"bool\"){return new z(k[F])}if(F==\"int\"){return new e(k[F])}if(F==\"bitstr\"){return new s(k[F])}if(F==\"octstr\"){return new h(k[F])}if(F==\"null\"){return new v(k[F])}if(F==\"oid\"){return new w(k[F])}if(F==\"enum\"){return new l(k[F])}if(F==\"utf8str\"){return new g(k[F])}if(F==\"numstr\"){return new f(k[F])}if(F==\"prnstr\"){return new y(k[F])}if(F==\"telstr\"){return new u(k[F])}if(F==\"ia5str\"){return new p(k[F])}if(F==\"utctime\"){return new C(k[F])}if(F==\"gentime\"){return new j(k[F])}if(F==\"seq\"){var d=k[F];var E=[];for(var x=0;x<d.length;x++){var B=o(d[x]);E.push(B)}return new m({array:E})}if(F==\"set\"){var d=k[F];var E=[];for(var x=0;x<d.length;x++){var B=o(d[x]);E.push(B)}return new c({array:E})}if(F==\"tag\"){var A=k[F];if(Object.prototype.toString.call(A)===\"[object Array]\"&&A.length==3){var q=o(A[2]);return new r({tag:A[0],explicit:A[1],obj:q})}else{var b={};if(A.explicit!==undefined){b.explicit=A.explicit}if(A.tag!==undefined){b.tag=A.tag}if(A.obj===undefined){throw\"obj shall be specified for 'tag'.\"}b.obj=o(A.obj);return new r(b)}}};this.jsonToASN1HEX=function(b){var a=this.newObject(b);return a.getEncodedHex()}};KJUR.asn1.ASN1Util.oidHexToInt=function(a){var j=\"\";var k=parseInt(a.substr(0,2),16);var d=Math.floor(k/40);var c=k%40;var j=d+\".\"+c;var e=\"\";for(var f=2;f<a.length;f+=2){var g=parseInt(a.substr(f,2),16);var h=(\"00000000\"+g.toString(2)).slice(-8);e=e+h.substr(1,7);if(h.substr(0,1)==\"0\"){var b=new BigInteger(e,2);j=j+\".\"+b.toString(10);e=\"\"}}return j};KJUR.asn1.ASN1Util.oidIntToHex=function(f){var e=function(a){var k=a.toString(16);if(k.length==1){k=\"0\"+k}return k};var d=function(o){var n=\"\";var k=new BigInteger(o,10);var a=k.toString(2);var l=7-a.length%7;if(l==7){l=0}var q=\"\";for(var m=0;m<l;m++){q+=\"0\"}a=q+a;for(var m=0;m<a.length-1;m+=7){var p=a.substr(m,7);if(m!=a.length-7){p=\"1\"+p}n+=e(parseInt(p,2))}return n};if(!f.match(/^[0-9.]+$/)){throw\"malformed oid string: \"+f}var g=\"\";var b=f.split(\".\");var j=parseInt(b[0])*40+parseInt(b[1]);g+=e(j);b.splice(0,2);for(var c=0;c<b.length;c++){g+=d(b[c])}return g};KJUR.asn1.ASN1Object=function(){var c=true;var b=null;var d=\"00\";var e=\"00\";var a=\"\";this.getLengthHexFromValue=function(){if(typeof this.hV==\"undefined\"||this.hV==null){throw\"this.hV is null or undefined.\"}if(this.hV.length%2==1){throw\"value hex must be even length: n=\"+a.length+\",v=\"+this.hV}var i=this.hV.length/2;var h=i.toString(16);if(h.length%2==1){h=\"0\"+h}if(i<128){return h}else{var g=h.length/2;if(g>15){throw\"ASN.1 length too long to represent by 8x: n = \"+i.toString(16)}var f=128+g;return f.toString(16)+h}};this.getEncodedHex=function(){if(this.hTLV==null||this.isModified){this.hV=this.getFreshValueHex();this.hL=this.getLengthHexFromValue();this.hTLV=this.hT+this.hL+this.hV;this.isModified=false}return this.hTLV};this.getValueHex=function(){this.getEncodedHex();return this.hV};this.getFreshValueHex=function(){return\"\"}};KJUR.asn1.DERAbstractString=function(c){KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var b=null;var a=null;this.getString=function(){return this.s};this.setString=function(d){this.hTLV=null;this.isModified=true;this.s=d;this.hV=utf8tohex(this.s).toLowerCase()};this.setStringHex=function(d){this.hTLV=null;this.isModified=true;this.s=null;this.hV=d};this.getFreshValueHex=function(){return this.hV};if(typeof c!=\"undefined\"){if(typeof c==\"string\"){this.setString(c)}else{if(typeof c.str!=\"undefined\"){this.setString(c.str)}else{if(typeof c.hex!=\"undefined\"){this.setStringHex(c.hex)}}}}};YAHOO.lang.extend(KJUR.asn1.DERAbstractString,KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractTime=function(c){KJUR.asn1.DERAbstractTime.superclass.constructor.call(this);var b=null;var a=null;this.localDateToUTC=function(f){utc=f.getTime()+(f.getTimezoneOffset()*60000);var e=new Date(utc);return e};this.formatDate=function(m,o,e){var g=this.zeroPadding;var n=this.localDateToUTC(m);var p=String(n.getFullYear());if(o==\"utc\"){p=p.substr(2,2)}var l=g(String(n.getMonth()+1),2);var q=g(String(n.getDate()),2);var h=g(String(n.getHours()),2);var i=g(String(n.getMinutes()),2);var j=g(String(n.getSeconds()),2);var r=p+l+q+h+i+j;if(e===true){var f=n.getMilliseconds();if(f!=0){var k=g(String(f),3);k=k.replace(/[0]+$/,\"\");r=r+\".\"+k}}return r+\"Z\"};this.zeroPadding=function(e,d){if(e.length>=d){return e}return new Array(d-e.length+1).join(\"0\")+e};this.getString=function(){return this.s};this.setString=function(d){this.hTLV=null;this.isModified=true;this.s=d;this.hV=stohex(d)};this.setByDateValue=function(h,j,e,d,f,g){var i=new Date(Date.UTC(h,j-1,e,d,f,g,0));this.setByDate(i)};this.getFreshValueHex=function(){return this.hV}};YAHOO.lang.extend(KJUR.asn1.DERAbstractTime,KJUR.asn1.ASN1Object);KJUR.asn1.DERAbstractStructured=function(b){KJUR.asn1.DERAbstractString.superclass.constructor.call(this);var a=null;this.setByASN1ObjectArray=function(c){this.hTLV=null;this.isModified=true;this.asn1Array=c};this.appendASN1Object=function(c){this.hTLV=null;this.isModified=true;this.asn1Array.push(c)};this.asn1Array=new Array();if(typeof b!=\"undefined\"){if(typeof b.array!=\"undefined\"){this.asn1Array=b.array}}};YAHOO.lang.extend(KJUR.asn1.DERAbstractStructured,KJUR.asn1.ASN1Object);KJUR.asn1.DERBoolean=function(){KJUR.asn1.DERBoolean.superclass.constructor.call(this);this.hT=\"01\";this.hTLV=\"0101ff\"};YAHOO.lang.extend(KJUR.asn1.DERBoolean,KJUR.asn1.ASN1Object);KJUR.asn1.DERInteger=function(a){KJUR.asn1.DERInteger.superclass.constructor.call(this);this.hT=\"02\";this.setByBigInteger=function(b){this.hTLV=null;this.isModified=true;this.hV=KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b)};this.setByInteger=function(c){var b=new BigInteger(String(c),10);this.setByBigInteger(b)};this.setValueHex=function(b){this.hV=b};this.getFreshValueHex=function(){return this.hV};if(typeof a!=\"undefined\"){if(typeof a.bigint!=\"undefined\"){this.setByBigInteger(a.bigint)}else{if(typeof a[\"int\"]!=\"undefined\"){this.setByInteger(a[\"int\"])}else{if(typeof a==\"number\"){this.setByInteger(a)}else{if(typeof a.hex!=\"undefined\"){this.setValueHex(a.hex)}}}}}};YAHOO.lang.extend(KJUR.asn1.DERInteger,KJUR.asn1.ASN1Object);KJUR.asn1.DERBitString=function(b){if(b!==undefined&&typeof b.obj!==\"undefined\"){var a=KJUR.asn1.ASN1Util.newObject(b.obj);b.hex=\"00\"+a.getEncodedHex()}KJUR.asn1.DERBitString.superclass.constructor.call(this);this.hT=\"03\";this.setHexValueIncludingUnusedBits=function(c){this.hTLV=null;this.isModified=true;this.hV=c};this.setUnusedBitsAndHexValue=function(c,e){if(c<0||7<c){throw\"unused bits shall be from 0 to 7: u = \"+c}var d=\"0\"+c;this.hTLV=null;this.isModified=true;this.hV=d+e};this.setByBinaryString=function(e){e=e.replace(/0+$/,\"\");var f=8-e.length%8;if(f==8){f=0}for(var g=0;g<=f;g++){e+=\"0\"}var j=\"\";for(var g=0;g<e.length-1;g+=8){var d=e.substr(g,8);var c=parseInt(d,2).toString(16);if(c.length==1){c=\"0\"+c}j+=c}this.hTLV=null;this.isModified=true;this.hV=\"0\"+f+j};this.setByBooleanArray=function(e){var d=\"\";for(var c=0;c<e.length;c++){if(e[c]==true){d+=\"1\"}else{d+=\"0\"}}this.setByBinaryString(d)};this.newFalseArray=function(e){var c=new Array(e);for(var d=0;d<e;d++){c[d]=false}return c};this.getFreshValueHex=function(){return this.hV};if(typeof b!=\"undefined\"){if(typeof b==\"string\"&&b.toLowerCase().match(/^[0-9a-f]+$/)){this.setHexValueIncludingUnusedBits(b)}else{if(typeof b.hex!=\"undefined\"){this.setHexValueIncludingUnusedBits(b.hex)}else{if(typeof b.bin!=\"undefined\"){this.setByBinaryString(b.bin)}else{if(typeof b.array!=\"undefined\"){this.setByBooleanArray(b.array)}}}}}};YAHOO.lang.extend(KJUR.asn1.DERBitString,KJUR.asn1.ASN1Object);KJUR.asn1.DEROctetString=function(b){if(b!==undefined&&typeof b.obj!==\"undefined\"){var a=KJUR.asn1.ASN1Util.newObject(b.obj);b.hex=a.getEncodedHex()}KJUR.asn1.DEROctetString.superclass.constructor.call(this,b);this.hT=\"04\"};YAHOO.lang.extend(KJUR.asn1.DEROctetString,KJUR.asn1.DERAbstractString);KJUR.asn1.DERNull=function(){KJUR.asn1.DERNull.superclass.constructor.call(this);this.hT=\"05\";this.hTLV=\"0500\"};YAHOO.lang.extend(KJUR.asn1.DERNull,KJUR.asn1.ASN1Object);KJUR.asn1.DERObjectIdentifier=function(c){var b=function(d){var e=d.toString(16);if(e.length==1){e=\"0\"+e}return e};var a=function(k){var j=\"\";var e=new BigInteger(k,10);var d=e.toString(2);var f=7-d.length%7;if(f==7){f=0}var m=\"\";for(var g=0;g<f;g++){m+=\"0\"}d=m+d;for(var g=0;g<d.length-1;g+=7){var l=d.substr(g,7);if(g!=d.length-7){l=\"1\"+l}j+=b(parseInt(l,2))}return j};KJUR.asn1.DERObjectIdentifier.superclass.constructor.call(this);this.hT=\"06\";this.setValueHex=function(d){this.hTLV=null;this.isModified=true;this.s=null;this.hV=d};this.setValueOidString=function(f){if(!f.match(/^[0-9.]+$/)){throw\"malformed oid string: \"+f}var g=\"\";var d=f.split(\".\");var j=parseInt(d[0])*40+parseInt(d[1]);g+=b(j);d.splice(0,2);for(var e=0;e<d.length;e++){g+=a(d[e])}this.hTLV=null;this.isModified=true;this.s=null;this.hV=g};this.setValueName=function(e){var d=KJUR.asn1.x509.OID.name2oid(e);if(d!==\"\"){this.setValueOidString(d)}else{throw\"DERObjectIdentifier oidName undefined: \"+e}};this.getFreshValueHex=function(){return this.hV};if(c!==undefined){if(typeof c===\"string\"){if(c.match(/^[0-2].[0-9.]+$/)){this.setValueOidString(c)}else{this.setValueName(c)}}else{if(c.oid!==undefined){this.setValueOidString(c.oid)}else{if(c.hex!==undefined){this.setValueHex(c.hex)}else{if(c.name!==undefined){this.setValueName(c.name)}}}}}};YAHOO.lang.extend(KJUR.asn1.DERObjectIdentifier,KJUR.asn1.ASN1Object);KJUR.asn1.DEREnumerated=function(a){KJUR.asn1.DEREnumerated.superclass.constructor.call(this);this.hT=\"0a\";this.setByBigInteger=function(b){this.hTLV=null;this.isModified=true;this.hV=KJUR.asn1.ASN1Util.bigIntToMinTwosComplementsHex(b)};this.setByInteger=function(c){var b=new BigInteger(String(c),10);this.setByBigInteger(b)};this.setValueHex=function(b){this.hV=b};this.getFreshValueHex=function(){return this.hV};if(typeof a!=\"undefined\"){if(typeof a[\"int\"]!=\"undefined\"){this.setByInteger(a[\"int\"])}else{if(typeof a==\"number\"){this.setByInteger(a)}else{if(typeof a.hex!=\"undefined\"){this.setValueHex(a.hex)}}}}};YAHOO.lang.extend(KJUR.asn1.DEREnumerated,KJUR.asn1.ASN1Object);KJUR.asn1.DERUTF8String=function(a){KJUR.asn1.DERUTF8String.superclass.constructor.call(this,a);this.hT=\"0c\"};YAHOO.lang.extend(KJUR.asn1.DERUTF8String,KJUR.asn1.DERAbstractString);KJUR.asn1.DERNumericString=function(a){KJUR.asn1.DERNumericString.superclass.constructor.call(this,a);this.hT=\"12\"};YAHOO.lang.extend(KJUR.asn1.DERNumericString,KJUR.asn1.DERAbstractString);KJUR.asn1.DERPrintableString=function(a){KJUR.asn1.DERPrintableString.superclass.constructor.call(this,a);this.hT=\"13\"};YAHOO.lang.extend(KJUR.asn1.DERPrintableString,KJUR.asn1.DERAbstractString);KJUR.asn1.DERTeletexString=function(a){KJUR.asn1.DERTeletexString.superclass.constructor.call(this,a);this.hT=\"14\"};YAHOO.lang.extend(KJUR.asn1.DERTeletexString,KJUR.asn1.DERAbstractString);KJUR.asn1.DERIA5String=function(a){KJUR.asn1.DERIA5String.superclass.constructor.call(this,a);this.hT=\"16\"};YAHOO.lang.extend(KJUR.asn1.DERIA5String,KJUR.asn1.DERAbstractString);KJUR.asn1.DERUTCTime=function(a){KJUR.asn1.DERUTCTime.superclass.constructor.call(this,a);this.hT=\"17\";this.setByDate=function(b){this.hTLV=null;this.isModified=true;this.date=b;this.s=this.formatDate(this.date,\"utc\");this.hV=stohex(this.s)};this.getFreshValueHex=function(){if(typeof this.date==\"undefined\"&&typeof this.s==\"undefined\"){this.date=new Date();this.s=this.formatDate(this.date,\"utc\");this.hV=stohex(this.s)}return this.hV};if(a!==undefined){if(a.str!==undefined){this.setString(a.str)}else{if(typeof a==\"string\"&&a.match(/^[0-9]{12}Z$/)){this.setString(a)}else{if(a.hex!==undefined){this.setStringHex(a.hex)}else{if(a.date!==undefined){this.setByDate(a.date)}}}}}};YAHOO.lang.extend(KJUR.asn1.DERUTCTime,KJUR.asn1.DERAbstractTime);KJUR.asn1.DERGeneralizedTime=function(a){KJUR.asn1.DERGeneralizedTime.superclass.constructor.call(this,a);this.hT=\"18\";this.withMillis=false;this.setByDate=function(b){this.hTLV=null;this.isModified=true;this.date=b;this.s=this.formatDate(this.date,\"gen\",this.withMillis);this.hV=stohex(this.s)};this.getFreshValueHex=function(){if(this.date===undefined&&this.s===undefined){this.date=new Date();this.s=this.formatDate(this.date,\"gen\",this.withMillis);this.hV=stohex(this.s)}return this.hV};if(a!==undefined){if(a.str!==undefined){this.setString(a.str)}else{if(typeof a==\"string\"&&a.match(/^[0-9]{14}Z$/)){this.setString(a)}else{if(a.hex!==undefined){this.setStringHex(a.hex)}else{if(a.date!==undefined){this.setByDate(a.date)}}}}if(a.millis===true){this.withMillis=true}}};YAHOO.lang.extend(KJUR.asn1.DERGeneralizedTime,KJUR.asn1.DERAbstractTime);KJUR.asn1.DERSequence=function(a){KJUR.asn1.DERSequence.superclass.constructor.call(this,a);this.hT=\"30\";this.getFreshValueHex=function(){var c=\"\";for(var b=0;b<this.asn1Array.length;b++){var d=this.asn1Array[b];c+=d.getEncodedHex()}this.hV=c;return this.hV}};YAHOO.lang.extend(KJUR.asn1.DERSequence,KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERSet=function(a){KJUR.asn1.DERSet.superclass.constructor.call(this,a);this.hT=\"31\";this.sortFlag=true;this.getFreshValueHex=function(){var b=new Array();for(var c=0;c<this.asn1Array.length;c++){var d=this.asn1Array[c];b.push(d.getEncodedHex())}if(this.sortFlag==true){b.sort()}this.hV=b.join(\"\");return this.hV};if(typeof a!=\"undefined\"){if(typeof a.sortflag!=\"undefined\"&&a.sortflag==false){this.sortFlag=false}}};YAHOO.lang.extend(KJUR.asn1.DERSet,KJUR.asn1.DERAbstractStructured);KJUR.asn1.DERTaggedObject=function(a){KJUR.asn1.DERTaggedObject.superclass.constructor.call(this);this.hT=\"a0\";this.hV=\"\";this.isExplicit=true;this.asn1Object=null;this.setASN1Object=function(b,c,d){this.hT=c;this.isExplicit=b;this.asn1Object=d;if(this.isExplicit){this.hV=this.asn1Object.getEncodedHex();this.hTLV=null;this.isModified=true}else{this.hV=null;this.hTLV=d.getEncodedHex();this.hTLV=this.hTLV.replace(/^../,c);this.isModified=false}};this.getFreshValueHex=function(){return this.hV};if(typeof a!=\"undefined\"){if(typeof a.tag!=\"undefined\"){this.hT=a.tag}if(typeof a.explicit!=\"undefined\"){this.isExplicit=a.explicit}if(typeof a.obj!=\"undefined\"){this.asn1Object=a.obj;this.setASN1Object(this.isExplicit,this.hT,this.asn1Object)}}};YAHOO.lang.extend(KJUR.asn1.DERTaggedObject,KJUR.asn1.ASN1Object);\nvar ASN1HEX=new function(){};ASN1HEX.getLblen=function(c,a){if(c.substr(a+2,1)!=\"8\"){return 1}var b=parseInt(c.substr(a+3,1));if(b==0){return -1}if(0<b&&b<10){return b+1}return -2};ASN1HEX.getL=function(c,b){var a=ASN1HEX.getLblen(c,b);if(a<1){return\"\"}return c.substr(b+2,a*2)};ASN1HEX.getVblen=function(d,a){var c,b;c=ASN1HEX.getL(d,a);if(c==\"\"){return -1}if(c.substr(0,1)===\"8\"){b=new BigInteger(c.substr(2),16)}else{b=new BigInteger(c,16)}return b.intValue()};ASN1HEX.getVidx=function(c,b){var a=ASN1HEX.getLblen(c,b);if(a<0){return a}return b+(a+1)*2};ASN1HEX.getV=function(d,a){var c=ASN1HEX.getVidx(d,a);var b=ASN1HEX.getVblen(d,a);return d.substr(c,b*2)};ASN1HEX.getTLV=function(b,a){return b.substr(a,2)+ASN1HEX.getL(b,a)+ASN1HEX.getV(b,a)};ASN1HEX.getNextSiblingIdx=function(d,a){var c=ASN1HEX.getVidx(d,a);var b=ASN1HEX.getVblen(d,a);return c+b*2};ASN1HEX.getChildIdx=function(e,f){var j=ASN1HEX;var g=new Array();var i=j.getVidx(e,f);if(e.substr(f,2)==\"03\"){g.push(i+2)}else{g.push(i)}var l=j.getVblen(e,f);var c=i;var d=0;while(1){var b=j.getNextSiblingIdx(e,c);if(b==null||(b-i>=(l*2))){break}if(d>=200){break}g.push(b);c=b;d++}return g};ASN1HEX.getNthChildIdx=function(d,b,e){var c=ASN1HEX.getChildIdx(d,b);return c[e]};ASN1HEX.getIdxbyList=function(e,d,c,i){var g=ASN1HEX;var f,b;if(c.length==0){if(i!==undefined){if(e.substr(d,2)!==i){throw\"checking tag doesn't match: \"+e.substr(d,2)+\"!=\"+i}}return d}f=c.shift();b=g.getChildIdx(e,d);return g.getIdxbyList(e,b[f],c,i)};ASN1HEX.getTLVbyList=function(d,c,b,f){var e=ASN1HEX;var a=e.getIdxbyList(d,c,b);if(a===undefined){throw\"can't find nthList object\"}if(f!==undefined){if(d.substr(a,2)!=f){throw\"checking tag doesn't match: \"+d.substr(a,2)+\"!=\"+f}}return e.getTLV(d,a)};ASN1HEX.getVbyList=function(e,c,b,g,i){var f=ASN1HEX;var a,d;a=f.getIdxbyList(e,c,b,g);if(a===undefined){throw\"can't find nthList object\"}d=f.getV(e,a);if(i===true){d=d.substr(2)}return d};ASN1HEX.hextooidstr=function(e){var h=function(b,a){if(b.length>=a){return b}return new Array(a-b.length+1).join(\"0\")+b};var l=[];var o=e.substr(0,2);var f=parseInt(o,16);l[0]=new String(Math.floor(f/40));l[1]=new String(f%40);var m=e.substr(2);var k=[];for(var g=0;g<m.length/2;g++){k.push(parseInt(m.substr(g*2,2),16))}var j=[];var d=\"\";for(var g=0;g<k.length;g++){if(k[g]&128){d=d+h((k[g]&127).toString(2),7)}else{d=d+h((k[g]&127).toString(2),7);j.push(new String(parseInt(d,2)));d=\"\"}}var n=l.join(\".\");if(j.length>0){n=n+\".\"+j.join(\".\")}return n};ASN1HEX.dump=function(t,c,l,g){var p=ASN1HEX;var j=p.getV;var y=p.dump;var w=p.getChildIdx;var e=t;if(t instanceof KJUR.asn1.ASN1Object){e=t.getEncodedHex()}var q=function(A,i){if(A.length<=i*2){return A}else{var v=A.substr(0,i)+\"..(total \"+A.length/2+\"bytes)..\"+A.substr(A.length-i,i);return v}};if(c===undefined){c={ommit_long_octet:32}}if(l===undefined){l=0}if(g===undefined){g=\"\"}var x=c.ommit_long_octet;if(e.substr(l,2)==\"01\"){var h=j(e,l);if(h==\"00\"){return g+\"BOOLEAN FALSE\\n\"}else{return g+\"BOOLEAN TRUE\\n\"}}if(e.substr(l,2)==\"02\"){var h=j(e,l);return g+\"INTEGER \"+q(h,x)+\"\\n\"}if(e.substr(l,2)==\"03\"){var h=j(e,l);return g+\"BITSTRING \"+q(h,x)+\"\\n\"}if(e.substr(l,2)==\"04\"){var h=j(e,l);if(p.isASN1HEX(h)){var k=g+\"OCTETSTRING, encapsulates\\n\";k=k+y(h,c,0,g+\"  \");return k}else{return g+\"OCTETSTRING \"+q(h,x)+\"\\n\"}}if(e.substr(l,2)==\"05\"){return g+\"NULL\\n\"}if(e.substr(l,2)==\"06\"){var m=j(e,l);var a=KJUR.asn1.ASN1Util.oidHexToInt(m);var o=KJUR.asn1.x509.OID.oid2name(a);var b=a.replace(/\\./g,\" \");if(o!=\"\"){return g+\"ObjectIdentifier \"+o+\" (\"+b+\")\\n\"}else{return g+\"ObjectIdentifier (\"+b+\")\\n\"}}if(e.substr(l,2)==\"0c\"){return g+\"UTF8String '\"+hextoutf8(j(e,l))+\"'\\n\"}if(e.substr(l,2)==\"13\"){return g+\"PrintableString '\"+hextoutf8(j(e,l))+\"'\\n\"}if(e.substr(l,2)==\"14\"){return g+\"TeletexString '\"+hextoutf8(j(e,l))+\"'\\n\"}if(e.substr(l,2)==\"16\"){return g+\"IA5String '\"+hextoutf8(j(e,l))+\"'\\n\"}if(e.substr(l,2)==\"17\"){return g+\"UTCTime \"+hextoutf8(j(e,l))+\"\\n\"}if(e.substr(l,2)==\"18\"){return g+\"GeneralizedTime \"+hextoutf8(j(e,l))+\"\\n\"}if(e.substr(l,2)==\"30\"){if(e.substr(l,4)==\"3000\"){return g+\"SEQUENCE {}\\n\"}var k=g+\"SEQUENCE\\n\";var d=w(e,l);var f=c;if((d.length==2||d.length==3)&&e.substr(d[0],2)==\"06\"&&e.substr(d[d.length-1],2)==\"04\"){var o=p.oidname(j(e,d[0]));var r=JSON.parse(JSON.stringify(c));r.x509ExtName=o;f=r}for(var u=0;u<d.length;u++){k=k+y(e,f,d[u],g+\"  \")}return k}if(e.substr(l,2)==\"31\"){var k=g+\"SET\\n\";var d=w(e,l);for(var u=0;u<d.length;u++){k=k+y(e,c,d[u],g+\"  \")}return k}var z=parseInt(e.substr(l,2),16);if((z&128)!=0){var n=z&31;if((z&32)!=0){var k=g+\"[\"+n+\"]\\n\";var d=w(e,l);for(var u=0;u<d.length;u++){k=k+y(e,c,d[u],g+\"  \")}return k}else{var h=j(e,l);if(h.substr(0,8)==\"68747470\"){h=hextoutf8(h)}if(c.x509ExtName===\"subjectAltName\"&&n==2){h=hextoutf8(h)}var k=g+\"[\"+n+\"] \"+h+\"\\n\";return k}}return g+\"UNKNOWN(\"+e.substr(l,2)+\") \"+j(e,l)+\"\\n\"};ASN1HEX.isASN1HEX=function(e){var d=ASN1HEX;if(e.length%2==1){return false}var c=d.getVblen(e,0);var b=e.substr(0,2);var f=d.getL(e,0);var a=e.length-b.length-f.length;if(a==c*2){return true}return false};ASN1HEX.oidname=function(a){var c=KJUR.asn1;if(KJUR.lang.String.isHex(a)){a=c.ASN1Util.oidHexToInt(a)}var b=c.x509.OID.oid2name(a);if(b===\"\"){b=a}return b};\nvar KJUR;if(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.lang==\"undefined\"||!KJUR.lang){KJUR.lang={}}KJUR.lang.String=function(){};function Base64x(){}function stoBA(d){var b=new Array();for(var c=0;c<d.length;c++){b[c]=d.charCodeAt(c)}return b}function BAtos(b){var d=\"\";for(var c=0;c<b.length;c++){d=d+String.fromCharCode(b[c])}return d}function BAtohex(b){var e=\"\";for(var d=0;d<b.length;d++){var c=b[d].toString(16);if(c.length==1){c=\"0\"+c}e=e+c}return e}function stohex(a){return BAtohex(stoBA(a))}function stob64(a){return hex2b64(stohex(a))}function stob64u(a){return b64tob64u(hex2b64(stohex(a)))}function b64utos(a){return BAtos(b64toBA(b64utob64(a)))}function b64tob64u(a){a=a.replace(/\\=/g,\"\");a=a.replace(/\\+/g,\"-\");a=a.replace(/\\//g,\"_\");return a}function b64utob64(a){if(a.length%4==2){a=a+\"==\"}else{if(a.length%4==3){a=a+\"=\"}}a=a.replace(/-/g,\"+\");a=a.replace(/_/g,\"/\");return a}function hextob64u(a){if(a.length%2==1){a=\"0\"+a}return b64tob64u(hex2b64(a))}function b64utohex(a){return b64tohex(b64utob64(a))}var utf8tob64u,b64utoutf8;if(typeof Buffer===\"function\"){utf8tob64u=function(a){return b64tob64u(new Buffer(a,\"utf8\").toString(\"base64\"))};b64utoutf8=function(a){return new Buffer(b64utob64(a),\"base64\").toString(\"utf8\")}}else{utf8tob64u=function(a){return hextob64u(uricmptohex(encodeURIComponentAll(a)))};b64utoutf8=function(a){return decodeURIComponent(hextouricmp(b64utohex(a)))}}function utf8tob64(a){return hex2b64(uricmptohex(encodeURIComponentAll(a)))}function b64toutf8(a){return decodeURIComponent(hextouricmp(b64tohex(a)))}function utf8tohex(a){return uricmptohex(encodeURIComponentAll(a))}function hextoutf8(a){return decodeURIComponent(hextouricmp(a))}function hextorstr(c){var b=\"\";for(var a=0;a<c.length-1;a+=2){b+=String.fromCharCode(parseInt(c.substr(a,2),16))}return b}function rstrtohex(c){var a=\"\";for(var b=0;b<c.length;b++){a+=(\"0\"+c.charCodeAt(b).toString(16)).slice(-2)}return a}function hextob64(a){return hex2b64(a)}function hextob64nl(b){var a=hextob64(b);var c=a.replace(/(.{64})/g,\"$1\\r\\n\");c=c.replace(/\\r\\n$/,\"\");return c}function b64nltohex(b){var a=b.replace(/[^0-9A-Za-z\\/+=]*/g,\"\");var c=b64tohex(a);return c}function hextopem(a,b){var c=hextob64nl(a);return\"-----BEGIN \"+b+\"-----\\r\\n\"+c+\"\\r\\n-----END \"+b+\"-----\\r\\n\"}function pemtohex(a,b){if(a.indexOf(\"-----BEGIN \")==-1){throw\"can't find PEM header: \"+b}if(b!==undefined){a=a.replace(\"-----BEGIN \"+b+\"-----\",\"\");a=a.replace(\"-----END \"+b+\"-----\",\"\")}else{a=a.replace(/-----BEGIN [^-]+-----/,\"\");a=a.replace(/-----END [^-]+-----/,\"\")}return b64nltohex(a)}function hextoArrayBuffer(d){if(d.length%2!=0){throw\"input is not even length\"}if(d.match(/^[0-9A-Fa-f]+$/)==null){throw\"input is not hexadecimal\"}var b=new ArrayBuffer(d.length/2);var a=new DataView(b);for(var c=0;c<d.length/2;c++){a.setUint8(c,parseInt(d.substr(c*2,2),16))}return b}function ArrayBuffertohex(b){var d=\"\";var a=new DataView(b);for(var c=0;c<b.byteLength;c++){d+=(\"00\"+a.getUint8(c).toString(16)).slice(-2)}return d}function zulutomsec(n){var l,j,m,e,f,i,b,k;var a,h,g,c;c=n.match(/^(\\d{2}|\\d{4})(\\d\\d)(\\d\\d)(\\d\\d)(\\d\\d)(\\d\\d)(|\\.\\d+)Z$/);if(c){a=c[1];l=parseInt(a);if(a.length===2){if(50<=l&&l<100){l=1900+l}else{if(0<=l&&l<50){l=2000+l}}}j=parseInt(c[2])-1;m=parseInt(c[3]);e=parseInt(c[4]);f=parseInt(c[5]);i=parseInt(c[6]);b=0;h=c[7];if(h!==\"\"){g=(h.substr(1)+\"00\").substr(0,3);b=parseInt(g)}return Date.UTC(l,j,m,e,f,i,b)}throw\"unsupported zulu format: \"+n}function zulutosec(a){var b=zulutomsec(a);return ~~(b/1000)}function zulutodate(a){return new Date(zulutomsec(a))}function datetozulu(g,e,f){var b;var a=g.getUTCFullYear();if(e){if(a<1950||2049<a){throw\"not proper year for UTCTime: \"+a}b=(\"\"+a).slice(-2)}else{b=(\"000\"+a).slice(-4)}b+=(\"0\"+(g.getUTCMonth()+1)).slice(-2);b+=(\"0\"+g.getUTCDate()).slice(-2);b+=(\"0\"+g.getUTCHours()).slice(-2);b+=(\"0\"+g.getUTCMinutes()).slice(-2);b+=(\"0\"+g.getUTCSeconds()).slice(-2);if(f){var c=g.getUTCMilliseconds();if(c!==0){c=(\"00\"+c).slice(-3);c=c.replace(/0+$/g,\"\");b+=\".\"+c}}b+=\"Z\";return b}function uricmptohex(a){return a.replace(/%/g,\"\")}function hextouricmp(a){return a.replace(/(..)/g,\"%$1\")}function ipv6tohex(g){var b=\"malformed IPv6 address\";if(!g.match(/^[0-9A-Fa-f:]+$/)){throw b}g=g.toLowerCase();var d=g.split(\":\").length-1;if(d<2){throw b}var e=\":\".repeat(7-d+2);g=g.replace(\"::\",e);var c=g.split(\":\");if(c.length!=8){throw b}for(var f=0;f<8;f++){c[f]=(\"0000\"+c[f]).slice(-4)}return c.join(\"\")}function hextoipv6(e){if(!e.match(/^[0-9A-Fa-f]{32}$/)){throw\"malformed IPv6 address octet\"}e=e.toLowerCase();var b=e.match(/.{1,4}/g);for(var d=0;d<8;d++){b[d]=b[d].replace(/^0+/,\"\");if(b[d]==\"\"){b[d]=\"0\"}}e=\":\"+b.join(\":\")+\":\";var c=e.match(/:(0:){2,}/g);if(c===null){return e.slice(1,-1)}var f=\"\";for(var d=0;d<c.length;d++){if(c[d].length>f.length){f=c[d]}}e=e.replace(f,\"::\");return e.slice(1,-1)}function hextoip(b){var d=\"malformed hex value\";if(!b.match(/^([0-9A-Fa-f][0-9A-Fa-f]){1,}$/)){throw d}if(b.length==8){var c;try{c=parseInt(b.substr(0,2),16)+\".\"+parseInt(b.substr(2,2),16)+\".\"+parseInt(b.substr(4,2),16)+\".\"+parseInt(b.substr(6,2),16);return c}catch(a){throw d}}else{if(b.length==32){return hextoipv6(b)}else{return b}}}function iptohex(f){var j=\"malformed IP address\";f=f.toLowerCase(f);if(f.match(/^[0-9.]+$/)){var b=f.split(\".\");if(b.length!==4){throw j}var g=\"\";try{for(var e=0;e<4;e++){var h=parseInt(b[e]);g+=(\"0\"+h.toString(16)).slice(-2)}return g}catch(c){throw j}}else{if(f.match(/^[0-9a-f:]+$/)&&f.indexOf(\":\")!==-1){return ipv6tohex(f)}else{throw j}}}function encodeURIComponentAll(a){var d=encodeURIComponent(a);var b=\"\";for(var c=0;c<d.length;c++){if(d[c]==\"%\"){b=b+d.substr(c,3);c=c+2}else{b=b+\"%\"+stohex(d[c])}}return b}function newline_toUnix(a){a=a.replace(/\\r\\n/mg,\"\\n\");return a}function newline_toDos(a){a=a.replace(/\\r\\n/mg,\"\\n\");a=a.replace(/\\n/mg,\"\\r\\n\");return a}KJUR.lang.String.isInteger=function(a){if(a.match(/^[0-9]+$/)){return true}else{if(a.match(/^-[0-9]+$/)){return true}else{return false}}};KJUR.lang.String.isHex=function(a){if(a.length%2==0&&(a.match(/^[0-9a-f]+$/)||a.match(/^[0-9A-F]+$/))){return true}else{return false}};KJUR.lang.String.isBase64=function(a){a=a.replace(/\\s+/g,\"\");if(a.match(/^[0-9A-Za-z+\\/]+={0,3}$/)&&a.length%4==0){return true}else{return false}};KJUR.lang.String.isBase64URL=function(a){if(a.match(/[+/=]/)){return false}a=b64utob64(a);return KJUR.lang.String.isBase64(a)};KJUR.lang.String.isIntegerArray=function(a){a=a.replace(/\\s+/g,\"\");if(a.match(/^\\[[0-9,]+\\]$/)){return true}else{return false}};function hextoposhex(a){if(a.length%2==1){return\"0\"+a}if(a.substr(0,1)>\"7\"){return\"00\"+a}return a}function intarystrtohex(b){b=b.replace(/^\\s*\\[\\s*/,\"\");b=b.replace(/\\s*\\]\\s*$/,\"\");b=b.replace(/\\s*/g,\"\");try{var c=b.split(/,/).map(function(g,e,h){var f=parseInt(g);if(f<0||255<f){throw\"integer not in range 0-255\"}var d=(\"00\"+f.toString(16)).slice(-2);return d}).join(\"\");return c}catch(a){throw\"malformed integer array string: \"+a}}var strdiffidx=function(c,a){var d=c.length;if(c.length>a.length){d=a.length}for(var b=0;b<d;b++){if(c.charCodeAt(b)!=a.charCodeAt(b)){return b}}if(c.length!=a.length){return d}return -1};\nif(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.crypto==\"undefined\"||!KJUR.crypto){KJUR.crypto={}}KJUR.crypto.Util=new function(){this.DIGESTINFOHEAD={sha1:\"3021300906052b0e03021a05000414\",sha224:\"302d300d06096086480165030402040500041c\",sha256:\"3031300d060960864801650304020105000420\",sha384:\"3041300d060960864801650304020205000430\",sha512:\"3051300d060960864801650304020305000440\",md2:\"3020300c06082a864886f70d020205000410\",md5:\"3020300c06082a864886f70d020505000410\",ripemd160:\"3021300906052b2403020105000414\",};this.DEFAULTPROVIDER={md5:\"cryptojs\",sha1:\"cryptojs\",sha224:\"cryptojs\",sha256:\"cryptojs\",sha384:\"cryptojs\",sha512:\"cryptojs\",ripemd160:\"cryptojs\",hmacmd5:\"cryptojs\",hmacsha1:\"cryptojs\",hmacsha224:\"cryptojs\",hmacsha256:\"cryptojs\",hmacsha384:\"cryptojs\",hmacsha512:\"cryptojs\",hmacripemd160:\"cryptojs\",MD5withRSA:\"cryptojs/jsrsa\",SHA1withRSA:\"cryptojs/jsrsa\",SHA224withRSA:\"cryptojs/jsrsa\",SHA256withRSA:\"cryptojs/jsrsa\",SHA384withRSA:\"cryptojs/jsrsa\",SHA512withRSA:\"cryptojs/jsrsa\",RIPEMD160withRSA:\"cryptojs/jsrsa\",MD5withECDSA:\"cryptojs/jsrsa\",SHA1withECDSA:\"cryptojs/jsrsa\",SHA224withECDSA:\"cryptojs/jsrsa\",SHA256withECDSA:\"cryptojs/jsrsa\",SHA384withECDSA:\"cryptojs/jsrsa\",SHA512withECDSA:\"cryptojs/jsrsa\",RIPEMD160withECDSA:\"cryptojs/jsrsa\",SHA1withDSA:\"cryptojs/jsrsa\",SHA224withDSA:\"cryptojs/jsrsa\",SHA256withDSA:\"cryptojs/jsrsa\",MD5withRSAandMGF1:\"cryptojs/jsrsa\",SHA1withRSAandMGF1:\"cryptojs/jsrsa\",SHA224withRSAandMGF1:\"cryptojs/jsrsa\",SHA256withRSAandMGF1:\"cryptojs/jsrsa\",SHA384withRSAandMGF1:\"cryptojs/jsrsa\",SHA512withRSAandMGF1:\"cryptojs/jsrsa\",RIPEMD160withRSAandMGF1:\"cryptojs/jsrsa\",};this.CRYPTOJSMESSAGEDIGESTNAME={md5:CryptoJS.algo.MD5,sha1:CryptoJS.algo.SHA1,sha224:CryptoJS.algo.SHA224,sha256:CryptoJS.algo.SHA256,sha384:CryptoJS.algo.SHA384,sha512:CryptoJS.algo.SHA512,ripemd160:CryptoJS.algo.RIPEMD160};this.getDigestInfoHex=function(a,b){if(typeof this.DIGESTINFOHEAD[b]==\"undefined\"){throw\"alg not supported in Util.DIGESTINFOHEAD: \"+b}return this.DIGESTINFOHEAD[b]+a};this.getPaddedDigestInfoHex=function(h,a,j){var c=this.getDigestInfoHex(h,a);var d=j/4;if(c.length+22>d){throw\"key is too short for SigAlg: keylen=\"+j+\",\"+a}var b=\"0001\";var k=\"00\"+c;var g=\"\";var l=d-b.length-k.length;for(var f=0;f<l;f+=2){g+=\"ff\"}var e=b+g+k;return e};this.hashString=function(a,c){var b=new KJUR.crypto.MessageDigest({alg:c});return b.digestString(a)};this.hashHex=function(b,c){var a=new KJUR.crypto.MessageDigest({alg:c});return a.digestHex(b)};this.sha1=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"sha1\",prov:\"cryptojs\"});return b.digestString(a)};this.sha256=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"sha256\",prov:\"cryptojs\"});return b.digestString(a)};this.sha256Hex=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"sha256\",prov:\"cryptojs\"});return b.digestHex(a)};this.sha512=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"sha512\",prov:\"cryptojs\"});return b.digestString(a)};this.sha512Hex=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"sha512\",prov:\"cryptojs\"});return b.digestHex(a)}};KJUR.crypto.Util.md5=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"md5\",prov:\"cryptojs\"});return b.digestString(a)};KJUR.crypto.Util.ripemd160=function(a){var b=new KJUR.crypto.MessageDigest({alg:\"ripemd160\",prov:\"cryptojs\"});return b.digestString(a)};KJUR.crypto.Util.SECURERANDOMGEN=new SecureRandom();KJUR.crypto.Util.getRandomHexOfNbytes=function(b){var a=new Array(b);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(a);return BAtohex(a)};KJUR.crypto.Util.getRandomBigIntegerOfNbytes=function(a){return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbytes(a),16)};KJUR.crypto.Util.getRandomHexOfNbits=function(d){var c=d%8;var a=(d-c)/8;var b=new Array(a+1);KJUR.crypto.Util.SECURERANDOMGEN.nextBytes(b);b[0]=(((255<<c)&255)^255)&b[0];return BAtohex(b)};KJUR.crypto.Util.getRandomBigIntegerOfNbits=function(a){return new BigInteger(KJUR.crypto.Util.getRandomHexOfNbits(a),16)};KJUR.crypto.Util.getRandomBigIntegerZeroToMax=function(b){var a=b.bitLength();while(1){var c=KJUR.crypto.Util.getRandomBigIntegerOfNbits(a);if(b.compareTo(c)!=-1){return c}}};KJUR.crypto.Util.getRandomBigIntegerMinToMax=function(e,b){var c=e.compareTo(b);if(c==1){throw\"biMin is greater than biMax\"}if(c==0){return e}var a=b.subtract(e);var d=KJUR.crypto.Util.getRandomBigIntegerZeroToMax(a);return d.add(e)};KJUR.crypto.MessageDigest=function(c){var b=null;var a=null;var d=null;this.setAlgAndProvider=function(g,f){g=KJUR.crypto.MessageDigest.getCanonicalAlgName(g);if(g!==null&&f===undefined){f=KJUR.crypto.Util.DEFAULTPROVIDER[g]}if(\":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:\".indexOf(g)!=-1&&f==\"cryptojs\"){try{this.md=KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g].create()}catch(e){throw\"setAlgAndProvider hash alg set fail alg=\"+g+\"/\"+e}this.updateString=function(h){this.md.update(h)};this.updateHex=function(h){var i=CryptoJS.enc.Hex.parse(h);this.md.update(i)};this.digest=function(){var h=this.md.finalize();return h.toString(CryptoJS.enc.Hex)};this.digestString=function(h){this.updateString(h);return this.digest()};this.digestHex=function(h){this.updateHex(h);return this.digest()}}if(\":sha256:\".indexOf(g)!=-1&&f==\"sjcl\"){try{this.md=new sjcl.hash.sha256()}catch(e){throw\"setAlgAndProvider hash alg set fail alg=\"+g+\"/\"+e}this.updateString=function(h){this.md.update(h)};this.updateHex=function(i){var h=sjcl.codec.hex.toBits(i);this.md.update(h)};this.digest=function(){var h=this.md.finalize();return sjcl.codec.hex.fromBits(h)};this.digestString=function(h){this.updateString(h);return this.digest()};this.digestHex=function(h){this.updateHex(h);return this.digest()}}};this.updateString=function(e){throw\"updateString(str) not supported for this alg/prov: \"+this.algName+\"/\"+this.provName};this.updateHex=function(e){throw\"updateHex(hex) not supported for this alg/prov: \"+this.algName+\"/\"+this.provName};this.digest=function(){throw\"digest() not supported for this alg/prov: \"+this.algName+\"/\"+this.provName};this.digestString=function(e){throw\"digestString(str) not supported for this alg/prov: \"+this.algName+\"/\"+this.provName};this.digestHex=function(e){throw\"digestHex(hex) not supported for this alg/prov: \"+this.algName+\"/\"+this.provName};if(c!==undefined){if(c.alg!==undefined){this.algName=c.alg;if(c.prov===undefined){this.provName=KJUR.crypto.Util.DEFAULTPROVIDER[this.algName]}this.setAlgAndProvider(this.algName,this.provName)}}};KJUR.crypto.MessageDigest.getCanonicalAlgName=function(a){if(typeof a===\"string\"){a=a.toLowerCase();a=a.replace(/-/,\"\")}return a};KJUR.crypto.MessageDigest.getHashLength=function(c){var b=KJUR.crypto.MessageDigest;var a=b.getCanonicalAlgName(c);if(b.HASHLENGTH[a]===undefined){throw\"not supported algorithm: \"+c}return b.HASHLENGTH[a]};KJUR.crypto.MessageDigest.HASHLENGTH={md5:16,sha1:20,sha224:28,sha256:32,sha384:48,sha512:64,ripemd160:20};KJUR.crypto.Mac=function(d){var f=null;var c=null;var a=null;var e=null;var b=null;this.setAlgAndProvider=function(k,i){k=k.toLowerCase();if(k==null){k=\"hmacsha1\"}k=k.toLowerCase();if(k.substr(0,4)!=\"hmac\"){throw\"setAlgAndProvider unsupported HMAC alg: \"+k}if(i===undefined){i=KJUR.crypto.Util.DEFAULTPROVIDER[k]}this.algProv=k+\"/\"+i;var g=k.substr(4);if(\":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:\".indexOf(g)!=-1&&i==\"cryptojs\"){try{var j=KJUR.crypto.Util.CRYPTOJSMESSAGEDIGESTNAME[g];this.mac=CryptoJS.algo.HMAC.create(j,this.pass)}catch(h){throw\"setAlgAndProvider hash alg set fail hashAlg=\"+g+\"/\"+h}this.updateString=function(l){this.mac.update(l)};this.updateHex=function(l){var m=CryptoJS.enc.Hex.parse(l);this.mac.update(m)};this.doFinal=function(){var l=this.mac.finalize();return l.toString(CryptoJS.enc.Hex)};this.doFinalString=function(l){this.updateString(l);return this.doFinal()};this.doFinalHex=function(l){this.updateHex(l);return this.doFinal()}}};this.updateString=function(g){throw\"updateString(str) not supported for this alg/prov: \"+this.algProv};this.updateHex=function(g){throw\"updateHex(hex) not supported for this alg/prov: \"+this.algProv};this.doFinal=function(){throw\"digest() not supported for this alg/prov: \"+this.algProv};this.doFinalString=function(g){throw\"digestString(str) not supported for this alg/prov: \"+this.algProv};this.doFinalHex=function(g){throw\"digestHex(hex) not supported for this alg/prov: \"+this.algProv};this.setPassword=function(h){if(typeof h==\"string\"){var g=h;if(h.length%2==1||!h.match(/^[0-9A-Fa-f]+$/)){g=rstrtohex(h)}this.pass=CryptoJS.enc.Hex.parse(g);return}if(typeof h!=\"object\"){throw\"KJUR.crypto.Mac unsupported password type: \"+h}var g=null;if(h.hex!==undefined){if(h.hex.length%2!=0||!h.hex.match(/^[0-9A-Fa-f]+$/)){throw\"Mac: wrong hex password: \"+h.hex}g=h.hex}if(h.utf8!==undefined){g=utf8tohex(h.utf8)}if(h.rstr!==undefined){g=rstrtohex(h.rstr)}if(h.b64!==undefined){g=b64tohex(h.b64)}if(h.b64u!==undefined){g=b64utohex(h.b64u)}if(g==null){throw\"KJUR.crypto.Mac unsupported password type: \"+h}this.pass=CryptoJS.enc.Hex.parse(g)};if(d!==undefined){if(d.pass!==undefined){this.setPassword(d.pass)}if(d.alg!==undefined){this.algName=d.alg;if(d.prov===undefined){this.provName=KJUR.crypto.Util.DEFAULTPROVIDER[this.algName]}this.setAlgAndProvider(this.algName,this.provName)}}};KJUR.crypto.Signature=function(o){var q=null;var n=null;var r=null;var c=null;var l=null;var d=null;var k=null;var h=null;var p=null;var e=null;var b=-1;var g=null;var j=null;var a=null;var i=null;var f=null;this._setAlgNames=function(){var s=this.algName.match(/^(.+)with(.+)$/);if(s){this.mdAlgName=s[1].toLowerCase();this.pubkeyAlgName=s[2].toLowerCase()}};this._zeroPaddingOfSignature=function(x,w){var v=\"\";var t=w/4-x.length;for(var u=0;u<t;u++){v=v+\"0\"}return v+x};this.setAlgAndProvider=function(u,t){this._setAlgNames();if(t!=\"cryptojs/jsrsa\"){throw\"provider not supported: \"+t}if(\":md5:sha1:sha224:sha256:sha384:sha512:ripemd160:\".indexOf(this.mdAlgName)!=-1){try{this.md=new KJUR.crypto.MessageDigest({alg:this.mdAlgName})}catch(s){throw\"setAlgAndProvider hash alg set fail alg=\"+this.mdAlgName+\"/\"+s}this.init=function(w,x){var y=null;try{if(x===undefined){y=KEYUTIL.getKey(w)}else{y=KEYUTIL.getKey(w,x)}}catch(v){throw\"init failed:\"+v}if(y.isPrivate===true){this.prvKey=y;this.state=\"SIGN\"}else{if(y.isPublic===true){this.pubKey=y;this.state=\"VERIFY\"}else{throw\"init failed.:\"+y}}};this.updateString=function(v){this.md.updateString(v)};this.updateHex=function(v){this.md.updateHex(v)};this.sign=function(){this.sHashHex=this.md.digest();if(typeof this.ecprvhex!=\"undefined\"&&typeof this.eccurvename!=\"undefined\"){var v=new KJUR.crypto.ECDSA({curve:this.eccurvename});this.hSign=v.signHex(this.sHashHex,this.ecprvhex)}else{if(this.prvKey instanceof RSAKey&&this.pubkeyAlgName===\"rsaandmgf1\"){this.hSign=this.prvKey.signWithMessageHashPSS(this.sHashHex,this.mdAlgName,this.pssSaltLen)}else{if(this.prvKey instanceof RSAKey&&this.pubkeyAlgName===\"rsa\"){this.hSign=this.prvKey.signWithMessageHash(this.sHashHex,this.mdAlgName)}else{if(this.prvKey instanceof KJUR.crypto.ECDSA){this.hSign=this.prvKey.signWithMessageHash(this.sHashHex)}else{if(this.prvKey instanceof KJUR.crypto.DSA){this.hSign=this.prvKey.signWithMessageHash(this.sHashHex)}else{throw\"Signature: unsupported private key alg: \"+this.pubkeyAlgName}}}}}return this.hSign};this.signString=function(v){this.updateString(v);return this.sign()};this.signHex=function(v){this.updateHex(v);return this.sign()};this.verify=function(v){this.sHashHex=this.md.digest();if(typeof this.ecpubhex!=\"undefined\"&&typeof this.eccurvename!=\"undefined\"){var w=new KJUR.crypto.ECDSA({curve:this.eccurvename});return w.verifyHex(this.sHashHex,v,this.ecpubhex)}else{if(this.pubKey instanceof RSAKey&&this.pubkeyAlgName===\"rsaandmgf1\"){return this.pubKey.verifyWithMessageHashPSS(this.sHashHex,v,this.mdAlgName,this.pssSaltLen)}else{if(this.pubKey instanceof RSAKey&&this.pubkeyAlgName===\"rsa\"){return this.pubKey.verifyWithMessageHash(this.sHashHex,v)}else{if(KJUR.crypto.ECDSA!==undefined&&this.pubKey instanceof KJUR.crypto.ECDSA){return this.pubKey.verifyWithMessageHash(this.sHashHex,v)}else{if(KJUR.crypto.DSA!==undefined&&this.pubKey instanceof KJUR.crypto.DSA){return this.pubKey.verifyWithMessageHash(this.sHashHex,v)}else{throw\"Signature: unsupported public key alg: \"+this.pubkeyAlgName}}}}}}}};this.init=function(s,t){throw\"init(key, pass) not supported for this alg:prov=\"+this.algProvName};this.updateString=function(s){throw\"updateString(str) not supported for this alg:prov=\"+this.algProvName};this.updateHex=function(s){throw\"updateHex(hex) not supported for this alg:prov=\"+this.algProvName};this.sign=function(){throw\"sign() not supported for this alg:prov=\"+this.algProvName};this.signString=function(s){throw\"digestString(str) not supported for this alg:prov=\"+this.algProvName};this.signHex=function(s){throw\"digestHex(hex) not supported for this alg:prov=\"+this.algProvName};this.verify=function(s){throw\"verify(hSigVal) not supported for this alg:prov=\"+this.algProvName};this.initParams=o;if(o!==undefined){if(o.alg!==undefined){this.algName=o.alg;if(o.prov===undefined){this.provName=KJUR.crypto.Util.DEFAULTPROVIDER[this.algName]}else{this.provName=o.prov}this.algProvName=this.algName+\":\"+this.provName;this.setAlgAndProvider(this.algName,this.provName);this._setAlgNames()}if(o.psssaltlen!==undefined){this.pssSaltLen=o.psssaltlen}if(o.prvkeypem!==undefined){if(o.prvkeypas!==undefined){throw\"both prvkeypem and prvkeypas parameters not supported\"}else{try{var q=KEYUTIL.getKey(o.prvkeypem);this.init(q)}catch(m){throw\"fatal error to load pem private key: \"+m}}}}};KJUR.crypto.Cipher=function(a){};KJUR.crypto.Cipher.encrypt=function(e,f,d){if(f instanceof RSAKey&&f.isPublic){var c=KJUR.crypto.Cipher.getAlgByKeyAndName(f,d);if(c===\"RSA\"){return f.encrypt(e)}if(c===\"RSAOAEP\"){return f.encryptOAEP(e,\"sha1\")}var b=c.match(/^RSAOAEP(\\d+)$/);if(b!==null){return f.encryptOAEP(e,\"sha\"+b[1])}throw\"Cipher.encrypt: unsupported algorithm for RSAKey: \"+d}else{throw\"Cipher.encrypt: unsupported key or algorithm\"}};KJUR.crypto.Cipher.decrypt=function(e,f,d){if(f instanceof RSAKey&&f.isPrivate){var c=KJUR.crypto.Cipher.getAlgByKeyAndName(f,d);if(c===\"RSA\"){return f.decrypt(e)}if(c===\"RSAOAEP\"){return f.decryptOAEP(e,\"sha1\")}var b=c.match(/^RSAOAEP(\\d+)$/);if(b!==null){return f.decryptOAEP(e,\"sha\"+b[1])}throw\"Cipher.decrypt: unsupported algorithm for RSAKey: \"+d}else{throw\"Cipher.decrypt: unsupported key or algorithm\"}};KJUR.crypto.Cipher.getAlgByKeyAndName=function(b,a){if(b instanceof RSAKey){if(\":RSA:RSAOAEP:RSAOAEP224:RSAOAEP256:RSAOAEP384:RSAOAEP512:\".indexOf(a)!=-1){return a}if(a===null||a===undefined){return\"RSA\"}throw\"getAlgByKeyAndName: not supported algorithm name for RSAKey: \"+a}throw\"getAlgByKeyAndName: not supported algorithm name: \"+a};KJUR.crypto.OID=new function(){this.oidhex2name={\"2a864886f70d010101\":\"rsaEncryption\",\"2a8648ce3d0201\":\"ecPublicKey\",\"2a8648ce380401\":\"dsa\",\"2a8648ce3d030107\":\"secp256r1\",\"2b8104001f\":\"secp192k1\",\"2b81040021\":\"secp224r1\",\"2b8104000a\":\"secp256k1\",\"2b81040023\":\"secp521r1\",\"2b81040022\":\"secp384r1\",\"2a8648ce380403\":\"SHA1withDSA\",\"608648016503040301\":\"SHA224withDSA\",\"608648016503040302\":\"SHA256withDSA\",}};\nif(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.crypto==\"undefined\"||!KJUR.crypto){KJUR.crypto={}}KJUR.crypto.ECDSA=function(h){var e=\"secp256r1\";var g=null;var b=null;var f=null;var a=new SecureRandom();var d=null;this.type=\"EC\";this.isPrivate=false;this.isPublic=false;function c(s,o,r,n){var j=Math.max(o.bitLength(),n.bitLength());var t=s.add2D(r);var q=s.curve.getInfinity();for(var p=j-1;p>=0;--p){q=q.twice2D();q.z=BigInteger.ONE;if(o.testBit(p)){if(n.testBit(p)){q=q.add2D(t)}else{q=q.add2D(s)}}else{if(n.testBit(p)){q=q.add2D(r)}}}return q}this.getBigRandom=function(i){return new BigInteger(i.bitLength(),a).mod(i.subtract(BigInteger.ONE)).add(BigInteger.ONE)};this.setNamedCurve=function(i){this.ecparams=KJUR.crypto.ECParameterDB.getByName(i);this.prvKeyHex=null;this.pubKeyHex=null;this.curveName=i};this.setPrivateKeyHex=function(i){this.isPrivate=true;this.prvKeyHex=i};this.setPublicKeyHex=function(i){this.isPublic=true;this.pubKeyHex=i};this.getPublicKeyXYHex=function(){var k=this.pubKeyHex;if(k.substr(0,2)!==\"04\"){throw\"this method supports uncompressed format(04) only\"}var j=this.ecparams.keylen/4;if(k.length!==2+j*2){throw\"malformed public key hex length\"}var i={};i.x=k.substr(2,j);i.y=k.substr(2+j);return i};this.getShortNISTPCurveName=function(){var i=this.curveName;if(i===\"secp256r1\"||i===\"NIST P-256\"||i===\"P-256\"||i===\"prime256v1\"){return\"P-256\"}if(i===\"secp384r1\"||i===\"NIST P-384\"||i===\"P-384\"){return\"P-384\"}return null};this.generateKeyPairHex=function(){var k=this.ecparams.n;var n=this.getBigRandom(k);var l=this.ecparams.G.multiply(n);var q=l.getX().toBigInteger();var o=l.getY().toBigInteger();var i=this.ecparams.keylen/4;var m=(\"0000000000\"+n.toString(16)).slice(-i);var r=(\"0000000000\"+q.toString(16)).slice(-i);var p=(\"0000000000\"+o.toString(16)).slice(-i);var j=\"04\"+r+p;this.setPrivateKeyHex(m);this.setPublicKeyHex(j);return{ecprvhex:m,ecpubhex:j}};this.signWithMessageHash=function(i){return this.signHex(i,this.prvKeyHex)};this.signHex=function(o,j){var t=new BigInteger(j,16);var l=this.ecparams.n;var q=new BigInteger(o,16);do{var m=this.getBigRandom(l);var u=this.ecparams.G;var p=u.multiply(m);var i=p.getX().toBigInteger().mod(l)}while(i.compareTo(BigInteger.ZERO)<=0);var v=m.modInverse(l).multiply(q.add(t.multiply(i))).mod(l);return KJUR.crypto.ECDSA.biRSSigToASN1Sig(i,v)};this.sign=function(m,u){var q=u;var j=this.ecparams.n;var p=BigInteger.fromByteArrayUnsigned(m);do{var l=this.getBigRandom(j);var t=this.ecparams.G;var o=t.multiply(l);var i=o.getX().toBigInteger().mod(j)}while(i.compareTo(BigInteger.ZERO)<=0);var v=l.modInverse(j).multiply(p.add(q.multiply(i))).mod(j);return this.serializeSig(i,v)};this.verifyWithMessageHash=function(j,i){return this.verifyHex(j,i,this.pubKeyHex)};this.verifyHex=function(m,i,p){var l,j;var o=KJUR.crypto.ECDSA.parseSigHex(i);l=o.r;j=o.s;var k;k=ECPointFp.decodeFromHex(this.ecparams.curve,p);var n=new BigInteger(m,16);return this.verifyRaw(n,l,j,k)};this.verify=function(o,p,j){var l,i;if(Bitcoin.Util.isArray(p)){var n=this.parseSig(p);l=n.r;i=n.s}else{if(\"object\"===typeof p&&p.r&&p.s){l=p.r;i=p.s}else{throw\"Invalid value for signature\"}}var k;if(j instanceof ECPointFp){k=j}else{if(Bitcoin.Util.isArray(j)){k=ECPointFp.decodeFrom(this.ecparams.curve,j)}else{throw\"Invalid format for pubkey value, must be byte array or ECPointFp\"}}var m=BigInteger.fromByteArrayUnsigned(o);return this.verifyRaw(m,l,i,k)};this.verifyRaw=function(o,i,w,m){var l=this.ecparams.n;var u=this.ecparams.G;if(i.compareTo(BigInteger.ONE)<0||i.compareTo(l)>=0){return false}if(w.compareTo(BigInteger.ONE)<0||w.compareTo(l)>=0){return false}var p=w.modInverse(l);var k=o.multiply(p).mod(l);var j=i.multiply(p).mod(l);var q=u.multiply(k).add(m.multiply(j));var t=q.getX().toBigInteger().mod(l);return t.equals(i)};this.serializeSig=function(k,j){var l=k.toByteArraySigned();var i=j.toByteArraySigned();var m=[];m.push(2);m.push(l.length);m=m.concat(l);m.push(2);m.push(i.length);m=m.concat(i);m.unshift(m.length);m.unshift(48);return m};this.parseSig=function(n){var m;if(n[0]!=48){throw new Error(\"Signature not a valid DERSequence\")}m=2;if(n[m]!=2){throw new Error(\"First element in signature must be a DERInteger\")}var l=n.slice(m+2,m+2+n[m+1]);m+=2+n[m+1];if(n[m]!=2){throw new Error(\"Second element in signature must be a DERInteger\")}var i=n.slice(m+2,m+2+n[m+1]);m+=2+n[m+1];var k=BigInteger.fromByteArrayUnsigned(l);var j=BigInteger.fromByteArrayUnsigned(i);return{r:k,s:j}};this.parseSigCompact=function(m){if(m.length!==65){throw\"Signature has the wrong length\"}var j=m[0]-27;if(j<0||j>7){throw\"Invalid signature type\"}var o=this.ecparams.n;var l=BigInteger.fromByteArrayUnsigned(m.slice(1,33)).mod(o);var k=BigInteger.fromByteArrayUnsigned(m.slice(33,65)).mod(o);return{r:l,s:k,i:j}};this.readPKCS5PrvKeyHex=function(l){var n=ASN1HEX;var m=KJUR.crypto.ECDSA.getName;var p=n.getVbyList;if(n.isASN1HEX(l)===false){throw\"not ASN.1 hex string\"}var i,k,o;try{i=p(l,0,[2,0],\"06\");k=p(l,0,[1],\"04\");try{o=p(l,0,[3,0],\"03\").substr(2)}catch(j){}}catch(j){throw\"malformed PKCS#1/5 plain ECC private key\"}this.curveName=m(i);if(this.curveName===undefined){throw\"unsupported curve name\"}this.setNamedCurve(this.curveName);this.setPublicKeyHex(o);this.setPrivateKeyHex(k);this.isPublic=false};this.readPKCS8PrvKeyHex=function(l){var q=ASN1HEX;var i=KJUR.crypto.ECDSA.getName;var n=q.getVbyList;if(q.isASN1HEX(l)===false){throw\"not ASN.1 hex string\"}var j,p,m,k;try{j=n(l,0,[1,0],\"06\");p=n(l,0,[1,1],\"06\");m=n(l,0,[2,0,1],\"04\");try{k=n(l,0,[2,0,2,0],\"03\").substr(2)}catch(o){}}catch(o){throw\"malformed PKCS#8 plain ECC private key\"}this.curveName=i(p);if(this.curveName===undefined){throw\"unsupported curve name\"}this.setNamedCurve(this.curveName);this.setPublicKeyHex(k);this.setPrivateKeyHex(m);this.isPublic=false};this.readPKCS8PubKeyHex=function(l){var n=ASN1HEX;var m=KJUR.crypto.ECDSA.getName;var p=n.getVbyList;if(n.isASN1HEX(l)===false){throw\"not ASN.1 hex string\"}var k,i,o;try{k=p(l,0,[0,0],\"06\");i=p(l,0,[0,1],\"06\");o=p(l,0,[1],\"03\").substr(2)}catch(j){throw\"malformed PKCS#8 ECC public key\"}this.curveName=m(i);if(this.curveName===null){throw\"unsupported curve name\"}this.setNamedCurve(this.curveName);this.setPublicKeyHex(o)};this.readCertPubKeyHex=function(k,p){if(p!==5){p=6}var m=ASN1HEX;var l=KJUR.crypto.ECDSA.getName;var o=m.getVbyList;if(m.isASN1HEX(k)===false){throw\"not ASN.1 hex string\"}var i,n;try{i=o(k,0,[0,p,0,1],\"06\");n=o(k,0,[0,p,1],\"03\").substr(2)}catch(j){throw\"malformed X.509 certificate ECC public key\"}this.curveName=l(i);if(this.curveName===null){throw\"unsupported curve name\"}this.setNamedCurve(this.curveName);this.setPublicKeyHex(n)};if(h!==undefined){if(h.curve!==undefined){this.curveName=h.curve}}if(this.curveName===undefined){this.curveName=e}this.setNamedCurve(this.curveName);if(h!==undefined){if(h.prv!==undefined){this.setPrivateKeyHex(h.prv)}if(h.pub!==undefined){this.setPublicKeyHex(h.pub)}}};KJUR.crypto.ECDSA.parseSigHex=function(a){var b=KJUR.crypto.ECDSA.parseSigHexInHexRS(a);var d=new BigInteger(b.r,16);var c=new BigInteger(b.s,16);return{r:d,s:c}};KJUR.crypto.ECDSA.parseSigHexInHexRS=function(f){var j=ASN1HEX;var i=j.getChildIdx;var g=j.getV;if(f.substr(0,2)!=\"30\"){throw\"signature is not a ASN.1 sequence\"}var h=i(f,0);if(h.length!=2){throw\"number of signature ASN.1 sequence elements seem wrong\"}var e=h[0];var d=h[1];if(f.substr(e,2)!=\"02\"){throw\"1st item of sequene of signature is not ASN.1 integer\"}if(f.substr(d,2)!=\"02\"){throw\"2nd item of sequene of signature is not ASN.1 integer\"}var c=g(f,e);var b=g(f,d);return{r:c,s:b}};KJUR.crypto.ECDSA.asn1SigToConcatSig=function(c){var d=KJUR.crypto.ECDSA.parseSigHexInHexRS(c);var b=d.r;var a=d.s;if(b.substr(0,2)==\"00\"&&(b.length%32)==2){b=b.substr(2)}if(a.substr(0,2)==\"00\"&&(a.length%32)==2){a=a.substr(2)}if((b.length%32)==30){b=\"00\"+b}if((a.length%32)==30){a=\"00\"+a}if(b.length%32!=0){throw\"unknown ECDSA sig r length error\"}if(a.length%32!=0){throw\"unknown ECDSA sig s length error\"}return b+a};KJUR.crypto.ECDSA.concatSigToASN1Sig=function(a){if((((a.length/2)*8)%(16*8))!=0){throw\"unknown ECDSA concatinated r-s sig  length error\"}var c=a.substr(0,a.length/2);var b=a.substr(a.length/2);return KJUR.crypto.ECDSA.hexRSSigToASN1Sig(c,b)};KJUR.crypto.ECDSA.hexRSSigToASN1Sig=function(b,a){var d=new BigInteger(b,16);var c=new BigInteger(a,16);return KJUR.crypto.ECDSA.biRSSigToASN1Sig(d,c)};KJUR.crypto.ECDSA.biRSSigToASN1Sig=function(f,d){var c=KJUR.asn1;var b=new c.DERInteger({bigint:f});var a=new c.DERInteger({bigint:d});var e=new c.DERSequence({array:[b,a]});return e.getEncodedHex()};KJUR.crypto.ECDSA.getName=function(a){if(a===\"2a8648ce3d030107\"){return\"secp256r1\"}if(a===\"2b8104000a\"){return\"secp256k1\"}if(a===\"2b81040022\"){return\"secp384r1\"}if(\"|secp256r1|NIST P-256|P-256|prime256v1|\".indexOf(a)!==-1){return\"secp256r1\"}if(\"|secp256k1|\".indexOf(a)!==-1){return\"secp256k1\"}if(\"|secp384r1|NIST P-384|P-384|\".indexOf(a)!==-1){return\"secp384r1\"}return null};\nif(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.crypto==\"undefined\"||!KJUR.crypto){KJUR.crypto={}}KJUR.crypto.ECParameterDB=new function(){var b={};var c={};function a(d){return new BigInteger(d,16)}this.getByName=function(e){var d=e;if(typeof c[d]!=\"undefined\"){d=c[e]}if(typeof b[d]!=\"undefined\"){return b[d]}throw\"unregistered EC curve name: \"+d};this.regist=function(A,l,o,g,m,e,j,f,k,u,d,x){b[A]={};var s=a(o);var z=a(g);var y=a(m);var t=a(e);var w=a(j);var r=new ECCurveFp(s,z,y);var q=r.decodePointHex(\"04\"+f+k);b[A][\"name\"]=A;b[A][\"keylen\"]=l;b[A][\"curve\"]=r;b[A][\"G\"]=q;b[A][\"n\"]=t;b[A][\"h\"]=w;b[A][\"oid\"]=d;b[A][\"info\"]=x;for(var v=0;v<u.length;v++){c[u[v]]=A}}};KJUR.crypto.ECParameterDB.regist(\"secp128r1\",128,\"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF\",\"FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC\",\"E87579C11079F43DD824993C2CEE5ED3\",\"FFFFFFFE0000000075A30D1B9038A115\",\"1\",\"161FF7528B899B2D0C28607CA52C5B86\",\"CF5AC8395BAFEB13C02DA292DDED7A83\",[],\"\",\"secp128r1 : SECG curve over a 128 bit prime field\");KJUR.crypto.ECParameterDB.regist(\"secp160k1\",160,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73\",\"0\",\"7\",\"0100000000000000000001B8FA16DFAB9ACA16B6B3\",\"1\",\"3B4C382CE37AA192A4019E763036F4F5DD4D7EBB\",\"938CF935318FDCED6BC28286531733C3F03C4FEE\",[],\"\",\"secp160k1 : SECG curve over a 160 bit prime field\");KJUR.crypto.ECParameterDB.regist(\"secp160r1\",160,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC\",\"1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45\",\"0100000000000000000001F4C8F927AED3CA752257\",\"1\",\"4A96B5688EF573284664698968C38BB913CBFC82\",\"23A628553168947D59DCC912042351377AC5FB32\",[],\"\",\"secp160r1 : SECG curve over a 160 bit prime field\");KJUR.crypto.ECParameterDB.regist(\"secp192k1\",192,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37\",\"0\",\"3\",\"FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D\",\"1\",\"DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D\",\"9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D\",[]);KJUR.crypto.ECParameterDB.regist(\"secp192r1\",192,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC\",\"64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1\",\"FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831\",\"1\",\"188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF1012\",\"07192B95FFC8DA78631011ED6B24CDD573F977A11E794811\",[]);KJUR.crypto.ECParameterDB.regist(\"secp224r1\",224,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE\",\"B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D\",\"1\",\"B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21\",\"BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34\",[]);KJUR.crypto.ECParameterDB.regist(\"secp256k1\",256,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F\",\"0\",\"7\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141\",\"1\",\"79BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798\",\"483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8\",[]);KJUR.crypto.ECParameterDB.regist(\"secp256r1\",256,\"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF\",\"FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC\",\"5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B\",\"FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551\",\"1\",\"6B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C296\",\"4FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5\",[\"NIST P-256\",\"P-256\",\"prime256v1\"]);KJUR.crypto.ECParameterDB.regist(\"secp384r1\",384,\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC\",\"B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF\",\"FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973\",\"1\",\"AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7\",\"3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f\",[\"NIST P-384\",\"P-384\"]);KJUR.crypto.ECParameterDB.regist(\"secp521r1\",521,\"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF\",\"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC\",\"051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00\",\"1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409\",\"1\",\"C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66\",\"011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650\",[\"NIST P-521\",\"P-521\"]);\nvar KEYUTIL=function(){var d=function(p,r,q){return k(CryptoJS.AES,p,r,q)};var e=function(p,r,q){return k(CryptoJS.TripleDES,p,r,q)};var a=function(p,r,q){return k(CryptoJS.DES,p,r,q)};var k=function(s,x,u,q){var r=CryptoJS.enc.Hex.parse(x);var w=CryptoJS.enc.Hex.parse(u);var p=CryptoJS.enc.Hex.parse(q);var t={};t.key=w;t.iv=p;t.ciphertext=r;var v=s.decrypt(t,w,{iv:p});return CryptoJS.enc.Hex.stringify(v)};var l=function(p,r,q){return g(CryptoJS.AES,p,r,q)};var o=function(p,r,q){return g(CryptoJS.TripleDES,p,r,q)};var f=function(p,r,q){return g(CryptoJS.DES,p,r,q)};var g=function(t,y,v,q){var s=CryptoJS.enc.Hex.parse(y);var x=CryptoJS.enc.Hex.parse(v);var p=CryptoJS.enc.Hex.parse(q);var w=t.encrypt(s,x,{iv:p});var r=CryptoJS.enc.Hex.parse(w.toString());var u=CryptoJS.enc.Base64.stringify(r);return u};var i={\"AES-256-CBC\":{proc:d,eproc:l,keylen:32,ivlen:16},\"AES-192-CBC\":{proc:d,eproc:l,keylen:24,ivlen:16},\"AES-128-CBC\":{proc:d,eproc:l,keylen:16,ivlen:16},\"DES-EDE3-CBC\":{proc:e,eproc:o,keylen:24,ivlen:8},\"DES-CBC\":{proc:a,eproc:f,keylen:8,ivlen:8}};var c=function(p){return i[p][\"proc\"]};var m=function(p){var r=CryptoJS.lib.WordArray.random(p);var q=CryptoJS.enc.Hex.stringify(r);return q};var n=function(v){var w={};var q=v.match(new RegExp(\"DEK-Info: ([^,]+),([0-9A-Fa-f]+)\",\"m\"));if(q){w.cipher=q[1];w.ivsalt=q[2]}var p=v.match(new RegExp(\"-----BEGIN ([A-Z]+) PRIVATE KEY-----\"));if(p){w.type=p[1]}var u=-1;var x=0;if(v.indexOf(\"\\r\\n\\r\\n\")!=-1){u=v.indexOf(\"\\r\\n\\r\\n\");x=2}if(v.indexOf(\"\\n\\n\")!=-1){u=v.indexOf(\"\\n\\n\");x=1}var t=v.indexOf(\"-----END\");if(u!=-1&&t!=-1){var r=v.substring(u+x*2,t-x);r=r.replace(/\\s+/g,\"\");w.data=r}return w};var j=function(q,y,p){var v=p.substring(0,16);var t=CryptoJS.enc.Hex.parse(v);var r=CryptoJS.enc.Utf8.parse(y);var u=i[q][\"keylen\"]+i[q][\"ivlen\"];var x=\"\";var w=null;for(;;){var s=CryptoJS.algo.MD5.create();if(w!=null){s.update(w)}s.update(r);s.update(t);w=s.finalize();x=x+CryptoJS.enc.Hex.stringify(w);if(x.length>=u*2){break}}var z={};z.keyhex=x.substr(0,i[q][\"keylen\"]*2);z.ivhex=x.substr(i[q][\"keylen\"]*2,i[q][\"ivlen\"]*2);return z};var b=function(p,v,r,w){var s=CryptoJS.enc.Base64.parse(p);var q=CryptoJS.enc.Hex.stringify(s);var u=i[v][\"proc\"];var t=u(q,r,w);return t};var h=function(p,s,q,u){var r=i[s][\"eproc\"];var t=r(p,q,u);return t};return{version:\"1.0.0\",parsePKCS5PEM:function(p){return n(p)},getKeyAndUnusedIvByPasscodeAndIvsalt:function(q,p,r){return j(q,p,r)},decryptKeyB64:function(p,r,q,s){return b(p,r,q,s)},getDecryptedKeyHex:function(y,x){var q=n(y);var t=q.type;var r=q.cipher;var p=q.ivsalt;var s=q.data;var w=j(r,x,p);var v=w.keyhex;var u=b(s,r,v,p);return u},getEncryptedPKCS5PEMFromPrvKeyHex:function(x,s,A,t,r){var p=\"\";if(typeof t==\"undefined\"||t==null){t=\"AES-256-CBC\"}if(typeof i[t]==\"undefined\"){throw\"KEYUTIL unsupported algorithm: \"+t}if(typeof r==\"undefined\"||r==null){var v=i[t][\"ivlen\"];var u=m(v);r=u.toUpperCase()}var z=j(t,A,r);var y=z.keyhex;var w=h(s,t,y,r);var q=w.replace(/(.{64})/g,\"$1\\r\\n\");var p=\"-----BEGIN \"+x+\" PRIVATE KEY-----\\r\\n\";p+=\"Proc-Type: 4,ENCRYPTED\\r\\n\";p+=\"DEK-Info: \"+t+\",\"+r+\"\\r\\n\";p+=\"\\r\\n\";p+=q;p+=\"\\r\\n-----END \"+x+\" PRIVATE KEY-----\\r\\n\";return p},parseHexOfEncryptedPKCS8:function(y){var B=ASN1HEX;var z=B.getChildIdx;var w=B.getV;var t={};var r=z(y,0);if(r.length!=2){throw\"malformed format: SEQUENCE(0).items != 2: \"+r.length}t.ciphertext=w(y,r[1]);var A=z(y,r[0]);if(A.length!=2){throw\"malformed format: SEQUENCE(0.0).items != 2: \"+A.length}if(w(y,A[0])!=\"2a864886f70d01050d\"){throw\"this only supports pkcs5PBES2\"}var p=z(y,A[1]);if(A.length!=2){throw\"malformed format: SEQUENCE(0.0.1).items != 2: \"+p.length}var q=z(y,p[1]);if(q.length!=2){throw\"malformed format: SEQUENCE(0.0.1.1).items != 2: \"+q.length}if(w(y,q[0])!=\"2a864886f70d0307\"){throw\"this only supports TripleDES\"}t.encryptionSchemeAlg=\"TripleDES\";t.encryptionSchemeIV=w(y,q[1]);var s=z(y,p[0]);if(s.length!=2){throw\"malformed format: SEQUENCE(0.0.1.0).items != 2: \"+s.length}if(w(y,s[0])!=\"2a864886f70d01050c\"){throw\"this only supports pkcs5PBKDF2\"}var x=z(y,s[1]);if(x.length<2){throw\"malformed format: SEQUENCE(0.0.1.0.1).items < 2: \"+x.length}t.pbkdf2Salt=w(y,x[0]);var u=w(y,x[1]);try{t.pbkdf2Iter=parseInt(u,16)}catch(v){throw\"malformed format pbkdf2Iter: \"+u}return t},getPBKDF2KeyHexFromParam:function(u,p){var t=CryptoJS.enc.Hex.parse(u.pbkdf2Salt);var q=u.pbkdf2Iter;var s=CryptoJS.PBKDF2(p,t,{keySize:192/32,iterations:q});var r=CryptoJS.enc.Hex.stringify(s);return r},_getPlainPKCS8HexFromEncryptedPKCS8PEM:function(x,y){var r=pemtohex(x,\"ENCRYPTED PRIVATE KEY\");var p=this.parseHexOfEncryptedPKCS8(r);var u=KEYUTIL.getPBKDF2KeyHexFromParam(p,y);var v={};v.ciphertext=CryptoJS.enc.Hex.parse(p.ciphertext);var t=CryptoJS.enc.Hex.parse(u);var s=CryptoJS.enc.Hex.parse(p.encryptionSchemeIV);var w=CryptoJS.TripleDES.decrypt(v,t,{iv:s});var q=CryptoJS.enc.Hex.stringify(w);return q},getKeyFromEncryptedPKCS8PEM:function(s,q){var p=this._getPlainPKCS8HexFromEncryptedPKCS8PEM(s,q);var r=this.getKeyFromPlainPrivatePKCS8Hex(p);return r},parsePlainPrivatePKCS8Hex:function(s){var v=ASN1HEX;var u=v.getChildIdx;var t=v.getV;var q={};q.algparam=null;if(s.substr(0,2)!=\"30\"){throw\"malformed plain PKCS8 private key(code:001)\"}var r=u(s,0);if(r.length!=3){throw\"malformed plain PKCS8 private key(code:002)\"}if(s.substr(r[1],2)!=\"30\"){throw\"malformed PKCS8 private key(code:003)\"}var p=u(s,r[1]);if(p.length!=2){throw\"malformed PKCS8 private key(code:004)\"}if(s.substr(p[0],2)!=\"06\"){throw\"malformed PKCS8 private key(code:005)\"}q.algoid=t(s,p[0]);if(s.substr(p[1],2)==\"06\"){q.algparam=t(s,p[1])}if(s.substr(r[2],2)!=\"04\"){throw\"malformed PKCS8 private key(code:006)\"}q.keyidx=v.getVidx(s,r[2]);return q},getKeyFromPlainPrivatePKCS8PEM:function(q){var p=pemtohex(q,\"PRIVATE KEY\");var r=this.getKeyFromPlainPrivatePKCS8Hex(p);return r},getKeyFromPlainPrivatePKCS8Hex:function(p){var q=this.parsePlainPrivatePKCS8Hex(p);var r;if(q.algoid==\"2a864886f70d010101\"){r=new RSAKey()}else{if(q.algoid==\"2a8648ce380401\"){r=new KJUR.crypto.DSA()}else{if(q.algoid==\"2a8648ce3d0201\"){r=new KJUR.crypto.ECDSA()}else{throw\"unsupported private key algorithm\"}}}r.readPKCS8PrvKeyHex(p);return r},_getKeyFromPublicPKCS8Hex:function(q){var p;var r=ASN1HEX.getVbyList(q,0,[0,0],\"06\");if(r===\"2a864886f70d010101\"){p=new RSAKey()}else{if(r===\"2a8648ce380401\"){p=new KJUR.crypto.DSA()}else{if(r===\"2a8648ce3d0201\"){p=new KJUR.crypto.ECDSA()}else{throw\"unsupported PKCS#8 public key hex\"}}}p.readPKCS8PubKeyHex(q);return p},parsePublicRawRSAKeyHex:function(r){var u=ASN1HEX;var t=u.getChildIdx;var s=u.getV;var p={};if(r.substr(0,2)!=\"30\"){throw\"malformed RSA key(code:001)\"}var q=t(r,0);if(q.length!=2){throw\"malformed RSA key(code:002)\"}if(r.substr(q[0],2)!=\"02\"){throw\"malformed RSA key(code:003)\"}p.n=s(r,q[0]);if(r.substr(q[1],2)!=\"02\"){throw\"malformed RSA key(code:004)\"}p.e=s(r,q[1]);return p},parsePublicPKCS8Hex:function(t){var v=ASN1HEX;var u=v.getChildIdx;var s=v.getV;var q={};q.algparam=null;var r=u(t,0);if(r.length!=2){throw\"outer DERSequence shall have 2 elements: \"+r.length}var w=r[0];if(t.substr(w,2)!=\"30\"){throw\"malformed PKCS8 public key(code:001)\"}var p=u(t,w);if(p.length!=2){throw\"malformed PKCS8 public key(code:002)\"}if(t.substr(p[0],2)!=\"06\"){throw\"malformed PKCS8 public key(code:003)\"}q.algoid=s(t,p[0]);if(t.substr(p[1],2)==\"06\"){q.algparam=s(t,p[1])}else{if(t.substr(p[1],2)==\"30\"){q.algparam={};q.algparam.p=v.getVbyList(t,p[1],[0],\"02\");q.algparam.q=v.getVbyList(t,p[1],[1],\"02\");q.algparam.g=v.getVbyList(t,p[1],[2],\"02\")}}if(t.substr(r[1],2)!=\"03\"){throw\"malformed PKCS8 public key(code:004)\"}q.key=s(t,r[1]).substr(2);return q},}}();KEYUTIL.getKey=function(l,k,n){var G=ASN1HEX,L=G.getChildIdx,v=G.getV,d=G.getVbyList,c=KJUR.crypto,i=c.ECDSA,C=c.DSA,w=RSAKey,M=pemtohex,F=KEYUTIL;if(typeof w!=\"undefined\"&&l instanceof w){return l}if(typeof i!=\"undefined\"&&l instanceof i){return l}if(typeof C!=\"undefined\"&&l instanceof C){return l}if(l.curve!==undefined&&l.xy!==undefined&&l.d===undefined){return new i({pub:l.xy,curve:l.curve})}if(l.curve!==undefined&&l.d!==undefined){return new i({prv:l.d,curve:l.curve})}if(l.kty===undefined&&l.n!==undefined&&l.e!==undefined&&l.d===undefined){var P=new w();P.setPublic(l.n,l.e);return P}if(l.kty===undefined&&l.n!==undefined&&l.e!==undefined&&l.d!==undefined&&l.p!==undefined&&l.q!==undefined&&l.dp!==undefined&&l.dq!==undefined&&l.co!==undefined&&l.qi===undefined){var P=new w();P.setPrivateEx(l.n,l.e,l.d,l.p,l.q,l.dp,l.dq,l.co);return P}if(l.kty===undefined&&l.n!==undefined&&l.e!==undefined&&l.d!==undefined&&l.p===undefined){var P=new w();P.setPrivate(l.n,l.e,l.d);return P}if(l.p!==undefined&&l.q!==undefined&&l.g!==undefined&&l.y!==undefined&&l.x===undefined){var P=new C();P.setPublic(l.p,l.q,l.g,l.y);return P}if(l.p!==undefined&&l.q!==undefined&&l.g!==undefined&&l.y!==undefined&&l.x!==undefined){var P=new C();P.setPrivate(l.p,l.q,l.g,l.y,l.x);return P}if(l.kty===\"RSA\"&&l.n!==undefined&&l.e!==undefined&&l.d===undefined){var P=new w();P.setPublic(b64utohex(l.n),b64utohex(l.e));return P}if(l.kty===\"RSA\"&&l.n!==undefined&&l.e!==undefined&&l.d!==undefined&&l.p!==undefined&&l.q!==undefined&&l.dp!==undefined&&l.dq!==undefined&&l.qi!==undefined){var P=new w();P.setPrivateEx(b64utohex(l.n),b64utohex(l.e),b64utohex(l.d),b64utohex(l.p),b64utohex(l.q),b64utohex(l.dp),b64utohex(l.dq),b64utohex(l.qi));return P}if(l.kty===\"RSA\"&&l.n!==undefined&&l.e!==undefined&&l.d!==undefined){var P=new w();P.setPrivate(b64utohex(l.n),b64utohex(l.e),b64utohex(l.d));return P}if(l.kty===\"EC\"&&l.crv!==undefined&&l.x!==undefined&&l.y!==undefined&&l.d===undefined){var j=new i({curve:l.crv});var t=j.ecparams.keylen/4;var B=(\"0000000000\"+b64utohex(l.x)).slice(-t);var z=(\"0000000000\"+b64utohex(l.y)).slice(-t);var u=\"04\"+B+z;j.setPublicKeyHex(u);return j}if(l.kty===\"EC\"&&l.crv!==undefined&&l.x!==undefined&&l.y!==undefined&&l.d!==undefined){var j=new i({curve:l.crv});var t=j.ecparams.keylen/4;var B=(\"0000000000\"+b64utohex(l.x)).slice(-t);var z=(\"0000000000\"+b64utohex(l.y)).slice(-t);var u=\"04\"+B+z;var b=(\"0000000000\"+b64utohex(l.d)).slice(-t);j.setPublicKeyHex(u);j.setPrivateKeyHex(b);return j}if(n===\"pkcs5prv\"){var J=l,G=ASN1HEX,N,P;N=L(J,0);if(N.length===9){P=new w();P.readPKCS5PrvKeyHex(J)}else{if(N.length===6){P=new C();P.readPKCS5PrvKeyHex(J)}else{if(N.length>2&&J.substr(N[1],2)===\"04\"){P=new i();P.readPKCS5PrvKeyHex(J)}else{throw\"unsupported PKCS#1/5 hexadecimal key\"}}}return P}if(n===\"pkcs8prv\"){var P=F.getKeyFromPlainPrivatePKCS8Hex(l);return P}if(n===\"pkcs8pub\"){return F._getKeyFromPublicPKCS8Hex(l)}if(n===\"x509pub\"){return X509.getPublicKeyFromCertHex(l)}if(l.indexOf(\"-END CERTIFICATE-\",0)!=-1||l.indexOf(\"-END X509 CERTIFICATE-\",0)!=-1||l.indexOf(\"-END TRUSTED CERTIFICATE-\",0)!=-1){return X509.getPublicKeyFromCertPEM(l)}if(l.indexOf(\"-END PUBLIC KEY-\")!=-1){var O=pemtohex(l,\"PUBLIC KEY\");return F._getKeyFromPublicPKCS8Hex(O)}if(l.indexOf(\"-END RSA PRIVATE KEY-\")!=-1&&l.indexOf(\"4,ENCRYPTED\")==-1){var m=M(l,\"RSA PRIVATE KEY\");return F.getKey(m,null,\"pkcs5prv\")}if(l.indexOf(\"-END DSA PRIVATE KEY-\")!=-1&&l.indexOf(\"4,ENCRYPTED\")==-1){var I=M(l,\"DSA PRIVATE KEY\");var E=d(I,0,[1],\"02\");var D=d(I,0,[2],\"02\");var K=d(I,0,[3],\"02\");var r=d(I,0,[4],\"02\");var s=d(I,0,[5],\"02\");var P=new C();P.setPrivate(new BigInteger(E,16),new BigInteger(D,16),new BigInteger(K,16),new BigInteger(r,16),new BigInteger(s,16));return P}if(l.indexOf(\"-END PRIVATE KEY-\")!=-1){return F.getKeyFromPlainPrivatePKCS8PEM(l)}if(l.indexOf(\"-END RSA PRIVATE KEY-\")!=-1&&l.indexOf(\"4,ENCRYPTED\")!=-1){var o=F.getDecryptedKeyHex(l,k);var H=new RSAKey();H.readPKCS5PrvKeyHex(o);return H}if(l.indexOf(\"-END EC PRIVATE KEY-\")!=-1&&l.indexOf(\"4,ENCRYPTED\")!=-1){var I=F.getDecryptedKeyHex(l,k);var P=d(I,0,[1],\"04\");var f=d(I,0,[2,0],\"06\");var A=d(I,0,[3,0],\"03\").substr(2);var e=\"\";if(KJUR.crypto.OID.oidhex2name[f]!==undefined){e=KJUR.crypto.OID.oidhex2name[f]}else{throw\"undefined OID(hex) in KJUR.crypto.OID: \"+f}var j=new i({curve:e});j.setPublicKeyHex(A);j.setPrivateKeyHex(P);j.isPublic=false;return j}if(l.indexOf(\"-END DSA PRIVATE KEY-\")!=-1&&l.indexOf(\"4,ENCRYPTED\")!=-1){var I=F.getDecryptedKeyHex(l,k);var E=d(I,0,[1],\"02\");var D=d(I,0,[2],\"02\");var K=d(I,0,[3],\"02\");var r=d(I,0,[4],\"02\");var s=d(I,0,[5],\"02\");var P=new C();P.setPrivate(new BigInteger(E,16),new BigInteger(D,16),new BigInteger(K,16),new BigInteger(r,16),new BigInteger(s,16));return P}if(l.indexOf(\"-END ENCRYPTED PRIVATE KEY-\")!=-1){return F.getKeyFromEncryptedPKCS8PEM(l,k)}throw\"not supported argument\"};KEYUTIL.generateKeypair=function(a,c){if(a==\"RSA\"){var b=c;var h=new RSAKey();h.generate(b,\"10001\");h.isPrivate=true;h.isPublic=true;var f=new RSAKey();var e=h.n.toString(16);var i=h.e.toString(16);f.setPublic(e,i);f.isPrivate=false;f.isPublic=true;var k={};k.prvKeyObj=h;k.pubKeyObj=f;return k}else{if(a==\"EC\"){var d=c;var g=new KJUR.crypto.ECDSA({curve:d});var j=g.generateKeyPairHex();var h=new KJUR.crypto.ECDSA({curve:d});h.setPublicKeyHex(j.ecpubhex);h.setPrivateKeyHex(j.ecprvhex);h.isPrivate=true;h.isPublic=false;var f=new KJUR.crypto.ECDSA({curve:d});f.setPublicKeyHex(j.ecpubhex);f.isPrivate=false;f.isPublic=true;var k={};k.prvKeyObj=h;k.pubKeyObj=f;return k}else{throw\"unknown algorithm: \"+a}}};KEYUTIL.getPEM=function(b,D,y,m,q,j){var F=KJUR,k=F.asn1,z=k.DERObjectIdentifier,f=k.DERInteger,l=k.ASN1Util.newObject,a=k.x509,C=a.SubjectPublicKeyInfo,e=F.crypto,u=e.DSA,r=e.ECDSA,n=RSAKey;function A(s){var G=l({seq:[{\"int\":0},{\"int\":{bigint:s.n}},{\"int\":s.e},{\"int\":{bigint:s.d}},{\"int\":{bigint:s.p}},{\"int\":{bigint:s.q}},{\"int\":{bigint:s.dmp1}},{\"int\":{bigint:s.dmq1}},{\"int\":{bigint:s.coeff}}]});return G}function B(G){var s=l({seq:[{\"int\":1},{octstr:{hex:G.prvKeyHex}},{tag:[\"a0\",true,{oid:{name:G.curveName}}]},{tag:[\"a1\",true,{bitstr:{hex:\"00\"+G.pubKeyHex}}]}]});return s}function x(s){var G=l({seq:[{\"int\":0},{\"int\":{bigint:s.p}},{\"int\":{bigint:s.q}},{\"int\":{bigint:s.g}},{\"int\":{bigint:s.y}},{\"int\":{bigint:s.x}}]});return G}if(((n!==undefined&&b instanceof n)||(u!==undefined&&b instanceof u)||(r!==undefined&&b instanceof r))&&b.isPublic==true&&(D===undefined||D==\"PKCS8PUB\")){var E=new C(b);var w=E.getEncodedHex();return hextopem(w,\"PUBLIC KEY\")}if(D==\"PKCS1PRV\"&&n!==undefined&&b instanceof n&&(y===undefined||y==null)&&b.isPrivate==true){var E=A(b);var w=E.getEncodedHex();return hextopem(w,\"RSA PRIVATE KEY\")}if(D==\"PKCS1PRV\"&&r!==undefined&&b instanceof r&&(y===undefined||y==null)&&b.isPrivate==true){var i=new z({name:b.curveName});var v=i.getEncodedHex();var h=B(b);var t=h.getEncodedHex();var p=\"\";p+=hextopem(v,\"EC PARAMETERS\");p+=hextopem(t,\"EC PRIVATE KEY\");return p}if(D==\"PKCS1PRV\"&&u!==undefined&&b instanceof u&&(y===undefined||y==null)&&b.isPrivate==true){var E=x(b);var w=E.getEncodedHex();return hextopem(w,\"DSA PRIVATE KEY\")}if(D==\"PKCS5PRV\"&&n!==undefined&&b instanceof n&&(y!==undefined&&y!=null)&&b.isPrivate==true){var E=A(b);var w=E.getEncodedHex();if(m===undefined){m=\"DES-EDE3-CBC\"}return this.getEncryptedPKCS5PEMFromPrvKeyHex(\"RSA\",w,y,m,j)}if(D==\"PKCS5PRV\"&&r!==undefined&&b instanceof r&&(y!==undefined&&y!=null)&&b.isPrivate==true){var E=B(b);var w=E.getEncodedHex();if(m===undefined){m=\"DES-EDE3-CBC\"}return this.getEncryptedPKCS5PEMFromPrvKeyHex(\"EC\",w,y,m,j)}if(D==\"PKCS5PRV\"&&u!==undefined&&b instanceof u&&(y!==undefined&&y!=null)&&b.isPrivate==true){var E=x(b);var w=E.getEncodedHex();if(m===undefined){m=\"DES-EDE3-CBC\"}return this.getEncryptedPKCS5PEMFromPrvKeyHex(\"DSA\",w,y,m,j)}var o=function(G,s){var I=c(G,s);var H=new l({seq:[{seq:[{oid:{name:\"pkcs5PBES2\"}},{seq:[{seq:[{oid:{name:\"pkcs5PBKDF2\"}},{seq:[{octstr:{hex:I.pbkdf2Salt}},{\"int\":I.pbkdf2Iter}]}]},{seq:[{oid:{name:\"des-EDE3-CBC\"}},{octstr:{hex:I.encryptionSchemeIV}}]}]}]},{octstr:{hex:I.ciphertext}}]});return H.getEncodedHex()};var c=function(N,O){var H=100;var M=CryptoJS.lib.WordArray.random(8);var L=\"DES-EDE3-CBC\";var s=CryptoJS.lib.WordArray.random(8);var I=CryptoJS.PBKDF2(O,M,{keySize:192/32,iterations:H});var J=CryptoJS.enc.Hex.parse(N);var K=CryptoJS.TripleDES.encrypt(J,I,{iv:s})+\"\";var G={};G.ciphertext=K;G.pbkdf2Salt=CryptoJS.enc.Hex.stringify(M);G.pbkdf2Iter=H;G.encryptionSchemeAlg=L;G.encryptionSchemeIV=CryptoJS.enc.Hex.stringify(s);return G};if(D==\"PKCS8PRV\"&&n!=undefined&&b instanceof n&&b.isPrivate==true){var g=A(b);var d=g.getEncodedHex();var E=l({seq:[{\"int\":0},{seq:[{oid:{name:\"rsaEncryption\"}},{\"null\":true}]},{octstr:{hex:d}}]});var w=E.getEncodedHex();if(y===undefined||y==null){return hextopem(w,\"PRIVATE KEY\")}else{var t=o(w,y);return hextopem(t,\"ENCRYPTED PRIVATE KEY\")}}if(D==\"PKCS8PRV\"&&r!==undefined&&b instanceof r&&b.isPrivate==true){var g=new l({seq:[{\"int\":1},{octstr:{hex:b.prvKeyHex}},{tag:[\"a1\",true,{bitstr:{hex:\"00\"+b.pubKeyHex}}]}]});var d=g.getEncodedHex();var E=l({seq:[{\"int\":0},{seq:[{oid:{name:\"ecPublicKey\"}},{oid:{name:b.curveName}}]},{octstr:{hex:d}}]});var w=E.getEncodedHex();if(y===undefined||y==null){return hextopem(w,\"PRIVATE KEY\")}else{var t=o(w,y);return hextopem(t,\"ENCRYPTED PRIVATE KEY\")}}if(D==\"PKCS8PRV\"&&u!==undefined&&b instanceof u&&b.isPrivate==true){var g=new f({bigint:b.x});var d=g.getEncodedHex();var E=l({seq:[{\"int\":0},{seq:[{oid:{name:\"dsa\"}},{seq:[{\"int\":{bigint:b.p}},{\"int\":{bigint:b.q}},{\"int\":{bigint:b.g}}]}]},{octstr:{hex:d}}]});var w=E.getEncodedHex();if(y===undefined||y==null){return hextopem(w,\"PRIVATE KEY\")}else{var t=o(w,y);return hextopem(t,\"ENCRYPTED PRIVATE KEY\")}}throw\"unsupported object nor format\"};KEYUTIL.getKeyFromCSRPEM=function(b){var a=pemtohex(b,\"CERTIFICATE REQUEST\");var c=KEYUTIL.getKeyFromCSRHex(a);return c};KEYUTIL.getKeyFromCSRHex=function(a){var c=KEYUTIL.parseCSRHex(a);var b=KEYUTIL.getKey(c.p8pubkeyhex,null,\"pkcs8pub\");return b};KEYUTIL.parseCSRHex=function(d){var i=ASN1HEX;var f=i.getChildIdx;var c=i.getTLV;var b={};var g=d;if(g.substr(0,2)!=\"30\"){throw\"malformed CSR(code:001)\"}var e=f(g,0);if(e.length<1){throw\"malformed CSR(code:002)\"}if(g.substr(e[0],2)!=\"30\"){throw\"malformed CSR(code:003)\"}var a=f(g,e[0]);if(a.length<3){throw\"malformed CSR(code:004)\"}b.p8pubkeyhex=c(g,a[2]);return b};KEYUTIL.getJWKFromKey=function(d){var b={};if(d instanceof RSAKey&&d.isPrivate){b.kty=\"RSA\";b.n=hextob64u(d.n.toString(16));b.e=hextob64u(d.e.toString(16));b.d=hextob64u(d.d.toString(16));b.p=hextob64u(d.p.toString(16));b.q=hextob64u(d.q.toString(16));b.dp=hextob64u(d.dmp1.toString(16));b.dq=hextob64u(d.dmq1.toString(16));b.qi=hextob64u(d.coeff.toString(16));return b}else{if(d instanceof RSAKey&&d.isPublic){b.kty=\"RSA\";b.n=hextob64u(d.n.toString(16));b.e=hextob64u(d.e.toString(16));return b}else{if(d instanceof KJUR.crypto.ECDSA&&d.isPrivate){var a=d.getShortNISTPCurveName();if(a!==\"P-256\"&&a!==\"P-384\"){throw\"unsupported curve name for JWT: \"+a}var c=d.getPublicKeyXYHex();b.kty=\"EC\";b.crv=a;b.x=hextob64u(c.x);b.y=hextob64u(c.y);b.d=hextob64u(d.prvKeyHex);return b}else{if(d instanceof KJUR.crypto.ECDSA&&d.isPublic){var a=d.getShortNISTPCurveName();if(a!==\"P-256\"&&a!==\"P-384\"){throw\"unsupported curve name for JWT: \"+a}var c=d.getPublicKeyXYHex();b.kty=\"EC\";b.crv=a;b.x=hextob64u(c.x);b.y=hextob64u(c.y);return b}}}}throw\"not supported key object\"};\nRSAKey.getPosArrayOfChildrenFromHex=function(a){return ASN1HEX.getChildIdx(a,0)};RSAKey.getHexValueArrayOfChildrenFromHex=function(f){var n=ASN1HEX;var i=n.getV;var k=RSAKey.getPosArrayOfChildrenFromHex(f);var e=i(f,k[0]);var j=i(f,k[1]);var b=i(f,k[2]);var c=i(f,k[3]);var h=i(f,k[4]);var g=i(f,k[5]);var m=i(f,k[6]);var l=i(f,k[7]);var d=i(f,k[8]);var k=new Array();k.push(e,j,b,c,h,g,m,l,d);return k};RSAKey.prototype.readPrivateKeyFromPEMString=function(d){var c=pemtohex(d);var b=RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1],b[2],b[3],b[4],b[5],b[6],b[7],b[8])};RSAKey.prototype.readPKCS5PrvKeyHex=function(c){var b=RSAKey.getHexValueArrayOfChildrenFromHex(c);this.setPrivateEx(b[1],b[2],b[3],b[4],b[5],b[6],b[7],b[8])};RSAKey.prototype.readPKCS8PrvKeyHex=function(e){var c,j,l,b,a,f,d,k;var m=ASN1HEX;var g=m.getVbyList;if(m.isASN1HEX(e)===false){throw\"not ASN.1 hex string\"}try{c=g(e,0,[2,0,1],\"02\");j=g(e,0,[2,0,2],\"02\");l=g(e,0,[2,0,3],\"02\");b=g(e,0,[2,0,4],\"02\");a=g(e,0,[2,0,5],\"02\");f=g(e,0,[2,0,6],\"02\");d=g(e,0,[2,0,7],\"02\");k=g(e,0,[2,0,8],\"02\")}catch(i){throw\"malformed PKCS#8 plain RSA private key\"}this.setPrivateEx(c,j,l,b,a,f,d,k)};RSAKey.prototype.readPKCS5PubKeyHex=function(c){var e=ASN1HEX;var b=e.getV;if(e.isASN1HEX(c)===false){throw\"keyHex is not ASN.1 hex string\"}var a=e.getChildIdx(c,0);if(a.length!==2||c.substr(a[0],2)!==\"02\"||c.substr(a[1],2)!==\"02\"){throw\"wrong hex for PKCS#5 public key\"}var f=b(c,a[0]);var d=b(c,a[1]);this.setPublic(f,d)};RSAKey.prototype.readPKCS8PubKeyHex=function(b){var c=ASN1HEX;if(c.isASN1HEX(b)===false){throw\"not ASN.1 hex string\"}if(c.getTLVbyList(b,0,[0,0])!==\"06092a864886f70d010101\"){throw\"not PKCS8 RSA public key\"}var a=c.getTLVbyList(b,0,[1,0]);this.readPKCS5PubKeyHex(a)};RSAKey.prototype.readCertPubKeyHex=function(b,d){var a,c;a=new X509();a.readCertHex(b);c=a.getPublicKeyHex();this.readPKCS8PubKeyHex(c)};\nvar _RE_HEXDECONLY=new RegExp(\"\");_RE_HEXDECONLY.compile(\"[^0-9a-f]\",\"gi\");function _rsasign_getHexPaddedDigestInfoForString(d,e,a){var b=function(f){return KJUR.crypto.Util.hashString(f,a)};var c=b(d);return KJUR.crypto.Util.getPaddedDigestInfoHex(c,a,e)}function _zeroPaddingOfSignature(e,d){var c=\"\";var a=d/4-e.length;for(var b=0;b<a;b++){c=c+\"0\"}return c+e}RSAKey.prototype.sign=function(d,a){var b=function(e){return KJUR.crypto.Util.hashString(e,a)};var c=b(d);return this.signWithMessageHash(c,a)};RSAKey.prototype.signWithMessageHash=function(e,c){var f=KJUR.crypto.Util.getPaddedDigestInfoHex(e,c,this.n.bitLength());var b=parseBigInt(f,16);var d=this.doPrivate(b);var a=d.toString(16);return _zeroPaddingOfSignature(a,this.n.bitLength())};function pss_mgf1_str(c,a,e){var b=\"\",d=0;while(b.length<a){b+=hextorstr(e(rstrtohex(c+String.fromCharCode.apply(String,[(d&4278190080)>>24,(d&16711680)>>16,(d&65280)>>8,d&255]))));d+=1}return b}RSAKey.prototype.signPSS=function(e,a,d){var c=function(f){return KJUR.crypto.Util.hashHex(f,a)};var b=c(rstrtohex(e));if(d===undefined){d=-1}return this.signWithMessageHashPSS(b,a,d)};RSAKey.prototype.signWithMessageHashPSS=function(l,a,k){var b=hextorstr(l);var g=b.length;var m=this.n.bitLength()-1;var c=Math.ceil(m/8);var d;var o=function(i){return KJUR.crypto.Util.hashHex(i,a)};if(k===-1||k===undefined){k=g}else{if(k===-2){k=c-g-2}else{if(k<-2){throw\"invalid salt length\"}}}if(c<(g+k+2)){throw\"data too long\"}var f=\"\";if(k>0){f=new Array(k);new SecureRandom().nextBytes(f);f=String.fromCharCode.apply(String,f)}var n=hextorstr(o(rstrtohex(\"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"+b+f)));var j=[];for(d=0;d<c-k-g-2;d+=1){j[d]=0}var e=String.fromCharCode.apply(String,j)+\"\\x01\"+f;var h=pss_mgf1_str(n,e.length,o);var q=[];for(d=0;d<e.length;d+=1){q[d]=e.charCodeAt(d)^h.charCodeAt(d)}var p=(65280>>(8*c-m))&255;q[0]&=~p;for(d=0;d<g;d++){q.push(n.charCodeAt(d))}q.push(188);return _zeroPaddingOfSignature(this.doPrivate(new BigInteger(q)).toString(16),this.n.bitLength())};function _rsasign_getDecryptSignatureBI(a,d,c){var b=new RSAKey();b.setPublic(d,c);var e=b.doPublic(a);return e}function _rsasign_getHexDigestInfoFromSig(a,c,b){var e=_rsasign_getDecryptSignatureBI(a,c,b);var d=e.toString(16).replace(/^1f+00/,\"\");return d}function _rsasign_getAlgNameAndHashFromHexDisgestInfo(f){for(var e in KJUR.crypto.Util.DIGESTINFOHEAD){var d=KJUR.crypto.Util.DIGESTINFOHEAD[e];var b=d.length;if(f.substring(0,b)==d){var c=[e,f.substring(b)];return c}}return[]}RSAKey.prototype.verify=function(f,j){j=j.replace(_RE_HEXDECONLY,\"\");j=j.replace(/[ \\n]+/g,\"\");var b=parseBigInt(j,16);if(b.bitLength()>this.n.bitLength()){return 0}var i=this.doPublic(b);var e=i.toString(16).replace(/^1f+00/,\"\");var g=_rsasign_getAlgNameAndHashFromHexDisgestInfo(e);if(g.length==0){return false}var d=g[0];var h=g[1];var a=function(k){return KJUR.crypto.Util.hashString(k,d)};var c=a(f);return(h==c)};RSAKey.prototype.verifyWithMessageHash=function(e,a){a=a.replace(_RE_HEXDECONLY,\"\");a=a.replace(/[ \\n]+/g,\"\");var b=parseBigInt(a,16);if(b.bitLength()>this.n.bitLength()){return 0}var h=this.doPublic(b);var g=h.toString(16).replace(/^1f+00/,\"\");var c=_rsasign_getAlgNameAndHashFromHexDisgestInfo(g);if(c.length==0){return false}var d=c[0];var f=c[1];return(f==e)};RSAKey.prototype.verifyPSS=function(c,b,a,f){var e=function(g){return KJUR.crypto.Util.hashHex(g,a)};var d=e(rstrtohex(c));if(f===undefined){f=-1}return this.verifyWithMessageHashPSS(d,b,a,f)};RSAKey.prototype.verifyWithMessageHashPSS=function(f,s,l,c){var k=new BigInteger(s,16);if(k.bitLength()>this.n.bitLength()){return false}var r=function(i){return KJUR.crypto.Util.hashHex(i,l)};var j=hextorstr(f);var h=j.length;var g=this.n.bitLength()-1;var m=Math.ceil(g/8);var q;if(c===-1||c===undefined){c=h}else{if(c===-2){c=m-h-2}else{if(c<-2){throw\"invalid salt length\"}}}if(m<(h+c+2)){throw\"data too long\"}var a=this.doPublic(k).toByteArray();for(q=0;q<a.length;q+=1){a[q]&=255}while(a.length<m){a.unshift(0)}if(a[m-1]!==188){throw\"encoded message does not end in 0xbc\"}a=String.fromCharCode.apply(String,a);var d=a.substr(0,m-h-1);var e=a.substr(d.length,h);var p=(65280>>(8*m-g))&255;if((d.charCodeAt(0)&p)!==0){throw\"bits beyond keysize not zero\"}var n=pss_mgf1_str(e,d.length,r);var o=[];for(q=0;q<d.length;q+=1){o[q]=d.charCodeAt(q)^n.charCodeAt(q)}o[0]&=~p;var b=m-h-c-2;for(q=0;q<b;q+=1){if(o[q]!==0){throw\"leftmost octets not zero\"}}if(o[b]!==1){throw\"0x01 marker not found\"}return e===hextorstr(r(rstrtohex(\"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\"+j+String.fromCharCode.apply(String,o.slice(-c)))))};RSAKey.SALT_LEN_HLEN=-1;RSAKey.SALT_LEN_MAX=-2;RSAKey.SALT_LEN_RECOVER=-2;\nfunction X509(){var k=ASN1HEX,j=k.getChildIdx,h=k.getV,b=k.getTLV,f=k.getVbyList,c=k.getTLVbyList,g=k.getIdxbyList,d=k.getVidx,i=k.oidname,a=X509,e=pemtohex;this.hex=null;this.version=0;this.foffset=0;this.aExtInfo=null;this.getVersion=function(){if(this.hex===null||this.version!==0){return this.version}if(c(this.hex,0,[0,0])!==\"a003020102\"){this.version=1;this.foffset=-1;return 1}this.version=3;return 3};this.getSerialNumberHex=function(){return f(this.hex,0,[0,1+this.foffset],\"02\")};this.getSignatureAlgorithmField=function(){return i(f(this.hex,0,[0,2+this.foffset,0],\"06\"))};this.getIssuerHex=function(){return c(this.hex,0,[0,3+this.foffset],\"30\")};this.getIssuerString=function(){return a.hex2dn(this.getIssuerHex())};this.getSubjectHex=function(){return c(this.hex,0,[0,5+this.foffset],\"30\")};this.getSubjectString=function(){return a.hex2dn(this.getSubjectHex())};this.getNotBefore=function(){var l=f(this.hex,0,[0,4+this.foffset,0]);l=l.replace(/(..)/g,\"%$1\");l=decodeURIComponent(l);return l};this.getNotAfter=function(){var l=f(this.hex,0,[0,4+this.foffset,1]);l=l.replace(/(..)/g,\"%$1\");l=decodeURIComponent(l);return l};this.getPublicKeyHex=function(){return k.getTLVbyList(this.hex,0,[0,6+this.foffset],\"30\")};this.getPublicKeyIdx=function(){return g(this.hex,0,[0,6+this.foffset],\"30\")};this.getPublicKeyContentIdx=function(){var l=this.getPublicKeyIdx();return g(this.hex,l,[1,0],\"30\")};this.getPublicKey=function(){return KEYUTIL.getKey(this.getPublicKeyHex(),null,\"pkcs8pub\")};this.getSignatureAlgorithmName=function(){return i(f(this.hex,0,[1,0],\"06\"))};this.getSignatureValueHex=function(){return f(this.hex,0,[2],\"03\",true)};this.verifySignature=function(n){var o=this.getSignatureAlgorithmName();var l=this.getSignatureValueHex();var m=c(this.hex,0,[0],\"30\");var p=new KJUR.crypto.Signature({alg:o});p.init(n);p.updateHex(m);return p.verify(l)};this.parseExt=function(){if(this.version!==3){return -1}var p=g(this.hex,0,[0,7,0],\"30\");var m=j(this.hex,p);this.aExtInfo=new Array();for(var n=0;n<m.length;n++){var q={};q.critical=false;var l=j(this.hex,m[n]);var r=0;if(l.length===3){q.critical=true;r=1}q.oid=k.hextooidstr(f(this.hex,m[n],[0],\"06\"));var o=g(this.hex,m[n],[1+r]);q.vidx=d(this.hex,o);this.aExtInfo.push(q)}};this.getExtInfo=function(n){var l=this.aExtInfo;var o=n;if(!n.match(/^[0-9.]+$/)){o=KJUR.asn1.x509.OID.name2oid(n)}if(o===\"\"){return undefined}for(var m=0;m<l.length;m++){if(l[m].oid===o){return l[m]}}return undefined};this.getExtBasicConstraints=function(){var n=this.getExtInfo(\"basicConstraints\");if(n===undefined){return n}var l=h(this.hex,n.vidx);if(l===\"\"){return{}}if(l===\"0101ff\"){return{cA:true}}if(l.substr(0,8)===\"0101ff02\"){var o=h(l,6);var m=parseInt(o,16);return{cA:true,pathLen:m}}throw\"basicConstraints parse error\"};this.getExtKeyUsageBin=function(){var o=this.getExtInfo(\"keyUsage\");if(o===undefined){return\"\"}var m=h(this.hex,o.vidx);if(m.length%2!=0||m.length<=2){throw\"malformed key usage value\"}var l=parseInt(m.substr(0,2));var n=parseInt(m.substr(2),16).toString(2);return n.substr(0,n.length-l)};this.getExtKeyUsageString=function(){var n=this.getExtKeyUsageBin();var l=new Array();for(var m=0;m<n.length;m++){if(n.substr(m,1)==\"1\"){l.push(X509.KEYUSAGE_NAME[m])}}return l.join(\",\")};this.getExtSubjectKeyIdentifier=function(){var l=this.getExtInfo(\"subjectKeyIdentifier\");if(l===undefined){return l}return h(this.hex,l.vidx)};this.getExtAuthorityKeyIdentifier=function(){var p=this.getExtInfo(\"authorityKeyIdentifier\");if(p===undefined){return p}var l={};var o=b(this.hex,p.vidx);var m=j(o,0);for(var n=0;n<m.length;n++){if(o.substr(m[n],2)===\"80\"){l.kid=h(o,m[n])}}return l};this.getExtExtKeyUsageName=function(){var p=this.getExtInfo(\"extKeyUsage\");if(p===undefined){return p}var l=new Array();var o=b(this.hex,p.vidx);if(o===\"\"){return l}var m=j(o,0);for(var n=0;n<m.length;n++){l.push(i(h(o,m[n])))}return l};this.getExtSubjectAltName=function(){var m=this.getExtSubjectAltName2();var l=new Array();for(var n=0;n<m.length;n++){if(m[n][0]===\"DNS\"){l.push(m[n][1])}}return l};this.getExtSubjectAltName2=function(){var p,s,r;var q=this.getExtInfo(\"subjectAltName\");if(q===undefined){return q}var l=new Array();var o=b(this.hex,q.vidx);var m=j(o,0);for(var n=0;n<m.length;n++){r=o.substr(m[n],2);p=h(o,m[n]);if(r===\"81\"){s=hextoutf8(p);l.push([\"MAIL\",s])}if(r===\"82\"){s=hextoutf8(p);l.push([\"DNS\",s])}if(r===\"84\"){s=X509.hex2dn(p,0);l.push([\"DN\",s])}if(r===\"86\"){s=hextoutf8(p);l.push([\"URI\",s])}if(r===\"87\"){s=hextoip(p);l.push([\"IP\",s])}}return l};this.getExtCRLDistributionPointsURI=function(){var q=this.getExtInfo(\"cRLDistributionPoints\");if(q===undefined){return q}var l=new Array();var m=j(this.hex,q.vidx);for(var o=0;o<m.length;o++){try{var r=f(this.hex,m[o],[0,0,0],\"86\");var p=hextoutf8(r);l.push(p)}catch(n){}}return l};this.getExtAIAInfo=function(){var p=this.getExtInfo(\"authorityInfoAccess\");if(p===undefined){return p}var l={ocsp:[],caissuer:[]};var m=j(this.hex,p.vidx);for(var n=0;n<m.length;n++){var q=f(this.hex,m[n],[0],\"06\");var o=f(this.hex,m[n],[1],\"86\");if(q===\"2b06010505073001\"){l.ocsp.push(hextoutf8(o))}if(q===\"2b06010505073002\"){l.caissuer.push(hextoutf8(o))}}return l};this.getExtCertificatePolicies=function(){var o=this.getExtInfo(\"certificatePolicies\");if(o===undefined){return o}var l=b(this.hex,o.vidx);var u=[];var s=j(l,0);for(var r=0;r<s.length;r++){var t={};var n=j(l,s[r]);t.id=i(h(l,n[0]));if(n.length===2){var m=j(l,n[1]);for(var q=0;q<m.length;q++){var p=f(l,m[q],[0],\"06\");if(p===\"2b06010505070201\"){t.cps=hextoutf8(f(l,m[q],[1]))}else{if(p===\"2b06010505070202\"){t.unotice=hextoutf8(f(l,m[q],[1,0]))}}}}u.push(t)}return u};this.readCertPEM=function(l){this.readCertHex(e(l))};this.readCertHex=function(l){this.hex=l;this.getVersion();try{g(this.hex,0,[0,7],\"a3\");this.parseExt()}catch(m){}};this.getInfo=function(){var m=X509;var B,u,z;B=\"Basic Fields\\n\";B+=\"  serial number: \"+this.getSerialNumberHex()+\"\\n\";B+=\"  signature algorithm: \"+this.getSignatureAlgorithmField()+\"\\n\";B+=\"  issuer: \"+this.getIssuerString()+\"\\n\";B+=\"  notBefore: \"+this.getNotBefore()+\"\\n\";B+=\"  notAfter: \"+this.getNotAfter()+\"\\n\";B+=\"  subject: \"+this.getSubjectString()+\"\\n\";B+=\"  subject public key info: \\n\";u=this.getPublicKey();B+=\"    key algorithm: \"+u.type+\"\\n\";if(u.type===\"RSA\"){B+=\"    n=\"+hextoposhex(u.n.toString(16)).substr(0,16)+\"...\\n\";B+=\"    e=\"+hextoposhex(u.e.toString(16))+\"\\n\"}z=this.aExtInfo;if(z!==undefined&&z!==null){B+=\"X509v3 Extensions:\\n\";for(var r=0;r<z.length;r++){var n=z[r];var A=KJUR.asn1.x509.OID.oid2name(n.oid);if(A===\"\"){A=n.oid}var x=\"\";if(n.critical===true){x=\"CRITICAL\"}B+=\"  \"+A+\" \"+x+\":\\n\";if(A===\"basicConstraints\"){var v=this.getExtBasicConstraints();if(v.cA===undefined){B+=\"    {}\\n\"}else{B+=\"    cA=true\";if(v.pathLen!==undefined){B+=\", pathLen=\"+v.pathLen}B+=\"\\n\"}}else{if(A===\"keyUsage\"){B+=\"    \"+this.getExtKeyUsageString()+\"\\n\"}else{if(A===\"subjectKeyIdentifier\"){B+=\"    \"+this.getExtSubjectKeyIdentifier()+\"\\n\"}else{if(A===\"authorityKeyIdentifier\"){var l=this.getExtAuthorityKeyIdentifier();if(l.kid!==undefined){B+=\"    kid=\"+l.kid+\"\\n\"}}else{if(A===\"extKeyUsage\"){var w=this.getExtExtKeyUsageName();B+=\"    \"+w.join(\", \")+\"\\n\"}else{if(A===\"subjectAltName\"){var t=this.getExtSubjectAltName2();B+=\"    \"+t+\"\\n\"}else{if(A===\"cRLDistributionPoints\"){var y=this.getExtCRLDistributionPointsURI();B+=\"    \"+y+\"\\n\"}else{if(A===\"authorityInfoAccess\"){var p=this.getExtAIAInfo();if(p.ocsp!==undefined){B+=\"    ocsp: \"+p.ocsp.join(\",\")+\"\\n\"}if(p.caissuer!==undefined){B+=\"    caissuer: \"+p.caissuer.join(\",\")+\"\\n\"}}else{if(A===\"certificatePolicies\"){var o=this.getExtCertificatePolicies();for(var q=0;q<o.length;q++){if(o[q].id!==undefined){B+=\"    policy oid: \"+o[q].id+\"\\n\"}if(o[q].cps!==undefined){B+=\"    cps: \"+o[q].cps+\"\\n\"}}}}}}}}}}}}}B+=\"signature algorithm: \"+this.getSignatureAlgorithmName()+\"\\n\";B+=\"signature: \"+this.getSignatureValueHex().substr(0,16)+\"...\\n\";return B}}X509.hex2dn=function(f,b){if(b===undefined){b=0}if(f.substr(b,2)!==\"30\"){throw\"malformed DN\"}var c=new Array();var d=ASN1HEX.getChildIdx(f,b);for(var e=0;e<d.length;e++){c.push(X509.hex2rdn(f,d[e]))}c=c.map(function(a){return a.replace(\"/\",\"\\\\/\")});return\"/\"+c.join(\"/\")};X509.hex2rdn=function(f,b){if(b===undefined){b=0}if(f.substr(b,2)!==\"31\"){throw\"malformed RDN\"}var c=new Array();var d=ASN1HEX.getChildIdx(f,b);for(var e=0;e<d.length;e++){c.push(X509.hex2attrTypeValue(f,d[e]))}c=c.map(function(a){return a.replace(\"+\",\"\\\\+\")});return c.join(\"+\")};X509.hex2attrTypeValue=function(d,i){var j=ASN1HEX;var h=j.getV;if(i===undefined){i=0}if(d.substr(i,2)!==\"30\"){throw\"malformed attribute type and value\"}var g=j.getChildIdx(d,i);if(g.length!==2||d.substr(g[0],2)!==\"06\"){\"malformed attribute type and value\"}var b=h(d,g[0]);var f=KJUR.asn1.ASN1Util.oidHexToInt(b);var e=KJUR.asn1.x509.OID.oid2atype(f);var a=h(d,g[1]);var c=hextorstr(a);return e+\"=\"+c};X509.getPublicKeyFromCertHex=function(b){var a=new X509();a.readCertHex(b);return a.getPublicKey()};X509.getPublicKeyFromCertPEM=function(b){var a=new X509();a.readCertPEM(b);return a.getPublicKey()};X509.getPublicKeyInfoPropOfCertPEM=function(c){var e=ASN1HEX;var g=e.getVbyList;var b={};var a,f,d;b.algparam=null;a=new X509();a.readCertPEM(c);f=a.getPublicKeyHex();b.keyhex=g(f,0,[1],\"03\").substr(2);b.algoid=g(f,0,[0,0],\"06\");if(b.algoid===\"2a8648ce3d0201\"){b.algparam=g(f,0,[0,1],\"06\")}return b};X509.KEYUSAGE_NAME=[\"digitalSignature\",\"nonRepudiation\",\"keyEncipherment\",\"dataEncipherment\",\"keyAgreement\",\"keyCertSign\",\"cRLSign\",\"encipherOnly\",\"decipherOnly\"];\nif(typeof KJUR==\"undefined\"||!KJUR){KJUR={}}if(typeof KJUR.jws==\"undefined\"||!KJUR.jws){KJUR.jws={}}KJUR.jws.JWS=function(){var b=KJUR,a=b.jws.JWS,c=a.isSafeJSONString;this.parseJWS=function(g,j){if((this.parsedJWS!==undefined)&&(j||(this.parsedJWS.sigvalH!==undefined))){return}var i=g.match(/^([^.]+)\\.([^.]+)\\.([^.]+)$/);if(i==null){throw\"JWS signature is not a form of 'Head.Payload.SigValue'.\"}var k=i[1];var e=i[2];var l=i[3];var n=k+\".\"+e;this.parsedJWS={};this.parsedJWS.headB64U=k;this.parsedJWS.payloadB64U=e;this.parsedJWS.sigvalB64U=l;this.parsedJWS.si=n;if(!j){var h=b64utohex(l);var f=parseBigInt(h,16);this.parsedJWS.sigvalH=h;this.parsedJWS.sigvalBI=f}var d=b64utoutf8(k);var m=b64utoutf8(e);this.parsedJWS.headS=d;this.parsedJWS.payloadS=m;if(!c(d,this.parsedJWS,\"headP\")){throw\"malformed JSON string for JWS Head: \"+d}}};KJUR.jws.JWS.sign=function(i,v,y,z,a){var w=KJUR,m=w.jws,q=m.JWS,g=q.readSafeJSONString,p=q.isSafeJSONString,d=w.crypto,k=d.ECDSA,o=d.Mac,c=d.Signature,t=JSON;var s,j,n;if(typeof v!=\"string\"&&typeof v!=\"object\"){throw\"spHeader must be JSON string or object: \"+v}if(typeof v==\"object\"){j=v;s=t.stringify(j)}if(typeof v==\"string\"){s=v;if(!p(s)){throw\"JWS Head is not safe JSON string: \"+s}j=g(s)}n=y;if(typeof y==\"object\"){n=t.stringify(y)}if((i==\"\"||i==null)&&j.alg!==undefined){i=j.alg}if((i!=\"\"&&i!=null)&&j.alg===undefined){j.alg=i;s=t.stringify(j)}if(i!==j.alg){throw\"alg and sHeader.alg doesn't match: \"+i+\"!=\"+j.alg}var r=null;if(q.jwsalg2sigalg[i]===undefined){throw\"unsupported alg name: \"+i}else{r=q.jwsalg2sigalg[i]}var e=utf8tob64u(s);var l=utf8tob64u(n);var b=e+\".\"+l;var x=\"\";if(r.substr(0,4)==\"Hmac\"){if(z===undefined){throw\"mac key shall be specified for HS* alg\"}var h=new o({alg:r,prov:\"cryptojs\",pass:z});h.updateString(b);x=h.doFinal()}else{if(r.indexOf(\"withECDSA\")!=-1){var f=new c({alg:r});f.init(z,a);f.updateString(b);hASN1Sig=f.sign();x=KJUR.crypto.ECDSA.asn1SigToConcatSig(hASN1Sig)}else{if(r!=\"none\"){var f=new c({alg:r});f.init(z,a);f.updateString(b);x=f.sign()}}}var u=hextob64u(x);return b+\".\"+u};KJUR.jws.JWS.verify=function(w,B,n){var x=KJUR,q=x.jws,t=q.JWS,i=t.readSafeJSONString,e=x.crypto,p=e.ECDSA,s=e.Mac,d=e.Signature,m;if(typeof RSAKey!==undefined){m=RSAKey}var y=w.split(\".\");if(y.length!==3){return false}var f=y[0];var r=y[1];var c=f+\".\"+r;var A=b64utohex(y[2]);var l=i(b64utoutf8(y[0]));var k=null;var z=null;if(l.alg===undefined){throw\"algorithm not specified in header\"}else{k=l.alg;z=k.substr(0,2)}if(n!=null&&Object.prototype.toString.call(n)===\"[object Array]\"&&n.length>0){var b=\":\"+n.join(\":\")+\":\";if(b.indexOf(\":\"+k+\":\")==-1){throw\"algorithm '\"+k+\"' not accepted in the list\"}}if(k!=\"none\"&&B===null){throw\"key shall be specified to verify.\"}if(typeof B==\"string\"&&B.indexOf(\"-----BEGIN \")!=-1){B=KEYUTIL.getKey(B)}if(z==\"RS\"||z==\"PS\"){if(!(B instanceof m)){throw\"key shall be a RSAKey obj for RS* and PS* algs\"}}if(z==\"ES\"){if(!(B instanceof p)){throw\"key shall be a ECDSA obj for ES* algs\"}}if(k==\"none\"){}var u=null;if(t.jwsalg2sigalg[l.alg]===undefined){throw\"unsupported alg name: \"+k}else{u=t.jwsalg2sigalg[k]}if(u==\"none\"){throw\"not supported\"}else{if(u.substr(0,4)==\"Hmac\"){var o=null;if(B===undefined){throw\"hexadecimal key shall be specified for HMAC\"}var j=new s({alg:u,pass:B});j.updateString(c);o=j.doFinal();return A==o}else{if(u.indexOf(\"withECDSA\")!=-1){var h=null;try{h=p.concatSigToASN1Sig(A)}catch(v){return false}var g=new d({alg:u});g.init(B);g.updateString(c);return g.verify(h)}else{var g=new d({alg:u});g.init(B);g.updateString(c);return g.verify(A)}}}};KJUR.jws.JWS.parse=function(g){var c=g.split(\".\");var b={};var f,e,d;if(c.length!=2&&c.length!=3){throw\"malformed sJWS: wrong number of '.' splitted elements\"}f=c[0];e=c[1];if(c.length==3){d=c[2]}b.headerObj=KJUR.jws.JWS.readSafeJSONString(b64utoutf8(f));b.payloadObj=KJUR.jws.JWS.readSafeJSONString(b64utoutf8(e));b.headerPP=JSON.stringify(b.headerObj,null,\"  \");if(b.payloadObj==null){b.payloadPP=b64utoutf8(e)}else{b.payloadPP=JSON.stringify(b.payloadObj,null,\"  \")}if(d!==undefined){b.sigHex=b64utohex(d)}return b};KJUR.jws.JWS.verifyJWT=function(e,l,r){var d=KJUR,j=d.jws,o=j.JWS,n=o.readSafeJSONString,p=o.inArray,f=o.includedArray;var k=e.split(\".\");var c=k[0];var i=k[1];var q=c+\".\"+i;var m=b64utohex(k[2]);var h=n(b64utoutf8(c));var g=n(b64utoutf8(i));if(h.alg===undefined){return false}if(r.alg===undefined){throw\"acceptField.alg shall be specified\"}if(!p(h.alg,r.alg)){return false}if(g.iss!==undefined&&typeof r.iss===\"object\"){if(!p(g.iss,r.iss)){return false}}if(g.sub!==undefined&&typeof r.sub===\"object\"){if(!p(g.sub,r.sub)){return false}}if(g.aud!==undefined&&typeof r.aud===\"object\"){if(typeof g.aud==\"string\"){if(!p(g.aud,r.aud)){return false}}else{if(typeof g.aud==\"object\"){if(!f(g.aud,r.aud)){return false}}}}var b=j.IntDate.getNow();if(r.verifyAt!==undefined&&typeof r.verifyAt===\"number\"){b=r.verifyAt}if(r.gracePeriod===undefined||typeof r.gracePeriod!==\"number\"){r.gracePeriod=0}if(g.exp!==undefined&&typeof g.exp==\"number\"){if(g.exp+r.gracePeriod<b){return false}}if(g.nbf!==undefined&&typeof g.nbf==\"number\"){if(b<g.nbf-r.gracePeriod){return false}}if(g.iat!==undefined&&typeof g.iat==\"number\"){if(b<g.iat-r.gracePeriod){return false}}if(g.jti!==undefined&&r.jti!==undefined){if(g.jti!==r.jti){return false}}if(!o.verify(e,l,r.alg)){return false}return true};KJUR.jws.JWS.includedArray=function(b,a){var c=KJUR.jws.JWS.inArray;if(b===null){return false}if(typeof b!==\"object\"){return false}if(typeof b.length!==\"number\"){return false}for(var d=0;d<b.length;d++){if(!c(b[d],a)){return false}}return true};KJUR.jws.JWS.inArray=function(d,b){if(b===null){return false}if(typeof b!==\"object\"){return false}if(typeof b.length!==\"number\"){return false}for(var c=0;c<b.length;c++){if(b[c]==d){return true}}return false};KJUR.jws.JWS.jwsalg2sigalg={HS256:\"HmacSHA256\",HS384:\"HmacSHA384\",HS512:\"HmacSHA512\",RS256:\"SHA256withRSA\",RS384:\"SHA384withRSA\",RS512:\"SHA512withRSA\",ES256:\"SHA256withECDSA\",ES384:\"SHA384withECDSA\",PS256:\"SHA256withRSAandMGF1\",PS384:\"SHA384withRSAandMGF1\",PS512:\"SHA512withRSAandMGF1\",none:\"none\",};KJUR.jws.JWS.isSafeJSONString=function(c,b,d){var e=null;try{e=jsonParse(c);if(typeof e!=\"object\"){return 0}if(e.constructor===Array){return 0}if(b){b[d]=e}return 1}catch(a){return 0}};KJUR.jws.JWS.readSafeJSONString=function(b){var c=null;try{c=jsonParse(b);if(typeof c!=\"object\"){return null}if(c.constructor===Array){return null}return c}catch(a){return null}};KJUR.jws.JWS.getEncodedSignatureValueFromJWS=function(b){var a=b.match(/^[^.]+\\.[^.]+\\.([^.]+)$/);if(a==null){throw\"JWS signature is not a form of 'Head.Payload.SigValue'.\"}return a[1]};KJUR.jws.JWS.getJWKthumbprint=function(d){if(d.kty!==\"RSA\"&&d.kty!==\"EC\"&&d.kty!==\"oct\"){throw\"unsupported algorithm for JWK Thumprint\"}var a=\"{\";if(d.kty===\"RSA\"){if(typeof d.n!=\"string\"||typeof d.e!=\"string\"){throw\"wrong n and e value for RSA key\"}a+='\"e\":\"'+d.e+'\",';a+='\"kty\":\"'+d.kty+'\",';a+='\"n\":\"'+d.n+'\"}'}else{if(d.kty===\"EC\"){if(typeof d.crv!=\"string\"||typeof d.x!=\"string\"||typeof d.y!=\"string\"){throw\"wrong crv, x and y value for EC key\"}a+='\"crv\":\"'+d.crv+'\",';a+='\"kty\":\"'+d.kty+'\",';a+='\"x\":\"'+d.x+'\",';a+='\"y\":\"'+d.y+'\"}'}else{if(d.kty===\"oct\"){if(typeof d.k!=\"string\"){throw\"wrong k value for oct(symmetric) key\"}a+='\"kty\":\"'+d.kty+'\",';a+='\"k\":\"'+d.k+'\"}'}}}var b=rstrtohex(a);var c=KJUR.crypto.Util.hashHex(b,\"sha256\");var e=hextob64u(c);return e};KJUR.jws.IntDate={};KJUR.jws.IntDate.get=function(c){var b=KJUR.jws.IntDate,d=b.getNow,a=b.getZulu;if(c==\"now\"){return d()}else{if(c==\"now + 1hour\"){return d()+60*60}else{if(c==\"now + 1day\"){return d()+60*60*24}else{if(c==\"now + 1month\"){return d()+60*60*24*30}else{if(c==\"now + 1year\"){return d()+60*60*24*365}else{if(c.match(/Z$/)){return a(c)}else{if(c.match(/^[0-9]+$/)){return parseInt(c)}}}}}}}throw\"unsupported format: \"+c};KJUR.jws.IntDate.getZulu=function(a){return zulutosec(a)};KJUR.jws.IntDate.getNow=function(){var a=~~(new Date()/1000);return a};KJUR.jws.IntDate.intDate2UTCString=function(a){var b=new Date(a*1000);return b.toUTCString()};KJUR.jws.IntDate.intDate2Zulu=function(e){var i=new Date(e*1000),h=(\"0000\"+i.getUTCFullYear()).slice(-4),g=(\"00\"+(i.getUTCMonth()+1)).slice(-2),b=(\"00\"+i.getUTCDate()).slice(-2),a=(\"00\"+i.getUTCHours()).slice(-2),c=(\"00\"+i.getUTCMinutes()).slice(-2),f=(\"00\"+i.getUTCSeconds()).slice(-2);return h+g+b+a+c+f+\"Z\"};\nexport { SecureRandom };\r\nexport { rng_seed_time };\r\n\r\nexport { BigInteger };\r\nexport { RSAKey };\r\nexport const { EDSA } = KJUR.crypto;\r\nexport const { DSA } = KJUR.crypto;\r\nexport const { Signature } = KJUR.crypto;\r\nexport const { MessageDigest } =  KJUR.crypto;\r\nexport const { Mac } = KJUR.crypto;\r\nexport const { Cipher } =  KJUR.crypto;\r\nexport { KEYUTIL };\r\nexport { ASN1HEX };\r\nexport { X509 };\r\nexport { CryptoJS };\r\n\r\n// ext/base64.js\r\nexport { b64tohex };\r\nexport { b64toBA };\r\n\r\n// base64x.js\r\nexport { stoBA };\r\nexport { BAtos };\r\nexport { BAtohex };\r\nexport { stohex };\r\nexport { stob64 };\r\nexport { stob64u };\r\nexport { b64utos };\r\nexport { b64tob64u };\r\nexport { b64utob64 };\r\nexport { hex2b64 };\r\nexport { hextob64u };\r\nexport { b64utohex };\r\nexport { utf8tob64u };\r\nexport { b64utoutf8 };\r\nexport { utf8tob64 };\r\nexport { b64toutf8 };\r\nexport { utf8tohex };\r\nexport { hextoutf8 };\r\nexport { hextorstr };\r\nexport { rstrtohex };\r\nexport { hextob64 };\r\nexport { hextob64nl };\r\nexport { b64nltohex };\r\nexport { hextopem };\r\nexport { pemtohex };\r\nexport { hextoArrayBuffer };\r\nexport { ArrayBuffertohex };\r\nexport { zulutomsec };\r\nexport { zulutosec };\r\nexport { zulutodate };\r\nexport { datetozulu };\r\nexport { uricmptohex };\r\nexport { hextouricmp };\r\nexport { ipv6tohex };\r\nexport { hextoipv6 };\r\nexport { hextoip };\r\nexport { iptohex };\r\nexport { encodeURIComponentAll };\r\nexport { newline_toUnix };\r\nexport { newline_toDos };\r\nexport { hextoposhex };\r\nexport { intarystrtohex };\r\nexport { strdiffidx };\r\n\r\n// name spaces\r\nexport { KJUR };\r\nconst _crypto =  KJUR.crypto;\r\nexport { _crypto as crypto };\r\nexport const { asn1 } = KJUR;\r\nexport const { jws } = KJUR;\r\nexport const { lang } = KJUR;\r\n\r\n\r\n","\"use strict\";\n\nrequire(\"core-js/shim\");\n\nrequire(\"regenerator-runtime/runtime\");\n\nrequire(\"core-js/fn/regexp/escape\");\n\nif (global._babelPolyfill) {\n  throw new Error(\"only one instance of babel-polyfill is allowed\");\n}\nglobal._babelPolyfill = true;\n\nvar DEFINE_PROPERTY = \"defineProperty\";\nfunction define(O, key, value) {\n  O[key] || Object[DEFINE_PROPERTY](O, key, {\n    writable: true,\n    configurable: true,\n    value: value\n  });\n}\n\ndefine(String.prototype, \"padLeft\", \"\".padStart);\ndefine(String.prototype, \"padRight\", \"\".padEnd);\n\n\"pop,reverse,shift,keys,values,entries,indexOf,every,some,forEach,map,filter,find,findIndex,includes,join,slice,concat,push,splice,unshift,sort,lastIndexOf,reduce,reduceRight,copyWithin,fill\".split(\",\").forEach(function (key) {\n  [][key] && define(Array, key, Function.call.bind([][key]));\n});","/**\n * Copyright (c) 2014, Facebook, Inc.\n * All rights reserved.\n *\n * This source code is licensed under the BSD-style license found in the\n * https://raw.github.com/facebook/regenerator/master/LICENSE file. An\n * additional grant of patent rights can be found in the PATENTS file in\n * the same directory.\n */\n\n!(function(global) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  var inModule = typeof module === \"object\";\n  var runtime = global.regeneratorRuntime;\n  if (runtime) {\n    if (inModule) {\n      // If regeneratorRuntime is defined globally and we're in a module,\n      // make the exports object identical to regeneratorRuntime.\n      module.exports = runtime;\n    }\n    // Don't bother evaluating the rest of this file if the runtime was\n    // already defined globally.\n    return;\n  }\n\n  // Define the runtime globally (as expected by generated code) as either\n  // module.exports (if we're in a module) or a new, empty object.\n  runtime = global.regeneratorRuntime = inModule ? module.exports : {};\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  runtime.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunctionPrototype[toStringTagSymbol] =\n    GeneratorFunction.displayName = \"GeneratorFunction\";\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      prototype[method] = function(arg) {\n        return this._invoke(method, arg);\n      };\n    });\n  }\n\n  runtime.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  runtime.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      if (!(toStringTagSymbol in genFun)) {\n        genFun[toStringTagSymbol] = \"GeneratorFunction\";\n      }\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  runtime.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return Promise.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return Promise.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration. If the Promise is rejected, however, the\n          // result for this iteration will be rejected with the same\n          // reason. Note that rejections of yielded Promises are not\n          // thrown back into the generator function, as is the case\n          // when an awaited Promise is rejected. This difference in\n          // behavior between yield and await is important, because it\n          // allows the consumer to decide what to do with the yielded\n          // rejection (swallow it and continue, manually .throw it back\n          // into the generator, abandon iteration, whatever). With\n          // await, by contrast, there is no opportunity to examine the\n          // rejection reason outside the generator function, so the\n          // only option is to throw it from the await expression, and\n          // let the generator function handle the exception.\n          result.value = unwrapped;\n          resolve(result);\n        }, reject);\n      }\n    }\n\n    if (typeof global.process === \"object\" && global.process.domain) {\n      invoke = global.process.domain.bind(invoke);\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new Promise(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  runtime.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  runtime.async = function(innerFn, outerFn, self, tryLocsList) {\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList)\n    );\n\n    return runtime.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        if (delegate.iterator.return) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  Gp[toStringTagSymbol] = \"Generator\";\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  runtime.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  runtime.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n})(\n  // Among the various tricks for obtaining a reference to the global\n  // object, this seems to be the most reliable technique that does not\n  // use indirect eval (which violates Content Security Policy).\n  typeof global === \"object\" ? global :\n  typeof window === \"object\" ? window :\n  typeof self === \"object\" ? self : this\n);\n","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n","require('../../modules/core.regexp.escape');\nmodule.exports = require('../../modules/_core').RegExp.escape;\n","module.exports = function (it) {\n  if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n  return it;\n};\n","var cof = require('./_cof');\nmodule.exports = function (it, msg) {\n  if (typeof it != 'number' && cof(it) != 'Number') throw TypeError(msg);\n  return +it;\n};\n","// 22.1.3.31 Array.prototype[@@unscopables]\nvar UNSCOPABLES = require('./_wks')('unscopables');\nvar ArrayProto = Array.prototype;\nif (ArrayProto[UNSCOPABLES] == undefined) require('./_hide')(ArrayProto, UNSCOPABLES, {});\nmodule.exports = function (key) {\n  ArrayProto[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar at = require('./_string-at')(true);\n\n // `AdvanceStringIndex` abstract operation\n// https://tc39.github.io/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n  return index + (unicode ? at(S, index).length : 1);\n};\n","module.exports = function (it, Constructor, name, forbiddenField) {\n  if (!(it instanceof Constructor) || (forbiddenField !== undefined && forbiddenField in it)) {\n    throw TypeError(name + ': incorrect invocation!');\n  } return it;\n};\n","var isObject = require('./_is-object');\nmodule.exports = function (it) {\n  if (!isObject(it)) throw TypeError(it + ' is not an object!');\n  return it;\n};\n","// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)\n'use strict';\nvar toObject = require('./_to-object');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\n\nmodule.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {\n  var O = toObject(this);\n  var len = toLength(O.length);\n  var to = toAbsoluteIndex(target, len);\n  var from = toAbsoluteIndex(start, len);\n  var end = arguments.length > 2 ? arguments[2] : undefined;\n  var count = Math.min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);\n  var inc = 1;\n  if (from < to && to < from + count) {\n    inc = -1;\n    from += count - 1;\n    to += count - 1;\n  }\n  while (count-- > 0) {\n    if (from in O) O[to] = O[from];\n    else delete O[to];\n    to += inc;\n    from += inc;\n  } return O;\n};\n","// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)\n'use strict';\nvar toObject = require('./_to-object');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n  var O = toObject(this);\n  var length = toLength(O.length);\n  var aLen = arguments.length;\n  var index = toAbsoluteIndex(aLen > 1 ? arguments[1] : undefined, length);\n  var end = aLen > 2 ? arguments[2] : undefined;\n  var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n  while (endPos > index) O[index++] = value;\n  return O;\n};\n","var forOf = require('./_for-of');\n\nmodule.exports = function (iter, ITERATOR) {\n  var result = [];\n  forOf(iter, false, result.push, result, ITERATOR);\n  return result;\n};\n","// false -> Array#indexOf\n// true  -> Array#includes\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nmodule.exports = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) if (IS_INCLUDES || index in O) {\n      if (O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n","// 0 -> Array#forEach\n// 1 -> Array#map\n// 2 -> Array#filter\n// 3 -> Array#some\n// 4 -> Array#every\n// 5 -> Array#find\n// 6 -> Array#findIndex\nvar ctx = require('./_ctx');\nvar IObject = require('./_iobject');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar asc = require('./_array-species-create');\nmodule.exports = function (TYPE, $create) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  var create = $create || asc;\n  return function ($this, callbackfn, that) {\n    var O = toObject($this);\n    var self = IObject(O);\n    var f = ctx(callbackfn, that, 3);\n    var length = toLength(self.length);\n    var index = 0;\n    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;\n    var val, res;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      val = self[index];\n      res = f(val, index, O);\n      if (TYPE) {\n        if (IS_MAP) result[index] = res;   // map\n        else if (res) switch (TYPE) {\n          case 3: return true;             // some\n          case 5: return val;              // find\n          case 6: return index;            // findIndex\n          case 2: result.push(val);        // filter\n        } else if (IS_EVERY) return false; // every\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;\n  };\n};\n","var aFunction = require('./_a-function');\nvar toObject = require('./_to-object');\nvar IObject = require('./_iobject');\nvar toLength = require('./_to-length');\n\nmodule.exports = function (that, callbackfn, aLen, memo, isRight) {\n  aFunction(callbackfn);\n  var O = toObject(that);\n  var self = IObject(O);\n  var length = toLength(O.length);\n  var index = isRight ? length - 1 : 0;\n  var i = isRight ? -1 : 1;\n  if (aLen < 2) for (;;) {\n    if (index in self) {\n      memo = self[index];\n      index += i;\n      break;\n    }\n    index += i;\n    if (isRight ? index < 0 : length <= index) {\n      throw TypeError('Reduce of empty array with no initial value');\n    }\n  }\n  for (;isRight ? index >= 0 : length > index; index += i) if (index in self) {\n    memo = callbackfn(memo, self[index], index, O);\n  }\n  return memo;\n};\n","var isObject = require('./_is-object');\nvar isArray = require('./_is-array');\nvar SPECIES = require('./_wks')('species');\n\nmodule.exports = function (original) {\n  var C;\n  if (isArray(original)) {\n    C = original.constructor;\n    // cross-realm fallback\n    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;\n    if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return C === undefined ? Array : C;\n};\n","// 9.4.2.3 ArraySpeciesCreate(originalArray, length)\nvar speciesConstructor = require('./_array-species-constructor');\n\nmodule.exports = function (original, length) {\n  return new (speciesConstructor(original))(length);\n};\n","'use strict';\nvar aFunction = require('./_a-function');\nvar isObject = require('./_is-object');\nvar invoke = require('./_invoke');\nvar arraySlice = [].slice;\nvar factories = {};\n\nvar construct = function (F, len, args) {\n  if (!(len in factories)) {\n    for (var n = [], i = 0; i < len; i++) n[i] = 'a[' + i + ']';\n    // eslint-disable-next-line no-new-func\n    factories[len] = Function('F,a', 'return new F(' + n.join(',') + ')');\n  } return factories[len](F, args);\n};\n\nmodule.exports = Function.bind || function bind(that /* , ...args */) {\n  var fn = aFunction(this);\n  var partArgs = arraySlice.call(arguments, 1);\n  var bound = function (/* args... */) {\n    var args = partArgs.concat(arraySlice.call(arguments));\n    return this instanceof bound ? construct(fn, args.length, args) : invoke(fn, args, that);\n  };\n  if (isObject(fn.prototype)) bound.prototype = fn.prototype;\n  return bound;\n};\n","// getting tag from 19.1.3.6 Object.prototype.toString()\nvar cof = require('./_cof');\nvar TAG = require('./_wks')('toStringTag');\n// ES3 wrong here\nvar ARG = cof(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (e) { /* empty */ }\n};\n\nmodule.exports = function (it) {\n  var O, T, B;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T\n    // builtinTag case\n    : ARG ? cof(O)\n    // ES3 arguments fallback\n    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;\n};\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","'use strict';\nvar dP = require('./_object-dp').f;\nvar create = require('./_object-create');\nvar redefineAll = require('./_redefine-all');\nvar ctx = require('./_ctx');\nvar anInstance = require('./_an-instance');\nvar forOf = require('./_for-of');\nvar $iterDefine = require('./_iter-define');\nvar step = require('./_iter-step');\nvar setSpecies = require('./_set-species');\nvar DESCRIPTORS = require('./_descriptors');\nvar fastKey = require('./_meta').fastKey;\nvar validate = require('./_validate-collection');\nvar SIZE = DESCRIPTORS ? '_s' : 'size';\n\nvar getEntry = function (that, key) {\n  // fast case\n  var index = fastKey(key);\n  var entry;\n  if (index !== 'F') return that._i[index];\n  // frozen object case\n  for (entry = that._f; entry; entry = entry.n) {\n    if (entry.k == key) return entry;\n  }\n};\n\nmodule.exports = {\n  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, NAME, '_i');\n      that._t = NAME;         // collection type\n      that._i = create(null); // index\n      that._f = undefined;    // first entry\n      that._l = undefined;    // last entry\n      that[SIZE] = 0;         // size\n      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);\n    });\n    redefineAll(C.prototype, {\n      // 23.1.3.1 Map.prototype.clear()\n      // 23.2.3.2 Set.prototype.clear()\n      clear: function clear() {\n        for (var that = validate(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {\n          entry.r = true;\n          if (entry.p) entry.p = entry.p.n = undefined;\n          delete data[entry.i];\n        }\n        that._f = that._l = undefined;\n        that[SIZE] = 0;\n      },\n      // 23.1.3.3 Map.prototype.delete(key)\n      // 23.2.3.4 Set.prototype.delete(value)\n      'delete': function (key) {\n        var that = validate(this, NAME);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.n;\n          var prev = entry.p;\n          delete that._i[entry.i];\n          entry.r = true;\n          if (prev) prev.n = next;\n          if (next) next.p = prev;\n          if (that._f == entry) that._f = next;\n          if (that._l == entry) that._l = prev;\n          that[SIZE]--;\n        } return !!entry;\n      },\n      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        validate(this, NAME);\n        var f = ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);\n        var entry;\n        while (entry = entry ? entry.n : this._f) {\n          f(entry.v, entry.k, this);\n          // revert to the last existing entry\n          while (entry && entry.r) entry = entry.p;\n        }\n      },\n      // 23.1.3.7 Map.prototype.has(key)\n      // 23.2.3.7 Set.prototype.has(value)\n      has: function has(key) {\n        return !!getEntry(validate(this, NAME), key);\n      }\n    });\n    if (DESCRIPTORS) dP(C.prototype, 'size', {\n      get: function () {\n        return validate(this, NAME)[SIZE];\n      }\n    });\n    return C;\n  },\n  def: function (that, key, value) {\n    var entry = getEntry(that, key);\n    var prev, index;\n    // change existing entry\n    if (entry) {\n      entry.v = value;\n    // create new entry\n    } else {\n      that._l = entry = {\n        i: index = fastKey(key, true), // <- index\n        k: key,                        // <- key\n        v: value,                      // <- value\n        p: prev = that._l,             // <- previous entry\n        n: undefined,                  // <- next entry\n        r: false                       // <- removed\n      };\n      if (!that._f) that._f = entry;\n      if (prev) prev.n = entry;\n      that[SIZE]++;\n      // add to index\n      if (index !== 'F') that._i[index] = entry;\n    } return that;\n  },\n  getEntry: getEntry,\n  setStrong: function (C, NAME, IS_MAP) {\n    // add .keys, .values, .entries, [@@iterator]\n    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n    $iterDefine(C, NAME, function (iterated, kind) {\n      this._t = validate(iterated, NAME); // target\n      this._k = kind;                     // kind\n      this._l = undefined;                // previous\n    }, function () {\n      var that = this;\n      var kind = that._k;\n      var entry = that._l;\n      // revert to the last existing entry\n      while (entry && entry.r) entry = entry.p;\n      // get next entry\n      if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {\n        // or finish the iteration\n        that._t = undefined;\n        return step(1);\n      }\n      // return step by kind\n      if (kind == 'keys') return step(0, entry.k);\n      if (kind == 'values') return step(0, entry.v);\n      return step(0, [entry.k, entry.v]);\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // add [@@species], 23.1.2.2, 23.2.2.2\n    setSpecies(NAME);\n  }\n};\n","// https://github.com/DavidBruant/Map-Set.prototype.toJSON\nvar classof = require('./_classof');\nvar from = require('./_array-from-iterable');\nmodule.exports = function (NAME) {\n  return function toJSON() {\n    if (classof(this) != NAME) throw TypeError(NAME + \"#toJSON isn't generic\");\n    return from(this);\n  };\n};\n","'use strict';\nvar redefineAll = require('./_redefine-all');\nvar getWeak = require('./_meta').getWeak;\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar anInstance = require('./_an-instance');\nvar forOf = require('./_for-of');\nvar createArrayMethod = require('./_array-methods');\nvar $has = require('./_has');\nvar validate = require('./_validate-collection');\nvar arrayFind = createArrayMethod(5);\nvar arrayFindIndex = createArrayMethod(6);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (that) {\n  return that._l || (that._l = new UncaughtFrozenStore());\n};\nvar UncaughtFrozenStore = function () {\n  this.a = [];\n};\nvar findUncaughtFrozen = function (store, key) {\n  return arrayFind(store.a, function (it) {\n    return it[0] === key;\n  });\n};\nUncaughtFrozenStore.prototype = {\n  get: function (key) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) return entry[1];\n  },\n  has: function (key) {\n    return !!findUncaughtFrozen(this, key);\n  },\n  set: function (key, value) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) entry[1] = value;\n    else this.a.push([key, value]);\n  },\n  'delete': function (key) {\n    var index = arrayFindIndex(this.a, function (it) {\n      return it[0] === key;\n    });\n    if (~index) this.a.splice(index, 1);\n    return !!~index;\n  }\n};\n\nmodule.exports = {\n  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, NAME, '_i');\n      that._t = NAME;      // collection type\n      that._i = id++;      // collection id\n      that._l = undefined; // leak store for uncaught frozen objects\n      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);\n    });\n    redefineAll(C.prototype, {\n      // 23.3.3.2 WeakMap.prototype.delete(key)\n      // 23.4.3.3 WeakSet.prototype.delete(value)\n      'delete': function (key) {\n        if (!isObject(key)) return false;\n        var data = getWeak(key);\n        if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);\n        return data && $has(data, this._i) && delete data[this._i];\n      },\n      // 23.3.3.4 WeakMap.prototype.has(key)\n      // 23.4.3.4 WeakSet.prototype.has(value)\n      has: function has(key) {\n        if (!isObject(key)) return false;\n        var data = getWeak(key);\n        if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);\n        return data && $has(data, this._i);\n      }\n    });\n    return C;\n  },\n  def: function (that, key, value) {\n    var data = getWeak(anObject(key), true);\n    if (data === true) uncaughtFrozenStore(that).set(key, value);\n    else data[that._i] = value;\n    return that;\n  },\n  ufstore: uncaughtFrozenStore\n};\n","'use strict';\nvar global = require('./_global');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar redefineAll = require('./_redefine-all');\nvar meta = require('./_meta');\nvar forOf = require('./_for-of');\nvar anInstance = require('./_an-instance');\nvar isObject = require('./_is-object');\nvar fails = require('./_fails');\nvar $iterDetect = require('./_iter-detect');\nvar setToStringTag = require('./_set-to-string-tag');\nvar inheritIfRequired = require('./_inherit-if-required');\n\nmodule.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {\n  var Base = global[NAME];\n  var C = Base;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var proto = C && C.prototype;\n  var O = {};\n  var fixMethod = function (KEY) {\n    var fn = proto[KEY];\n    redefine(proto, KEY,\n      KEY == 'delete' ? function (a) {\n        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'has' ? function has(a) {\n        return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'get' ? function get(a) {\n        return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);\n      } : KEY == 'add' ? function add(a) { fn.call(this, a === 0 ? 0 : a); return this; }\n        : function set(a, b) { fn.call(this, a === 0 ? 0 : a, b); return this; }\n    );\n  };\n  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {\n    new C().entries().next();\n  }))) {\n    // create collection constructor\n    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);\n    redefineAll(C.prototype, methods);\n    meta.NEED = true;\n  } else {\n    var instance = new C();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~  Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    var ACCEPT_ITERABLES = $iterDetect(function (iter) { new C(iter); }); // eslint-disable-line no-new\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new C();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n    if (!ACCEPT_ITERABLES) {\n      C = wrapper(function (target, iterable) {\n        anInstance(target, C, NAME);\n        var that = inheritIfRequired(new Base(), target, C);\n        if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);\n        return that;\n      });\n      C.prototype = proto;\n      proto.constructor = C;\n    }\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n    // weak collections should not contains .clear method\n    if (IS_WEAK && proto.clear) delete proto.clear;\n  }\n\n  setToStringTag(C, NAME);\n\n  O[NAME] = C;\n  $export($export.G + $export.W + $export.F * (C != Base), O);\n\n  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);\n\n  return C;\n};\n","var core = module.exports = { version: '2.6.4' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n","'use strict';\nvar $defineProperty = require('./_object-dp');\nvar createDesc = require('./_property-desc');\n\nmodule.exports = function (object, index, value) {\n  if (index in object) $defineProperty.f(object, index, createDesc(0, value));\n  else object[index] = value;\n};\n","// optional / simple context binding\nvar aFunction = require('./_a-function');\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","'use strict';\n// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()\nvar fails = require('./_fails');\nvar getTime = Date.prototype.getTime;\nvar $toISOString = Date.prototype.toISOString;\n\nvar lz = function (num) {\n  return num > 9 ? num : '0' + num;\n};\n\n// PhantomJS / old WebKit has a broken implementations\nmodule.exports = (fails(function () {\n  return $toISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z';\n}) || !fails(function () {\n  $toISOString.call(new Date(NaN));\n})) ? function toISOString() {\n  if (!isFinite(getTime.call(this))) throw RangeError('Invalid time value');\n  var d = this;\n  var y = d.getUTCFullYear();\n  var m = d.getUTCMilliseconds();\n  var s = y < 0 ? '-' : y > 9999 ? '+' : '';\n  return s + ('00000' + Math.abs(y)).slice(s ? -6 : -4) +\n    '-' + lz(d.getUTCMonth() + 1) + '-' + lz(d.getUTCDate()) +\n    'T' + lz(d.getUTCHours()) + ':' + lz(d.getUTCMinutes()) +\n    ':' + lz(d.getUTCSeconds()) + '.' + (m > 99 ? m : '0' + lz(m)) + 'Z';\n} : $toISOString;\n","'use strict';\nvar anObject = require('./_an-object');\nvar toPrimitive = require('./_to-primitive');\nvar NUMBER = 'number';\n\nmodule.exports = function (hint) {\n  if (hint !== 'string' && hint !== NUMBER && hint !== 'default') throw TypeError('Incorrect hint');\n  return toPrimitive(anObject(this), hint != NUMBER);\n};\n","// 7.2.1 RequireObjectCoercible(argument)\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on  \" + it);\n  return it;\n};\n","// Thank's IE8 for his funny defineProperty\nmodule.exports = !require('./_fails')(function () {\n  return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n","var isObject = require('./_is-object');\nvar document = require('./_global').document;\n// typeof document.createElement is 'object' in old IE\nvar is = isObject(document) && isObject(document.createElement);\nmodule.exports = function (it) {\n  return is ? document.createElement(it) : {};\n};\n","// IE 8- don't enum bug keys\nmodule.exports = (\n  'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'\n).split(',');\n","// all enumerable object keys, includes symbols\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nmodule.exports = function (it) {\n  var result = getKeys(it);\n  var getSymbols = gOPS.f;\n  if (getSymbols) {\n    var symbols = getSymbols(it);\n    var isEnum = pIE.f;\n    var i = 0;\n    var key;\n    while (symbols.length > i) if (isEnum.call(it, key = symbols[i++])) result.push(key);\n  } return result;\n};\n","var global = require('./_global');\nvar core = require('./_core');\nvar hide = require('./_hide');\nvar redefine = require('./_redefine');\nvar ctx = require('./_ctx');\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n  var IS_FORCED = type & $export.F;\n  var IS_GLOBAL = type & $export.G;\n  var IS_STATIC = type & $export.S;\n  var IS_PROTO = type & $export.P;\n  var IS_BIND = type & $export.B;\n  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];\n  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});\n  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});\n  var key, own, out, exp;\n  if (IS_GLOBAL) source = name;\n  for (key in source) {\n    // contains in native\n    own = !IS_FORCED && target && target[key] !== undefined;\n    // export native or passed\n    out = (own ? target : source)[key];\n    // bind timers to global for call from export context\n    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;\n    // extend global\n    if (target) redefine(target, key, out, type & $export.U);\n    // export\n    if (exports[key] != out) hide(exports, key, exp);\n    if (IS_PROTO && expProto[key] != out) expProto[key] = out;\n  }\n};\nglobal.core = core;\n// type bitmap\n$export.F = 1;   // forced\n$export.G = 2;   // global\n$export.S = 4;   // static\n$export.P = 8;   // proto\n$export.B = 16;  // bind\n$export.W = 32;  // wrap\n$export.U = 64;  // safe\n$export.R = 128; // real proto method for `library`\nmodule.exports = $export;\n","var MATCH = require('./_wks')('match');\nmodule.exports = function (KEY) {\n  var re = /./;\n  try {\n    '/./'[KEY](re);\n  } catch (e) {\n    try {\n      re[MATCH] = false;\n      return !'/./'[KEY](re);\n    } catch (f) { /* empty */ }\n  } return true;\n};\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (e) {\n    return true;\n  }\n};\n","'use strict';\nrequire('./es6.regexp.exec');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar fails = require('./_fails');\nvar defined = require('./_defined');\nvar wks = require('./_wks');\nvar regexpExec = require('./_regexp-exec');\n\nvar SPECIES = wks('species');\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n  // #replace needs built-in support for named groups.\n  // #match works fine because it just return the exec results, even if it has\n  // a \"grops\" property.\n  var re = /./;\n  re.exec = function () {\n    var result = [];\n    result.groups = { a: '7' };\n    return result;\n  };\n  return ''.replace(re, '$<a>') !== '7';\n});\n\nvar SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = (function () {\n  // Chrome 51 has a buggy \"split\" implementation when RegExp#exec !== nativeExec\n  var re = /(?:)/;\n  var originalExec = re.exec;\n  re.exec = function () { return originalExec.apply(this, arguments); };\n  var result = 'ab'.split(re);\n  return result.length === 2 && result[0] === 'a' && result[1] === 'b';\n})();\n\nmodule.exports = function (KEY, length, exec) {\n  var SYMBOL = wks(KEY);\n\n  var DELEGATES_TO_SYMBOL = !fails(function () {\n    // String methods call symbol-named RegEp methods\n    var O = {};\n    O[SYMBOL] = function () { return 7; };\n    return ''[KEY](O) != 7;\n  });\n\n  var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL ? !fails(function () {\n    // Symbol-named RegExp methods call .exec\n    var execCalled = false;\n    var re = /a/;\n    re.exec = function () { execCalled = true; return null; };\n    if (KEY === 'split') {\n      // RegExp[@@split] doesn't call the regex's exec method, but first creates\n      // a new one. We need to return the patched regex when creating the new one.\n      re.constructor = {};\n      re.constructor[SPECIES] = function () { return re; };\n    }\n    re[SYMBOL]('');\n    return !execCalled;\n  }) : undefined;\n\n  if (\n    !DELEGATES_TO_SYMBOL ||\n    !DELEGATES_TO_EXEC ||\n    (KEY === 'replace' && !REPLACE_SUPPORTS_NAMED_GROUPS) ||\n    (KEY === 'split' && !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC)\n  ) {\n    var nativeRegExpMethod = /./[SYMBOL];\n    var fns = exec(\n      defined,\n      SYMBOL,\n      ''[KEY],\n      function maybeCallNative(nativeMethod, regexp, str, arg2, forceStringMethod) {\n        if (regexp.exec === regexpExec) {\n          if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n            // The native String method already delegates to @@method (this\n            // polyfilled function), leasing to infinite recursion.\n            // We avoid it by directly calling the native @@method method.\n            return { done: true, value: nativeRegExpMethod.call(regexp, str, arg2) };\n          }\n          return { done: true, value: nativeMethod.call(str, regexp, arg2) };\n        }\n        return { done: false };\n      }\n    );\n    var strfn = fns[0];\n    var rxfn = fns[1];\n\n    redefine(String.prototype, KEY, strfn);\n    hide(RegExp.prototype, SYMBOL, length == 2\n      // 21.2.5.8 RegExp.prototype[@@replace](string, replaceValue)\n      // 21.2.5.11 RegExp.prototype[@@split](string, limit)\n      ? function (string, arg) { return rxfn.call(string, this, arg); }\n      // 21.2.5.6 RegExp.prototype[@@match](string)\n      // 21.2.5.9 RegExp.prototype[@@search](string)\n      : function (string) { return rxfn.call(string, this); }\n    );\n  }\n};\n","'use strict';\n// 21.2.5.3 get RegExp.prototype.flags\nvar anObject = require('./_an-object');\nmodule.exports = function () {\n  var that = anObject(this);\n  var result = '';\n  if (that.global) result += 'g';\n  if (that.ignoreCase) result += 'i';\n  if (that.multiline) result += 'm';\n  if (that.unicode) result += 'u';\n  if (that.sticky) result += 'y';\n  return result;\n};\n","'use strict';\n// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray\nvar isArray = require('./_is-array');\nvar isObject = require('./_is-object');\nvar toLength = require('./_to-length');\nvar ctx = require('./_ctx');\nvar IS_CONCAT_SPREADABLE = require('./_wks')('isConcatSpreadable');\n\nfunction flattenIntoArray(target, original, source, sourceLen, start, depth, mapper, thisArg) {\n  var targetIndex = start;\n  var sourceIndex = 0;\n  var mapFn = mapper ? ctx(mapper, thisArg, 3) : false;\n  var element, spreadable;\n\n  while (sourceIndex < sourceLen) {\n    if (sourceIndex in source) {\n      element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];\n\n      spreadable = false;\n      if (isObject(element)) {\n        spreadable = element[IS_CONCAT_SPREADABLE];\n        spreadable = spreadable !== undefined ? !!spreadable : isArray(element);\n      }\n\n      if (spreadable && depth > 0) {\n        targetIndex = flattenIntoArray(target, original, element, toLength(element.length), targetIndex, depth - 1) - 1;\n      } else {\n        if (targetIndex >= 0x1fffffffffffff) throw TypeError();\n        target[targetIndex] = element;\n      }\n\n      targetIndex++;\n    }\n    sourceIndex++;\n  }\n  return targetIndex;\n}\n\nmodule.exports = flattenIntoArray;\n","var ctx = require('./_ctx');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar anObject = require('./_an-object');\nvar toLength = require('./_to-length');\nvar getIterFn = require('./core.get-iterator-method');\nvar BREAK = {};\nvar RETURN = {};\nvar exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {\n  var iterFn = ITERATOR ? function () { return iterable; } : getIterFn(iterable);\n  var f = ctx(fn, that, entries ? 2 : 1);\n  var index = 0;\n  var length, step, iterator, result;\n  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');\n  // fast case for arrays with default iterator\n  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {\n    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);\n    if (result === BREAK || result === RETURN) return result;\n  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {\n    result = call(iterator, f, step.value, entries);\n    if (result === BREAK || result === RETURN) return result;\n  }\n};\nexports.BREAK = BREAK;\nexports.RETURN = RETURN;\n","module.exports = require('./_shared')('native-function-to-string', Function.toString);\n","// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n  ? window : typeof self != 'undefined' && self.Math == Math ? self\n  // eslint-disable-next-line no-new-func\n  : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n","var hasOwnProperty = {}.hasOwnProperty;\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var dP = require('./_object-dp');\nvar createDesc = require('./_property-desc');\nmodule.exports = require('./_descriptors') ? function (object, key, value) {\n  return dP.f(object, key, createDesc(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var document = require('./_global').document;\nmodule.exports = document && document.documentElement;\n","module.exports = !require('./_descriptors') && !require('./_fails')(function () {\n  return Object.defineProperty(require('./_dom-create')('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n","var isObject = require('./_is-object');\nvar setPrototypeOf = require('./_set-proto').set;\nmodule.exports = function (that, target, C) {\n  var S = target.constructor;\n  var P;\n  if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {\n    setPrototypeOf(that, P);\n  } return that;\n};\n","// fast apply, http://jsperf.lnkit.com/fast-apply/5\nmodule.exports = function (fn, args, that) {\n  var un = that === undefined;\n  switch (args.length) {\n    case 0: return un ? fn()\n                      : fn.call(that);\n    case 1: return un ? fn(args[0])\n                      : fn.call(that, args[0]);\n    case 2: return un ? fn(args[0], args[1])\n                      : fn.call(that, args[0], args[1]);\n    case 3: return un ? fn(args[0], args[1], args[2])\n                      : fn.call(that, args[0], args[1], args[2]);\n    case 4: return un ? fn(args[0], args[1], args[2], args[3])\n                      : fn.call(that, args[0], args[1], args[2], args[3]);\n  } return fn.apply(that, args);\n};\n","// fallback for non-array-like ES3 and non-enumerable old V8 strings\nvar cof = require('./_cof');\n// eslint-disable-next-line no-prototype-builtins\nmodule.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {\n  return cof(it) == 'String' ? it.split('') : Object(it);\n};\n","// check on default Array iterator\nvar Iterators = require('./_iterators');\nvar ITERATOR = require('./_wks')('iterator');\nvar ArrayProto = Array.prototype;\n\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);\n};\n","// 7.2.2 IsArray(argument)\nvar cof = require('./_cof');\nmodule.exports = Array.isArray || function isArray(arg) {\n  return cof(arg) == 'Array';\n};\n","// 20.1.2.3 Number.isInteger(number)\nvar isObject = require('./_is-object');\nvar floor = Math.floor;\nmodule.exports = function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","// 7.2.8 IsRegExp(argument)\nvar isObject = require('./_is-object');\nvar cof = require('./_cof');\nvar MATCH = require('./_wks')('match');\nmodule.exports = function (it) {\n  var isRegExp;\n  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');\n};\n","// call something on iterator step with safe closing on error\nvar anObject = require('./_an-object');\nmodule.exports = function (iterator, fn, value, entries) {\n  try {\n    return entries ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (e) {\n    var ret = iterator['return'];\n    if (ret !== undefined) anObject(ret.call(iterator));\n    throw e;\n  }\n};\n","'use strict';\nvar create = require('./_object-create');\nvar descriptor = require('./_property-desc');\nvar setToStringTag = require('./_set-to-string-tag');\nvar IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nrequire('./_hide')(IteratorPrototype, require('./_wks')('iterator'), function () { return this; });\n\nmodule.exports = function (Constructor, NAME, next) {\n  Constructor.prototype = create(IteratorPrototype, { next: descriptor(1, next) });\n  setToStringTag(Constructor, NAME + ' Iterator');\n};\n","'use strict';\nvar LIBRARY = require('./_library');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar $iterCreate = require('./_iter-create');\nvar setToStringTag = require('./_set-to-string-tag');\nvar getPrototypeOf = require('./_object-gpo');\nvar ITERATOR = require('./_wks')('iterator');\nvar BUGGY = !([].keys && 'next' in [].keys()); // Safari has buggy iterators w/o `next`\nvar FF_ITERATOR = '@@iterator';\nvar KEYS = 'keys';\nvar VALUES = 'values';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {\n  $iterCreate(Constructor, NAME, next);\n  var getMethod = function (kind) {\n    if (!BUGGY && kind in proto) return proto[kind];\n    switch (kind) {\n      case KEYS: return function keys() { return new Constructor(this, kind); };\n      case VALUES: return function values() { return new Constructor(this, kind); };\n    } return function entries() { return new Constructor(this, kind); };\n  };\n  var TAG = NAME + ' Iterator';\n  var DEF_VALUES = DEFAULT == VALUES;\n  var VALUES_BUG = false;\n  var proto = Base.prototype;\n  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];\n  var $default = $native || getMethod(DEFAULT);\n  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;\n  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;\n  var methods, key, IteratorPrototype;\n  // Fix native\n  if ($anyNative) {\n    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));\n    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {\n      // Set @@toStringTag to native iterators\n      setToStringTag(IteratorPrototype, TAG, true);\n      // fix for some old engines\n      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);\n    }\n  }\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEF_VALUES && $native && $native.name !== VALUES) {\n    VALUES_BUG = true;\n    $default = function values() { return $native.call(this); };\n  }\n  // Define iterator\n  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {\n    hide(proto, ITERATOR, $default);\n  }\n  // Plug for library\n  Iterators[NAME] = $default;\n  Iterators[TAG] = returnThis;\n  if (DEFAULT) {\n    methods = {\n      values: DEF_VALUES ? $default : getMethod(VALUES),\n      keys: IS_SET ? $default : getMethod(KEYS),\n      entries: $entries\n    };\n    if (FORCED) for (key in methods) {\n      if (!(key in proto)) redefine(proto, key, methods[key]);\n    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);\n  }\n  return methods;\n};\n","var ITERATOR = require('./_wks')('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var riter = [7][ITERATOR]();\n  riter['return'] = function () { SAFE_CLOSING = true; };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(riter, function () { throw 2; });\n} catch (e) { /* empty */ }\n\nmodule.exports = function (exec, skipClosing) {\n  if (!skipClosing && !SAFE_CLOSING) return false;\n  var safe = false;\n  try {\n    var arr = [7];\n    var iter = arr[ITERATOR]();\n    iter.next = function () { return { done: safe = true }; };\n    arr[ITERATOR] = function () { return iter; };\n    exec(arr);\n  } catch (e) { /* empty */ }\n  return safe;\n};\n","module.exports = function (done, value) {\n  return { value: value, done: !!done };\n};\n","module.exports = {};\n","module.exports = false;\n","// 20.2.2.14 Math.expm1(x)\nvar $expm1 = Math.expm1;\nmodule.exports = (!$expm1\n  // Old FF bug\n  || $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168\n  // Tor Browser bug\n  || $expm1(-2e-17) != -2e-17\n) ? function expm1(x) {\n  return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : Math.exp(x) - 1;\n} : $expm1;\n","// 20.2.2.16 Math.fround(x)\nvar sign = require('./_math-sign');\nvar pow = Math.pow;\nvar EPSILON = pow(2, -52);\nvar EPSILON32 = pow(2, -23);\nvar MAX32 = pow(2, 127) * (2 - EPSILON32);\nvar MIN32 = pow(2, -126);\n\nvar roundTiesToEven = function (n) {\n  return n + 1 / EPSILON - 1 / EPSILON;\n};\n\nmodule.exports = Math.fround || function fround(x) {\n  var $abs = Math.abs(x);\n  var $sign = sign(x);\n  var a, result;\n  if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;\n  a = (1 + EPSILON32 / EPSILON) * $abs;\n  result = a - (a - $abs);\n  // eslint-disable-next-line no-self-compare\n  if (result > MAX32 || result != result) return $sign * Infinity;\n  return $sign * result;\n};\n","// 20.2.2.20 Math.log1p(x)\nmodule.exports = Math.log1p || function log1p(x) {\n  return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : Math.log(1 + x);\n};\n","// https://rwaldron.github.io/proposal-math-extensions/\nmodule.exports = Math.scale || function scale(x, inLow, inHigh, outLow, outHigh) {\n  if (\n    arguments.length === 0\n      // eslint-disable-next-line no-self-compare\n      || x != x\n      // eslint-disable-next-line no-self-compare\n      || inLow != inLow\n      // eslint-disable-next-line no-self-compare\n      || inHigh != inHigh\n      // eslint-disable-next-line no-self-compare\n      || outLow != outLow\n      // eslint-disable-next-line no-self-compare\n      || outHigh != outHigh\n  ) return NaN;\n  if (x === Infinity || x === -Infinity) return x;\n  return (x - inLow) * (outHigh - outLow) / (inHigh - inLow) + outLow;\n};\n","// 20.2.2.28 Math.sign(x)\nmodule.exports = Math.sign || function sign(x) {\n  // eslint-disable-next-line no-self-compare\n  return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;\n};\n","var META = require('./_uid')('meta');\nvar isObject = require('./_is-object');\nvar has = require('./_has');\nvar setDesc = require('./_object-dp').f;\nvar id = 0;\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\nvar FREEZE = !require('./_fails')(function () {\n  return isExtensible(Object.preventExtensions({}));\n});\nvar setMeta = function (it) {\n  setDesc(it, META, { value: {\n    i: 'O' + ++id, // object ID\n    w: {}          // weak collections IDs\n  } });\n};\nvar fastKey = function (it, create) {\n  // return primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMeta(it);\n  // return object ID\n  } return it[META].i;\n};\nvar getWeak = function (it, create) {\n  if (!has(it, META)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMeta(it);\n  // return hash weak collections IDs\n  } return it[META].w;\n};\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);\n  return it;\n};\nvar meta = module.exports = {\n  KEY: META,\n  NEED: false,\n  fastKey: fastKey,\n  getWeak: getWeak,\n  onFreeze: onFreeze\n};\n","var Map = require('./es6.map');\nvar $export = require('./_export');\nvar shared = require('./_shared')('metadata');\nvar store = shared.store || (shared.store = new (require('./es6.weak-map'))());\n\nvar getOrCreateMetadataMap = function (target, targetKey, create) {\n  var targetMetadata = store.get(target);\n  if (!targetMetadata) {\n    if (!create) return undefined;\n    store.set(target, targetMetadata = new Map());\n  }\n  var keyMetadata = targetMetadata.get(targetKey);\n  if (!keyMetadata) {\n    if (!create) return undefined;\n    targetMetadata.set(targetKey, keyMetadata = new Map());\n  } return keyMetadata;\n};\nvar ordinaryHasOwnMetadata = function (MetadataKey, O, P) {\n  var metadataMap = getOrCreateMetadataMap(O, P, false);\n  return metadataMap === undefined ? false : metadataMap.has(MetadataKey);\n};\nvar ordinaryGetOwnMetadata = function (MetadataKey, O, P) {\n  var metadataMap = getOrCreateMetadataMap(O, P, false);\n  return metadataMap === undefined ? undefined : metadataMap.get(MetadataKey);\n};\nvar ordinaryDefineOwnMetadata = function (MetadataKey, MetadataValue, O, P) {\n  getOrCreateMetadataMap(O, P, true).set(MetadataKey, MetadataValue);\n};\nvar ordinaryOwnMetadataKeys = function (target, targetKey) {\n  var metadataMap = getOrCreateMetadataMap(target, targetKey, false);\n  var keys = [];\n  if (metadataMap) metadataMap.forEach(function (_, key) { keys.push(key); });\n  return keys;\n};\nvar toMetaKey = function (it) {\n  return it === undefined || typeof it == 'symbol' ? it : String(it);\n};\nvar exp = function (O) {\n  $export($export.S, 'Reflect', O);\n};\n\nmodule.exports = {\n  store: store,\n  map: getOrCreateMetadataMap,\n  has: ordinaryHasOwnMetadata,\n  get: ordinaryGetOwnMetadata,\n  set: ordinaryDefineOwnMetadata,\n  keys: ordinaryOwnMetadataKeys,\n  key: toMetaKey,\n  exp: exp\n};\n","var global = require('./_global');\nvar macrotask = require('./_task').set;\nvar Observer = global.MutationObserver || global.WebKitMutationObserver;\nvar process = global.process;\nvar Promise = global.Promise;\nvar isNode = require('./_cof')(process) == 'process';\n\nmodule.exports = function () {\n  var head, last, notify;\n\n  var flush = function () {\n    var parent, fn;\n    if (isNode && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (e) {\n        if (head) notify();\n        else last = undefined;\n        throw e;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // Node.js\n  if (isNode) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // browsers with MutationObserver, except iOS Safari - https://github.com/zloirock/core-js/issues/339\n  } else if (Observer && !(global.navigator && global.navigator.standalone)) {\n    var toggle = true;\n    var node = document.createTextNode('');\n    new Observer(flush).observe(node, { characterData: true }); // eslint-disable-line no-new\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    var promise = Promise.resolve(undefined);\n    notify = function () {\n      promise.then(flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    notify = function () {\n      // strange IE + webpack dev server bug - use .call(global)\n      macrotask.call(global, flush);\n    };\n  }\n\n  return function (fn) {\n    var task = { fn: fn, next: undefined };\n    if (last) last.next = task;\n    if (!head) {\n      head = task;\n      notify();\n    } last = task;\n  };\n};\n","'use strict';\n// 25.4.1.5 NewPromiseCapability(C)\nvar aFunction = require('./_a-function');\n\nfunction PromiseCapability(C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject = aFunction(reject);\n}\n\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","'use strict';\n// 19.1.2.1 Object.assign(target, source, ...)\nvar getKeys = require('./_object-keys');\nvar gOPS = require('./_object-gops');\nvar pIE = require('./_object-pie');\nvar toObject = require('./_to-object');\nvar IObject = require('./_iobject');\nvar $assign = Object.assign;\n\n// should work with symbols and should have deterministic property order (V8 bug)\nmodule.exports = !$assign || require('./_fails')(function () {\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var S = Symbol();\n  var K = 'abcdefghijklmnopqrst';\n  A[S] = 7;\n  K.split('').forEach(function (k) { B[k] = k; });\n  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var aLen = arguments.length;\n  var index = 1;\n  var getSymbols = gOPS.f;\n  var isEnum = pIE.f;\n  while (aLen > index) {\n    var S = IObject(arguments[index++]);\n    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) if (isEnum.call(S, key = keys[j++])) T[key] = S[key];\n  } return T;\n} : $assign;\n","// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\nvar anObject = require('./_an-object');\nvar dPs = require('./_object-dps');\nvar enumBugKeys = require('./_enum-bug-keys');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar Empty = function () { /* empty */ };\nvar PROTOTYPE = 'prototype';\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar createDict = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = require('./_dom-create')('iframe');\n  var i = enumBugKeys.length;\n  var lt = '<';\n  var gt = '>';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  require('./_html').appendChild(iframe);\n  iframe.src = 'javascript:'; // eslint-disable-line no-script-url\n  // createDict = iframe.contentWindow.Object;\n  // html.removeChild(iframe);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);\n  iframeDocument.close();\n  createDict = iframeDocument.F;\n  while (i--) delete createDict[PROTOTYPE][enumBugKeys[i]];\n  return createDict();\n};\n\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    Empty[PROTOTYPE] = anObject(O);\n    result = new Empty();\n    Empty[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = createDict();\n  return Properties === undefined ? result : dPs(result, Properties);\n};\n","var anObject = require('./_an-object');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar toPrimitive = require('./_to-primitive');\nvar dP = Object.defineProperty;\n\nexports.f = require('./_descriptors') ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return dP(O, P, Attributes);\n  } catch (e) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var dP = require('./_object-dp');\nvar anObject = require('./_an-object');\nvar getKeys = require('./_object-keys');\n\nmodule.exports = require('./_descriptors') ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = getKeys(Properties);\n  var length = keys.length;\n  var i = 0;\n  var P;\n  while (length > i) dP.f(O, P = keys[i++], Properties[P]);\n  return O;\n};\n","'use strict';\n// Forced replacement prototype accessors methods\nmodule.exports = require('./_library') || !require('./_fails')(function () {\n  var K = Math.random();\n  // In FF throws only define methods\n  // eslint-disable-next-line no-undef, no-useless-call\n  __defineSetter__.call(null, K, function () { /* empty */ });\n  delete require('./_global')[K];\n});\n","var pIE = require('./_object-pie');\nvar createDesc = require('./_property-desc');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar has = require('./_has');\nvar IE8_DOM_DEFINE = require('./_ie8-dom-define');\nvar gOPD = Object.getOwnPropertyDescriptor;\n\nexports.f = require('./_descriptors') ? gOPD : function getOwnPropertyDescriptor(O, P) {\n  O = toIObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return gOPD(O, P);\n  } catch (e) { /* empty */ }\n  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);\n};\n","// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nvar toIObject = require('./_to-iobject');\nvar gOPN = require('./_object-gopn').f;\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return gOPN(it);\n  } catch (e) {\n    return windowNames.slice();\n  }\n};\n\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));\n};\n","// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)\nvar $keys = require('./_object-keys-internal');\nvar hiddenKeys = require('./_enum-bug-keys').concat('length', 'prototype');\n\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return $keys(O, hiddenKeys);\n};\n","exports.f = Object.getOwnPropertySymbols;\n","// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)\nvar has = require('./_has');\nvar toObject = require('./_to-object');\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\nvar ObjectProto = Object.prototype;\n\nmodule.exports = Object.getPrototypeOf || function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectProto : null;\n};\n","var has = require('./_has');\nvar toIObject = require('./_to-iobject');\nvar arrayIndexOf = require('./_array-includes')(false);\nvar IE_PROTO = require('./_shared-key')('IE_PROTO');\n\nmodule.exports = function (object, names) {\n  var O = toIObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) if (key != IE_PROTO) has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~arrayIndexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","// 19.1.2.14 / 15.2.3.14 Object.keys(O)\nvar $keys = require('./_object-keys-internal');\nvar enumBugKeys = require('./_enum-bug-keys');\n\nmodule.exports = Object.keys || function keys(O) {\n  return $keys(O, enumBugKeys);\n};\n","exports.f = {}.propertyIsEnumerable;\n","// most Object methods by ES6 should accept primitives\nvar $export = require('./_export');\nvar core = require('./_core');\nvar fails = require('./_fails');\nmodule.exports = function (KEY, exec) {\n  var fn = (core.Object || {})[KEY] || Object[KEY];\n  var exp = {};\n  exp[KEY] = exec(fn);\n  $export($export.S + $export.F * fails(function () { fn(1); }), 'Object', exp);\n};\n","var getKeys = require('./_object-keys');\nvar toIObject = require('./_to-iobject');\nvar isEnum = require('./_object-pie').f;\nmodule.exports = function (isEntries) {\n  return function (it) {\n    var O = toIObject(it);\n    var keys = getKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) if (isEnum.call(O, key = keys[i++])) {\n      result.push(isEntries ? [key, O[key]] : O[key]);\n    } return result;\n  };\n};\n","// all object keys, includes non-enumerable and symbols\nvar gOPN = require('./_object-gopn');\nvar gOPS = require('./_object-gops');\nvar anObject = require('./_an-object');\nvar Reflect = require('./_global').Reflect;\nmodule.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {\n  var keys = gOPN.f(anObject(it));\n  var getSymbols = gOPS.f;\n  return getSymbols ? keys.concat(getSymbols(it)) : keys;\n};\n","var $parseFloat = require('./_global').parseFloat;\nvar $trim = require('./_string-trim').trim;\n\nmodule.exports = 1 / $parseFloat(require('./_string-ws') + '-0') !== -Infinity ? function parseFloat(str) {\n  var string = $trim(String(str), 3);\n  var result = $parseFloat(string);\n  return result === 0 && string.charAt(0) == '-' ? -0 : result;\n} : $parseFloat;\n","var $parseInt = require('./_global').parseInt;\nvar $trim = require('./_string-trim').trim;\nvar ws = require('./_string-ws');\nvar hex = /^[-+]?0[xX]/;\n\nmodule.exports = $parseInt(ws + '08') !== 8 || $parseInt(ws + '0x16') !== 22 ? function parseInt(str, radix) {\n  var string = $trim(String(str), 3);\n  return $parseInt(string, (radix >>> 0) || (hex.test(string) ? 16 : 10));\n} : $parseInt;\n","module.exports = function (exec) {\n  try {\n    return { e: false, v: exec() };\n  } catch (e) {\n    return { e: true, v: e };\n  }\n};\n","var anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar newPromiseCapability = require('./_new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","var redefine = require('./_redefine');\nmodule.exports = function (target, src, safe) {\n  for (var key in src) redefine(target, key, src[key], safe);\n  return target;\n};\n","var global = require('./_global');\nvar hide = require('./_hide');\nvar has = require('./_has');\nvar SRC = require('./_uid')('src');\nvar $toString = require('./_function-to-string');\nvar TO_STRING = 'toString';\nvar TPL = ('' + $toString).split(TO_STRING);\n\nrequire('./_core').inspectSource = function (it) {\n  return $toString.call(it);\n};\n\n(module.exports = function (O, key, val, safe) {\n  var isFunction = typeof val == 'function';\n  if (isFunction) has(val, 'name') || hide(val, 'name', key);\n  if (O[key] === val) return;\n  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n  if (O === global) {\n    O[key] = val;\n  } else if (!safe) {\n    delete O[key];\n    hide(O, key, val);\n  } else if (O[key]) {\n    O[key] = val;\n  } else {\n    hide(O, key, val);\n  }\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, TO_STRING, function toString() {\n  return typeof this == 'function' && this[SRC] || $toString.call(this);\n});\n","'use strict';\n\nvar classof = require('./_classof');\nvar builtinExec = RegExp.prototype.exec;\n\n // `RegExpExec` abstract operation\n// https://tc39.github.io/ecma262/#sec-regexpexec\nmodule.exports = function (R, S) {\n  var exec = R.exec;\n  if (typeof exec === 'function') {\n    var result = exec.call(R, S);\n    if (typeof result !== 'object') {\n      throw new TypeError('RegExp exec method returned something other than an Object or null');\n    }\n    return result;\n  }\n  if (classof(R) !== 'RegExp') {\n    throw new TypeError('RegExp#exec called on incompatible receiver');\n  }\n  return builtinExec.call(R, S);\n};\n","'use strict';\n\nvar regexpFlags = require('./_flags');\n\nvar nativeExec = RegExp.prototype.exec;\n// This always refers to the native implementation, because the\n// String#replace polyfill uses ./fix-regexp-well-known-symbol-logic.js,\n// which loads this file before patching the method.\nvar nativeReplace = String.prototype.replace;\n\nvar patchedExec = nativeExec;\n\nvar LAST_INDEX = 'lastIndex';\n\nvar UPDATES_LAST_INDEX_WRONG = (function () {\n  var re1 = /a/,\n      re2 = /b*/g;\n  nativeExec.call(re1, 'a');\n  nativeExec.call(re2, 'a');\n  return re1[LAST_INDEX] !== 0 || re2[LAST_INDEX] !== 0;\n})();\n\n// nonparticipating capturing group, copied from es5-shim's String#split patch.\nvar NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;\n\nvar PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED;\n\nif (PATCH) {\n  patchedExec = function exec(str) {\n    var re = this;\n    var lastIndex, reCopy, match, i;\n\n    if (NPCG_INCLUDED) {\n      reCopy = new RegExp('^' + re.source + '$(?!\\\\s)', regexpFlags.call(re));\n    }\n    if (UPDATES_LAST_INDEX_WRONG) lastIndex = re[LAST_INDEX];\n\n    match = nativeExec.call(re, str);\n\n    if (UPDATES_LAST_INDEX_WRONG && match) {\n      re[LAST_INDEX] = re.global ? match.index + match[0].length : lastIndex;\n    }\n    if (NPCG_INCLUDED && match && match.length > 1) {\n      // Fix browsers whose `exec` methods don't consistently return `undefined`\n      // for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/\n      // eslint-disable-next-line no-loop-func\n      nativeReplace.call(match[0], reCopy, function () {\n        for (i = 1; i < arguments.length - 2; i++) {\n          if (arguments[i] === undefined) match[i] = undefined;\n        }\n      });\n    }\n\n    return match;\n  };\n}\n\nmodule.exports = patchedExec;\n","module.exports = function (regExp, replace) {\n  var replacer = replace === Object(replace) ? function (part) {\n    return replace[part];\n  } : replace;\n  return function (it) {\n    return String(it).replace(regExp, replacer);\n  };\n};\n","// 7.2.9 SameValue(x, y)\nmodule.exports = Object.is || function is(x, y) {\n  // eslint-disable-next-line no-self-compare\n  return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;\n};\n","'use strict';\n// https://tc39.github.io/proposal-setmap-offrom/\nvar $export = require('./_export');\nvar aFunction = require('./_a-function');\nvar ctx = require('./_ctx');\nvar forOf = require('./_for-of');\n\nmodule.exports = function (COLLECTION) {\n  $export($export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {\n    var mapFn = arguments[1];\n    var mapping, A, n, cb;\n    aFunction(this);\n    mapping = mapFn !== undefined;\n    if (mapping) aFunction(mapFn);\n    if (source == undefined) return new this();\n    A = [];\n    if (mapping) {\n      n = 0;\n      cb = ctx(mapFn, arguments[2], 2);\n      forOf(source, false, function (nextItem) {\n        A.push(cb(nextItem, n++));\n      });\n    } else {\n      forOf(source, false, A.push, A);\n    }\n    return new this(A);\n  } });\n};\n","'use strict';\n// https://tc39.github.io/proposal-setmap-offrom/\nvar $export = require('./_export');\n\nmodule.exports = function (COLLECTION) {\n  $export($export.S, COLLECTION, { of: function of() {\n    var length = arguments.length;\n    var A = new Array(length);\n    while (length--) A[length] = arguments[length];\n    return new this(A);\n  } });\n};\n","// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nvar isObject = require('./_is-object');\nvar anObject = require('./_an-object');\nvar check = function (O, proto) {\n  anObject(O);\n  if (!isObject(proto) && proto !== null) throw TypeError(proto + \": can't set as prototype!\");\n};\nmodule.exports = {\n  set: Object.setPrototypeOf || ('__proto__' in {} ? // eslint-disable-line\n    function (test, buggy, set) {\n      try {\n        set = require('./_ctx')(Function.call, require('./_object-gopd').f(Object.prototype, '__proto__').set, 2);\n        set(test, []);\n        buggy = !(test instanceof Array);\n      } catch (e) { buggy = true; }\n      return function setPrototypeOf(O, proto) {\n        check(O, proto);\n        if (buggy) O.__proto__ = proto;\n        else set(O, proto);\n        return O;\n      };\n    }({}, false) : undefined),\n  check: check\n};\n","'use strict';\nvar global = require('./_global');\nvar dP = require('./_object-dp');\nvar DESCRIPTORS = require('./_descriptors');\nvar SPECIES = require('./_wks')('species');\n\nmodule.exports = function (KEY) {\n  var C = global[KEY];\n  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {\n    configurable: true,\n    get: function () { return this; }\n  });\n};\n","var def = require('./_object-dp').f;\nvar has = require('./_has');\nvar TAG = require('./_wks')('toStringTag');\n\nmodule.exports = function (it, tag, stat) {\n  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, { configurable: true, value: tag });\n};\n","var shared = require('./_shared')('keys');\nvar uid = require('./_uid');\nmodule.exports = function (key) {\n  return shared[key] || (shared[key] = uid(key));\n};\n","var core = require('./_core');\nvar global = require('./_global');\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || (global[SHARED] = {});\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: core.version,\n  mode: require('./_library') ? 'pure' : 'global',\n  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'\n});\n","// 7.3.20 SpeciesConstructor(O, defaultConstructor)\nvar anObject = require('./_an-object');\nvar aFunction = require('./_a-function');\nvar SPECIES = require('./_wks')('species');\nmodule.exports = function (O, D) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);\n};\n","'use strict';\nvar fails = require('./_fails');\n\nmodule.exports = function (method, arg) {\n  return !!method && fails(function () {\n    // eslint-disable-next-line no-useless-call\n    arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);\n  });\n};\n","var toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n// true  -> String#at\n// false -> String#codePointAt\nmodule.exports = function (TO_STRING) {\n  return function (that, pos) {\n    var s = String(defined(that));\n    var i = toInteger(pos);\n    var l = s.length;\n    var a, b;\n    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;\n    a = s.charCodeAt(i);\n    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff\n      ? TO_STRING ? s.charAt(i) : a\n      : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;\n  };\n};\n","// helper for String#{startsWith, endsWith, includes}\nvar isRegExp = require('./_is-regexp');\nvar defined = require('./_defined');\n\nmodule.exports = function (that, searchString, NAME) {\n  if (isRegExp(searchString)) throw TypeError('String#' + NAME + \" doesn't accept regex!\");\n  return String(defined(that));\n};\n","var $export = require('./_export');\nvar fails = require('./_fails');\nvar defined = require('./_defined');\nvar quot = /\"/g;\n// B.2.3.2.1 CreateHTML(string, tag, attribute, value)\nvar createHTML = function (string, tag, attribute, value) {\n  var S = String(defined(string));\n  var p1 = '<' + tag;\n  if (attribute !== '') p1 += ' ' + attribute + '=\"' + String(value).replace(quot, '&quot;') + '\"';\n  return p1 + '>' + S + '</' + tag + '>';\n};\nmodule.exports = function (NAME, exec) {\n  var O = {};\n  O[NAME] = exec(createHTML);\n  $export($export.P + $export.F * fails(function () {\n    var test = ''[NAME]('\"');\n    return test !== test.toLowerCase() || test.split('\"').length > 3;\n  }), 'String', O);\n};\n","// https://github.com/tc39/proposal-string-pad-start-end\nvar toLength = require('./_to-length');\nvar repeat = require('./_string-repeat');\nvar defined = require('./_defined');\n\nmodule.exports = function (that, maxLength, fillString, left) {\n  var S = String(defined(that));\n  var stringLength = S.length;\n  var fillStr = fillString === undefined ? ' ' : String(fillString);\n  var intMaxLength = toLength(maxLength);\n  if (intMaxLength <= stringLength || fillStr == '') return S;\n  var fillLen = intMaxLength - stringLength;\n  var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));\n  if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);\n  return left ? stringFiller + S : S + stringFiller;\n};\n","'use strict';\nvar toInteger = require('./_to-integer');\nvar defined = require('./_defined');\n\nmodule.exports = function repeat(count) {\n  var str = String(defined(this));\n  var res = '';\n  var n = toInteger(count);\n  if (n < 0 || n == Infinity) throw RangeError(\"Count can't be negative\");\n  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) res += str;\n  return res;\n};\n","var $export = require('./_export');\nvar defined = require('./_defined');\nvar fails = require('./_fails');\nvar spaces = require('./_string-ws');\nvar space = '[' + spaces + ']';\nvar non = '\\u200b\\u0085';\nvar ltrim = RegExp('^' + space + space + '*');\nvar rtrim = RegExp(space + space + '*$');\n\nvar exporter = function (KEY, exec, ALIAS) {\n  var exp = {};\n  var FORCE = fails(function () {\n    return !!spaces[KEY]() || non[KEY]() != non;\n  });\n  var fn = exp[KEY] = FORCE ? exec(trim) : spaces[KEY];\n  if (ALIAS) exp[ALIAS] = fn;\n  $export($export.P + $export.F * FORCE, 'String', exp);\n};\n\n// 1 -> String#trimLeft\n// 2 -> String#trimRight\n// 3 -> String#trim\nvar trim = exporter.trim = function (string, TYPE) {\n  string = String(defined(string));\n  if (TYPE & 1) string = string.replace(ltrim, '');\n  if (TYPE & 2) string = string.replace(rtrim, '');\n  return string;\n};\n\nmodule.exports = exporter;\n","module.exports = '\\x09\\x0A\\x0B\\x0C\\x0D\\x20\\xA0\\u1680\\u180E\\u2000\\u2001\\u2002\\u2003' +\n  '\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","var ctx = require('./_ctx');\nvar invoke = require('./_invoke');\nvar html = require('./_html');\nvar cel = require('./_dom-create');\nvar global = require('./_global');\nvar process = global.process;\nvar setTask = global.setImmediate;\nvar clearTask = global.clearImmediate;\nvar MessageChannel = global.MessageChannel;\nvar Dispatch = global.Dispatch;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar defer, channel, port;\nvar run = function () {\n  var id = +this;\n  // eslint-disable-next-line no-prototype-builtins\n  if (queue.hasOwnProperty(id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\nvar listener = function (event) {\n  run.call(event.data);\n};\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!setTask || !clearTask) {\n  setTask = function setImmediate(fn) {\n    var args = [];\n    var i = 1;\n    while (arguments.length > i) args.push(arguments[i++]);\n    queue[++counter] = function () {\n      // eslint-disable-next-line no-new-func\n      invoke(typeof fn == 'function' ? fn : Function(fn), args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clearTask = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (require('./_cof')(process) == 'process') {\n    defer = function (id) {\n      process.nextTick(ctx(run, id, 1));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(ctx(run, id, 1));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  } else if (MessageChannel) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = ctx(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {\n    defer = function (id) {\n      global.postMessage(id + '', '*');\n    };\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in cel('script')) {\n    defer = function (id) {\n      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run.call(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(ctx(run, id, 1), 0);\n    };\n  }\n}\nmodule.exports = {\n  set: setTask,\n  clear: clearTask\n};\n","var toInteger = require('./_to-integer');\nvar max = Math.max;\nvar min = Math.min;\nmodule.exports = function (index, length) {\n  index = toInteger(index);\n  return index < 0 ? max(index + length, 0) : min(index, length);\n};\n","// https://tc39.github.io/ecma262/#sec-toindex\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nmodule.exports = function (it) {\n  if (it === undefined) return 0;\n  var number = toInteger(it);\n  var length = toLength(number);\n  if (number !== length) throw RangeError('Wrong length!');\n  return length;\n};\n","// 7.1.4 ToInteger\nvar ceil = Math.ceil;\nvar floor = Math.floor;\nmodule.exports = function (it) {\n  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);\n};\n","// to indexed object, toObject with fallback for non-array-like ES3 strings\nvar IObject = require('./_iobject');\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return IObject(defined(it));\n};\n","// 7.1.15 ToLength\nvar toInteger = require('./_to-integer');\nvar min = Math.min;\nmodule.exports = function (it) {\n  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991\n};\n","// 7.1.13 ToObject(argument)\nvar defined = require('./_defined');\nmodule.exports = function (it) {\n  return Object(defined(it));\n};\n","// 7.1.1 ToPrimitive(input [, PreferredType])\nvar isObject = require('./_is-object');\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (it, S) {\n  if (!isObject(it)) return it;\n  var fn, val;\n  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;\n  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nif (require('./_descriptors')) {\n  var LIBRARY = require('./_library');\n  var global = require('./_global');\n  var fails = require('./_fails');\n  var $export = require('./_export');\n  var $typed = require('./_typed');\n  var $buffer = require('./_typed-buffer');\n  var ctx = require('./_ctx');\n  var anInstance = require('./_an-instance');\n  var propertyDesc = require('./_property-desc');\n  var hide = require('./_hide');\n  var redefineAll = require('./_redefine-all');\n  var toInteger = require('./_to-integer');\n  var toLength = require('./_to-length');\n  var toIndex = require('./_to-index');\n  var toAbsoluteIndex = require('./_to-absolute-index');\n  var toPrimitive = require('./_to-primitive');\n  var has = require('./_has');\n  var classof = require('./_classof');\n  var isObject = require('./_is-object');\n  var toObject = require('./_to-object');\n  var isArrayIter = require('./_is-array-iter');\n  var create = require('./_object-create');\n  var getPrototypeOf = require('./_object-gpo');\n  var gOPN = require('./_object-gopn').f;\n  var getIterFn = require('./core.get-iterator-method');\n  var uid = require('./_uid');\n  var wks = require('./_wks');\n  var createArrayMethod = require('./_array-methods');\n  var createArrayIncludes = require('./_array-includes');\n  var speciesConstructor = require('./_species-constructor');\n  var ArrayIterators = require('./es6.array.iterator');\n  var Iterators = require('./_iterators');\n  var $iterDetect = require('./_iter-detect');\n  var setSpecies = require('./_set-species');\n  var arrayFill = require('./_array-fill');\n  var arrayCopyWithin = require('./_array-copy-within');\n  var $DP = require('./_object-dp');\n  var $GOPD = require('./_object-gopd');\n  var dP = $DP.f;\n  var gOPD = $GOPD.f;\n  var RangeError = global.RangeError;\n  var TypeError = global.TypeError;\n  var Uint8Array = global.Uint8Array;\n  var ARRAY_BUFFER = 'ArrayBuffer';\n  var SHARED_BUFFER = 'Shared' + ARRAY_BUFFER;\n  var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';\n  var PROTOTYPE = 'prototype';\n  var ArrayProto = Array[PROTOTYPE];\n  var $ArrayBuffer = $buffer.ArrayBuffer;\n  var $DataView = $buffer.DataView;\n  var arrayForEach = createArrayMethod(0);\n  var arrayFilter = createArrayMethod(2);\n  var arraySome = createArrayMethod(3);\n  var arrayEvery = createArrayMethod(4);\n  var arrayFind = createArrayMethod(5);\n  var arrayFindIndex = createArrayMethod(6);\n  var arrayIncludes = createArrayIncludes(true);\n  var arrayIndexOf = createArrayIncludes(false);\n  var arrayValues = ArrayIterators.values;\n  var arrayKeys = ArrayIterators.keys;\n  var arrayEntries = ArrayIterators.entries;\n  var arrayLastIndexOf = ArrayProto.lastIndexOf;\n  var arrayReduce = ArrayProto.reduce;\n  var arrayReduceRight = ArrayProto.reduceRight;\n  var arrayJoin = ArrayProto.join;\n  var arraySort = ArrayProto.sort;\n  var arraySlice = ArrayProto.slice;\n  var arrayToString = ArrayProto.toString;\n  var arrayToLocaleString = ArrayProto.toLocaleString;\n  var ITERATOR = wks('iterator');\n  var TAG = wks('toStringTag');\n  var TYPED_CONSTRUCTOR = uid('typed_constructor');\n  var DEF_CONSTRUCTOR = uid('def_constructor');\n  var ALL_CONSTRUCTORS = $typed.CONSTR;\n  var TYPED_ARRAY = $typed.TYPED;\n  var VIEW = $typed.VIEW;\n  var WRONG_LENGTH = 'Wrong length!';\n\n  var $map = createArrayMethod(1, function (O, length) {\n    return allocate(speciesConstructor(O, O[DEF_CONSTRUCTOR]), length);\n  });\n\n  var LITTLE_ENDIAN = fails(function () {\n    // eslint-disable-next-line no-undef\n    return new Uint8Array(new Uint16Array([1]).buffer)[0] === 1;\n  });\n\n  var FORCED_SET = !!Uint8Array && !!Uint8Array[PROTOTYPE].set && fails(function () {\n    new Uint8Array(1).set({});\n  });\n\n  var toOffset = function (it, BYTES) {\n    var offset = toInteger(it);\n    if (offset < 0 || offset % BYTES) throw RangeError('Wrong offset!');\n    return offset;\n  };\n\n  var validate = function (it) {\n    if (isObject(it) && TYPED_ARRAY in it) return it;\n    throw TypeError(it + ' is not a typed array!');\n  };\n\n  var allocate = function (C, length) {\n    if (!(isObject(C) && TYPED_CONSTRUCTOR in C)) {\n      throw TypeError('It is not a typed array constructor!');\n    } return new C(length);\n  };\n\n  var speciesFromList = function (O, list) {\n    return fromList(speciesConstructor(O, O[DEF_CONSTRUCTOR]), list);\n  };\n\n  var fromList = function (C, list) {\n    var index = 0;\n    var length = list.length;\n    var result = allocate(C, length);\n    while (length > index) result[index] = list[index++];\n    return result;\n  };\n\n  var addGetter = function (it, key, internal) {\n    dP(it, key, { get: function () { return this._d[internal]; } });\n  };\n\n  var $from = function from(source /* , mapfn, thisArg */) {\n    var O = toObject(source);\n    var aLen = arguments.length;\n    var mapfn = aLen > 1 ? arguments[1] : undefined;\n    var mapping = mapfn !== undefined;\n    var iterFn = getIterFn(O);\n    var i, length, values, result, step, iterator;\n    if (iterFn != undefined && !isArrayIter(iterFn)) {\n      for (iterator = iterFn.call(O), values = [], i = 0; !(step = iterator.next()).done; i++) {\n        values.push(step.value);\n      } O = values;\n    }\n    if (mapping && aLen > 2) mapfn = ctx(mapfn, arguments[2], 2);\n    for (i = 0, length = toLength(O.length), result = allocate(this, length); length > i; i++) {\n      result[i] = mapping ? mapfn(O[i], i) : O[i];\n    }\n    return result;\n  };\n\n  var $of = function of(/* ...items */) {\n    var index = 0;\n    var length = arguments.length;\n    var result = allocate(this, length);\n    while (length > index) result[index] = arguments[index++];\n    return result;\n  };\n\n  // iOS Safari 6.x fails here\n  var TO_LOCALE_BUG = !!Uint8Array && fails(function () { arrayToLocaleString.call(new Uint8Array(1)); });\n\n  var $toLocaleString = function toLocaleString() {\n    return arrayToLocaleString.apply(TO_LOCALE_BUG ? arraySlice.call(validate(this)) : validate(this), arguments);\n  };\n\n  var proto = {\n    copyWithin: function copyWithin(target, start /* , end */) {\n      return arrayCopyWithin.call(validate(this), target, start, arguments.length > 2 ? arguments[2] : undefined);\n    },\n    every: function every(callbackfn /* , thisArg */) {\n      return arrayEvery(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    fill: function fill(value /* , start, end */) { // eslint-disable-line no-unused-vars\n      return arrayFill.apply(validate(this), arguments);\n    },\n    filter: function filter(callbackfn /* , thisArg */) {\n      return speciesFromList(this, arrayFilter(validate(this), callbackfn,\n        arguments.length > 1 ? arguments[1] : undefined));\n    },\n    find: function find(predicate /* , thisArg */) {\n      return arrayFind(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    findIndex: function findIndex(predicate /* , thisArg */) {\n      return arrayFindIndex(validate(this), predicate, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    forEach: function forEach(callbackfn /* , thisArg */) {\n      arrayForEach(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    indexOf: function indexOf(searchElement /* , fromIndex */) {\n      return arrayIndexOf(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    includes: function includes(searchElement /* , fromIndex */) {\n      return arrayIncludes(validate(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    join: function join(separator) { // eslint-disable-line no-unused-vars\n      return arrayJoin.apply(validate(this), arguments);\n    },\n    lastIndexOf: function lastIndexOf(searchElement /* , fromIndex */) { // eslint-disable-line no-unused-vars\n      return arrayLastIndexOf.apply(validate(this), arguments);\n    },\n    map: function map(mapfn /* , thisArg */) {\n      return $map(validate(this), mapfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    reduce: function reduce(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars\n      return arrayReduce.apply(validate(this), arguments);\n    },\n    reduceRight: function reduceRight(callbackfn /* , initialValue */) { // eslint-disable-line no-unused-vars\n      return arrayReduceRight.apply(validate(this), arguments);\n    },\n    reverse: function reverse() {\n      var that = this;\n      var length = validate(that).length;\n      var middle = Math.floor(length / 2);\n      var index = 0;\n      var value;\n      while (index < middle) {\n        value = that[index];\n        that[index++] = that[--length];\n        that[length] = value;\n      } return that;\n    },\n    some: function some(callbackfn /* , thisArg */) {\n      return arraySome(validate(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n    },\n    sort: function sort(comparefn) {\n      return arraySort.call(validate(this), comparefn);\n    },\n    subarray: function subarray(begin, end) {\n      var O = validate(this);\n      var length = O.length;\n      var $begin = toAbsoluteIndex(begin, length);\n      return new (speciesConstructor(O, O[DEF_CONSTRUCTOR]))(\n        O.buffer,\n        O.byteOffset + $begin * O.BYTES_PER_ELEMENT,\n        toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - $begin)\n      );\n    }\n  };\n\n  var $slice = function slice(start, end) {\n    return speciesFromList(this, arraySlice.call(validate(this), start, end));\n  };\n\n  var $set = function set(arrayLike /* , offset */) {\n    validate(this);\n    var offset = toOffset(arguments[1], 1);\n    var length = this.length;\n    var src = toObject(arrayLike);\n    var len = toLength(src.length);\n    var index = 0;\n    if (len + offset > length) throw RangeError(WRONG_LENGTH);\n    while (index < len) this[offset + index] = src[index++];\n  };\n\n  var $iterators = {\n    entries: function entries() {\n      return arrayEntries.call(validate(this));\n    },\n    keys: function keys() {\n      return arrayKeys.call(validate(this));\n    },\n    values: function values() {\n      return arrayValues.call(validate(this));\n    }\n  };\n\n  var isTAIndex = function (target, key) {\n    return isObject(target)\n      && target[TYPED_ARRAY]\n      && typeof key != 'symbol'\n      && key in target\n      && String(+key) == String(key);\n  };\n  var $getDesc = function getOwnPropertyDescriptor(target, key) {\n    return isTAIndex(target, key = toPrimitive(key, true))\n      ? propertyDesc(2, target[key])\n      : gOPD(target, key);\n  };\n  var $setDesc = function defineProperty(target, key, desc) {\n    if (isTAIndex(target, key = toPrimitive(key, true))\n      && isObject(desc)\n      && has(desc, 'value')\n      && !has(desc, 'get')\n      && !has(desc, 'set')\n      // TODO: add validation descriptor w/o calling accessors\n      && !desc.configurable\n      && (!has(desc, 'writable') || desc.writable)\n      && (!has(desc, 'enumerable') || desc.enumerable)\n    ) {\n      target[key] = desc.value;\n      return target;\n    } return dP(target, key, desc);\n  };\n\n  if (!ALL_CONSTRUCTORS) {\n    $GOPD.f = $getDesc;\n    $DP.f = $setDesc;\n  }\n\n  $export($export.S + $export.F * !ALL_CONSTRUCTORS, 'Object', {\n    getOwnPropertyDescriptor: $getDesc,\n    defineProperty: $setDesc\n  });\n\n  if (fails(function () { arrayToString.call({}); })) {\n    arrayToString = arrayToLocaleString = function toString() {\n      return arrayJoin.call(this);\n    };\n  }\n\n  var $TypedArrayPrototype$ = redefineAll({}, proto);\n  redefineAll($TypedArrayPrototype$, $iterators);\n  hide($TypedArrayPrototype$, ITERATOR, $iterators.values);\n  redefineAll($TypedArrayPrototype$, {\n    slice: $slice,\n    set: $set,\n    constructor: function () { /* noop */ },\n    toString: arrayToString,\n    toLocaleString: $toLocaleString\n  });\n  addGetter($TypedArrayPrototype$, 'buffer', 'b');\n  addGetter($TypedArrayPrototype$, 'byteOffset', 'o');\n  addGetter($TypedArrayPrototype$, 'byteLength', 'l');\n  addGetter($TypedArrayPrototype$, 'length', 'e');\n  dP($TypedArrayPrototype$, TAG, {\n    get: function () { return this[TYPED_ARRAY]; }\n  });\n\n  // eslint-disable-next-line max-statements\n  module.exports = function (KEY, BYTES, wrapper, CLAMPED) {\n    CLAMPED = !!CLAMPED;\n    var NAME = KEY + (CLAMPED ? 'Clamped' : '') + 'Array';\n    var GETTER = 'get' + KEY;\n    var SETTER = 'set' + KEY;\n    var TypedArray = global[NAME];\n    var Base = TypedArray || {};\n    var TAC = TypedArray && getPrototypeOf(TypedArray);\n    var FORCED = !TypedArray || !$typed.ABV;\n    var O = {};\n    var TypedArrayPrototype = TypedArray && TypedArray[PROTOTYPE];\n    var getter = function (that, index) {\n      var data = that._d;\n      return data.v[GETTER](index * BYTES + data.o, LITTLE_ENDIAN);\n    };\n    var setter = function (that, index, value) {\n      var data = that._d;\n      if (CLAMPED) value = (value = Math.round(value)) < 0 ? 0 : value > 0xff ? 0xff : value & 0xff;\n      data.v[SETTER](index * BYTES + data.o, value, LITTLE_ENDIAN);\n    };\n    var addElement = function (that, index) {\n      dP(that, index, {\n        get: function () {\n          return getter(this, index);\n        },\n        set: function (value) {\n          return setter(this, index, value);\n        },\n        enumerable: true\n      });\n    };\n    if (FORCED) {\n      TypedArray = wrapper(function (that, data, $offset, $length) {\n        anInstance(that, TypedArray, NAME, '_d');\n        var index = 0;\n        var offset = 0;\n        var buffer, byteLength, length, klass;\n        if (!isObject(data)) {\n          length = toIndex(data);\n          byteLength = length * BYTES;\n          buffer = new $ArrayBuffer(byteLength);\n        } else if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {\n          buffer = data;\n          offset = toOffset($offset, BYTES);\n          var $len = data.byteLength;\n          if ($length === undefined) {\n            if ($len % BYTES) throw RangeError(WRONG_LENGTH);\n            byteLength = $len - offset;\n            if (byteLength < 0) throw RangeError(WRONG_LENGTH);\n          } else {\n            byteLength = toLength($length) * BYTES;\n            if (byteLength + offset > $len) throw RangeError(WRONG_LENGTH);\n          }\n          length = byteLength / BYTES;\n        } else if (TYPED_ARRAY in data) {\n          return fromList(TypedArray, data);\n        } else {\n          return $from.call(TypedArray, data);\n        }\n        hide(that, '_d', {\n          b: buffer,\n          o: offset,\n          l: byteLength,\n          e: length,\n          v: new $DataView(buffer)\n        });\n        while (index < length) addElement(that, index++);\n      });\n      TypedArrayPrototype = TypedArray[PROTOTYPE] = create($TypedArrayPrototype$);\n      hide(TypedArrayPrototype, 'constructor', TypedArray);\n    } else if (!fails(function () {\n      TypedArray(1);\n    }) || !fails(function () {\n      new TypedArray(-1); // eslint-disable-line no-new\n    }) || !$iterDetect(function (iter) {\n      new TypedArray(); // eslint-disable-line no-new\n      new TypedArray(null); // eslint-disable-line no-new\n      new TypedArray(1.5); // eslint-disable-line no-new\n      new TypedArray(iter); // eslint-disable-line no-new\n    }, true)) {\n      TypedArray = wrapper(function (that, data, $offset, $length) {\n        anInstance(that, TypedArray, NAME);\n        var klass;\n        // `ws` module bug, temporarily remove validation length for Uint8Array\n        // https://github.com/websockets/ws/pull/645\n        if (!isObject(data)) return new Base(toIndex(data));\n        if (data instanceof $ArrayBuffer || (klass = classof(data)) == ARRAY_BUFFER || klass == SHARED_BUFFER) {\n          return $length !== undefined\n            ? new Base(data, toOffset($offset, BYTES), $length)\n            : $offset !== undefined\n              ? new Base(data, toOffset($offset, BYTES))\n              : new Base(data);\n        }\n        if (TYPED_ARRAY in data) return fromList(TypedArray, data);\n        return $from.call(TypedArray, data);\n      });\n      arrayForEach(TAC !== Function.prototype ? gOPN(Base).concat(gOPN(TAC)) : gOPN(Base), function (key) {\n        if (!(key in TypedArray)) hide(TypedArray, key, Base[key]);\n      });\n      TypedArray[PROTOTYPE] = TypedArrayPrototype;\n      if (!LIBRARY) TypedArrayPrototype.constructor = TypedArray;\n    }\n    var $nativeIterator = TypedArrayPrototype[ITERATOR];\n    var CORRECT_ITER_NAME = !!$nativeIterator\n      && ($nativeIterator.name == 'values' || $nativeIterator.name == undefined);\n    var $iterator = $iterators.values;\n    hide(TypedArray, TYPED_CONSTRUCTOR, true);\n    hide(TypedArrayPrototype, TYPED_ARRAY, NAME);\n    hide(TypedArrayPrototype, VIEW, true);\n    hide(TypedArrayPrototype, DEF_CONSTRUCTOR, TypedArray);\n\n    if (CLAMPED ? new TypedArray(1)[TAG] != NAME : !(TAG in TypedArrayPrototype)) {\n      dP(TypedArrayPrototype, TAG, {\n        get: function () { return NAME; }\n      });\n    }\n\n    O[NAME] = TypedArray;\n\n    $export($export.G + $export.W + $export.F * (TypedArray != Base), O);\n\n    $export($export.S, NAME, {\n      BYTES_PER_ELEMENT: BYTES\n    });\n\n    $export($export.S + $export.F * fails(function () { Base.of.call(TypedArray, 1); }), NAME, {\n      from: $from,\n      of: $of\n    });\n\n    if (!(BYTES_PER_ELEMENT in TypedArrayPrototype)) hide(TypedArrayPrototype, BYTES_PER_ELEMENT, BYTES);\n\n    $export($export.P, NAME, proto);\n\n    setSpecies(NAME);\n\n    $export($export.P + $export.F * FORCED_SET, NAME, { set: $set });\n\n    $export($export.P + $export.F * !CORRECT_ITER_NAME, NAME, $iterators);\n\n    if (!LIBRARY && TypedArrayPrototype.toString != arrayToString) TypedArrayPrototype.toString = arrayToString;\n\n    $export($export.P + $export.F * fails(function () {\n      new TypedArray(1).slice();\n    }), NAME, { slice: $slice });\n\n    $export($export.P + $export.F * (fails(function () {\n      return [1, 2].toLocaleString() != new TypedArray([1, 2]).toLocaleString();\n    }) || !fails(function () {\n      TypedArrayPrototype.toLocaleString.call([1, 2]);\n    })), NAME, { toLocaleString: $toLocaleString });\n\n    Iterators[NAME] = CORRECT_ITER_NAME ? $nativeIterator : $iterator;\n    if (!LIBRARY && !CORRECT_ITER_NAME) hide(TypedArrayPrototype, ITERATOR, $iterator);\n  };\n} else module.exports = function () { /* empty */ };\n","'use strict';\nvar global = require('./_global');\nvar DESCRIPTORS = require('./_descriptors');\nvar LIBRARY = require('./_library');\nvar $typed = require('./_typed');\nvar hide = require('./_hide');\nvar redefineAll = require('./_redefine-all');\nvar fails = require('./_fails');\nvar anInstance = require('./_an-instance');\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nvar toIndex = require('./_to-index');\nvar gOPN = require('./_object-gopn').f;\nvar dP = require('./_object-dp').f;\nvar arrayFill = require('./_array-fill');\nvar setToStringTag = require('./_set-to-string-tag');\nvar ARRAY_BUFFER = 'ArrayBuffer';\nvar DATA_VIEW = 'DataView';\nvar PROTOTYPE = 'prototype';\nvar WRONG_LENGTH = 'Wrong length!';\nvar WRONG_INDEX = 'Wrong index!';\nvar $ArrayBuffer = global[ARRAY_BUFFER];\nvar $DataView = global[DATA_VIEW];\nvar Math = global.Math;\nvar RangeError = global.RangeError;\n// eslint-disable-next-line no-shadow-restricted-names\nvar Infinity = global.Infinity;\nvar BaseBuffer = $ArrayBuffer;\nvar abs = Math.abs;\nvar pow = Math.pow;\nvar floor = Math.floor;\nvar log = Math.log;\nvar LN2 = Math.LN2;\nvar BUFFER = 'buffer';\nvar BYTE_LENGTH = 'byteLength';\nvar BYTE_OFFSET = 'byteOffset';\nvar $BUFFER = DESCRIPTORS ? '_b' : BUFFER;\nvar $LENGTH = DESCRIPTORS ? '_l' : BYTE_LENGTH;\nvar $OFFSET = DESCRIPTORS ? '_o' : BYTE_OFFSET;\n\n// IEEE754 conversions based on https://github.com/feross/ieee754\nfunction packIEEE754(value, mLen, nBytes) {\n  var buffer = new Array(nBytes);\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var rt = mLen === 23 ? pow(2, -24) - pow(2, -77) : 0;\n  var i = 0;\n  var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;\n  var e, m, c;\n  value = abs(value);\n  // eslint-disable-next-line no-self-compare\n  if (value != value || value === Infinity) {\n    // eslint-disable-next-line no-self-compare\n    m = value != value ? 1 : 0;\n    e = eMax;\n  } else {\n    e = floor(log(value) / LN2);\n    if (value * (c = pow(2, -e)) < 1) {\n      e--;\n      c *= 2;\n    }\n    if (e + eBias >= 1) {\n      value += rt / c;\n    } else {\n      value += rt * pow(2, 1 - eBias);\n    }\n    if (value * c >= 2) {\n      e++;\n      c /= 2;\n    }\n    if (e + eBias >= eMax) {\n      m = 0;\n      e = eMax;\n    } else if (e + eBias >= 1) {\n      m = (value * c - 1) * pow(2, mLen);\n      e = e + eBias;\n    } else {\n      m = value * pow(2, eBias - 1) * pow(2, mLen);\n      e = 0;\n    }\n  }\n  for (; mLen >= 8; buffer[i++] = m & 255, m /= 256, mLen -= 8);\n  e = e << mLen | m;\n  eLen += mLen;\n  for (; eLen > 0; buffer[i++] = e & 255, e /= 256, eLen -= 8);\n  buffer[--i] |= s * 128;\n  return buffer;\n}\nfunction unpackIEEE754(buffer, mLen, nBytes) {\n  var eLen = nBytes * 8 - mLen - 1;\n  var eMax = (1 << eLen) - 1;\n  var eBias = eMax >> 1;\n  var nBits = eLen - 7;\n  var i = nBytes - 1;\n  var s = buffer[i--];\n  var e = s & 127;\n  var m;\n  s >>= 7;\n  for (; nBits > 0; e = e * 256 + buffer[i], i--, nBits -= 8);\n  m = e & (1 << -nBits) - 1;\n  e >>= -nBits;\n  nBits += mLen;\n  for (; nBits > 0; m = m * 256 + buffer[i], i--, nBits -= 8);\n  if (e === 0) {\n    e = 1 - eBias;\n  } else if (e === eMax) {\n    return m ? NaN : s ? -Infinity : Infinity;\n  } else {\n    m = m + pow(2, mLen);\n    e = e - eBias;\n  } return (s ? -1 : 1) * m * pow(2, e - mLen);\n}\n\nfunction unpackI32(bytes) {\n  return bytes[3] << 24 | bytes[2] << 16 | bytes[1] << 8 | bytes[0];\n}\nfunction packI8(it) {\n  return [it & 0xff];\n}\nfunction packI16(it) {\n  return [it & 0xff, it >> 8 & 0xff];\n}\nfunction packI32(it) {\n  return [it & 0xff, it >> 8 & 0xff, it >> 16 & 0xff, it >> 24 & 0xff];\n}\nfunction packF64(it) {\n  return packIEEE754(it, 52, 8);\n}\nfunction packF32(it) {\n  return packIEEE754(it, 23, 4);\n}\n\nfunction addGetter(C, key, internal) {\n  dP(C[PROTOTYPE], key, { get: function () { return this[internal]; } });\n}\n\nfunction get(view, bytes, index, isLittleEndian) {\n  var numIndex = +index;\n  var intIndex = toIndex(numIndex);\n  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);\n  var store = view[$BUFFER]._b;\n  var start = intIndex + view[$OFFSET];\n  var pack = store.slice(start, start + bytes);\n  return isLittleEndian ? pack : pack.reverse();\n}\nfunction set(view, bytes, index, conversion, value, isLittleEndian) {\n  var numIndex = +index;\n  var intIndex = toIndex(numIndex);\n  if (intIndex + bytes > view[$LENGTH]) throw RangeError(WRONG_INDEX);\n  var store = view[$BUFFER]._b;\n  var start = intIndex + view[$OFFSET];\n  var pack = conversion(+value);\n  for (var i = 0; i < bytes; i++) store[start + i] = pack[isLittleEndian ? i : bytes - i - 1];\n}\n\nif (!$typed.ABV) {\n  $ArrayBuffer = function ArrayBuffer(length) {\n    anInstance(this, $ArrayBuffer, ARRAY_BUFFER);\n    var byteLength = toIndex(length);\n    this._b = arrayFill.call(new Array(byteLength), 0);\n    this[$LENGTH] = byteLength;\n  };\n\n  $DataView = function DataView(buffer, byteOffset, byteLength) {\n    anInstance(this, $DataView, DATA_VIEW);\n    anInstance(buffer, $ArrayBuffer, DATA_VIEW);\n    var bufferLength = buffer[$LENGTH];\n    var offset = toInteger(byteOffset);\n    if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset!');\n    byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);\n    if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);\n    this[$BUFFER] = buffer;\n    this[$OFFSET] = offset;\n    this[$LENGTH] = byteLength;\n  };\n\n  if (DESCRIPTORS) {\n    addGetter($ArrayBuffer, BYTE_LENGTH, '_l');\n    addGetter($DataView, BUFFER, '_b');\n    addGetter($DataView, BYTE_LENGTH, '_l');\n    addGetter($DataView, BYTE_OFFSET, '_o');\n  }\n\n  redefineAll($DataView[PROTOTYPE], {\n    getInt8: function getInt8(byteOffset) {\n      return get(this, 1, byteOffset)[0] << 24 >> 24;\n    },\n    getUint8: function getUint8(byteOffset) {\n      return get(this, 1, byteOffset)[0];\n    },\n    getInt16: function getInt16(byteOffset /* , littleEndian */) {\n      var bytes = get(this, 2, byteOffset, arguments[1]);\n      return (bytes[1] << 8 | bytes[0]) << 16 >> 16;\n    },\n    getUint16: function getUint16(byteOffset /* , littleEndian */) {\n      var bytes = get(this, 2, byteOffset, arguments[1]);\n      return bytes[1] << 8 | bytes[0];\n    },\n    getInt32: function getInt32(byteOffset /* , littleEndian */) {\n      return unpackI32(get(this, 4, byteOffset, arguments[1]));\n    },\n    getUint32: function getUint32(byteOffset /* , littleEndian */) {\n      return unpackI32(get(this, 4, byteOffset, arguments[1])) >>> 0;\n    },\n    getFloat32: function getFloat32(byteOffset /* , littleEndian */) {\n      return unpackIEEE754(get(this, 4, byteOffset, arguments[1]), 23, 4);\n    },\n    getFloat64: function getFloat64(byteOffset /* , littleEndian */) {\n      return unpackIEEE754(get(this, 8, byteOffset, arguments[1]), 52, 8);\n    },\n    setInt8: function setInt8(byteOffset, value) {\n      set(this, 1, byteOffset, packI8, value);\n    },\n    setUint8: function setUint8(byteOffset, value) {\n      set(this, 1, byteOffset, packI8, value);\n    },\n    setInt16: function setInt16(byteOffset, value /* , littleEndian */) {\n      set(this, 2, byteOffset, packI16, value, arguments[2]);\n    },\n    setUint16: function setUint16(byteOffset, value /* , littleEndian */) {\n      set(this, 2, byteOffset, packI16, value, arguments[2]);\n    },\n    setInt32: function setInt32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packI32, value, arguments[2]);\n    },\n    setUint32: function setUint32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packI32, value, arguments[2]);\n    },\n    setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {\n      set(this, 4, byteOffset, packF32, value, arguments[2]);\n    },\n    setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {\n      set(this, 8, byteOffset, packF64, value, arguments[2]);\n    }\n  });\n} else {\n  if (!fails(function () {\n    $ArrayBuffer(1);\n  }) || !fails(function () {\n    new $ArrayBuffer(-1); // eslint-disable-line no-new\n  }) || fails(function () {\n    new $ArrayBuffer(); // eslint-disable-line no-new\n    new $ArrayBuffer(1.5); // eslint-disable-line no-new\n    new $ArrayBuffer(NaN); // eslint-disable-line no-new\n    return $ArrayBuffer.name != ARRAY_BUFFER;\n  })) {\n    $ArrayBuffer = function ArrayBuffer(length) {\n      anInstance(this, $ArrayBuffer);\n      return new BaseBuffer(toIndex(length));\n    };\n    var ArrayBufferProto = $ArrayBuffer[PROTOTYPE] = BaseBuffer[PROTOTYPE];\n    for (var keys = gOPN(BaseBuffer), j = 0, key; keys.length > j;) {\n      if (!((key = keys[j++]) in $ArrayBuffer)) hide($ArrayBuffer, key, BaseBuffer[key]);\n    }\n    if (!LIBRARY) ArrayBufferProto.constructor = $ArrayBuffer;\n  }\n  // iOS Safari 7.x bug\n  var view = new $DataView(new $ArrayBuffer(2));\n  var $setInt8 = $DataView[PROTOTYPE].setInt8;\n  view.setInt8(0, 2147483648);\n  view.setInt8(1, 2147483649);\n  if (view.getInt8(0) || !view.getInt8(1)) redefineAll($DataView[PROTOTYPE], {\n    setInt8: function setInt8(byteOffset, value) {\n      $setInt8.call(this, byteOffset, value << 24 >> 24);\n    },\n    setUint8: function setUint8(byteOffset, value) {\n      $setInt8.call(this, byteOffset, value << 24 >> 24);\n    }\n  }, true);\n}\nsetToStringTag($ArrayBuffer, ARRAY_BUFFER);\nsetToStringTag($DataView, DATA_VIEW);\nhide($DataView[PROTOTYPE], $typed.VIEW, true);\nexports[ARRAY_BUFFER] = $ArrayBuffer;\nexports[DATA_VIEW] = $DataView;\n","var global = require('./_global');\nvar hide = require('./_hide');\nvar uid = require('./_uid');\nvar TYPED = uid('typed_array');\nvar VIEW = uid('view');\nvar ABV = !!(global.ArrayBuffer && global.DataView);\nvar CONSTR = ABV;\nvar i = 0;\nvar l = 9;\nvar Typed;\n\nvar TypedArrayConstructors = (\n  'Int8Array,Uint8Array,Uint8ClampedArray,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array'\n).split(',');\n\nwhile (i < l) {\n  if (Typed = global[TypedArrayConstructors[i++]]) {\n    hide(Typed.prototype, TYPED, true);\n    hide(Typed.prototype, VIEW, true);\n  } else CONSTR = false;\n}\n\nmodule.exports = {\n  ABV: ABV,\n  CONSTR: CONSTR,\n  TYPED: TYPED,\n  VIEW: VIEW\n};\n","var id = 0;\nvar px = Math.random();\nmodule.exports = function (key) {\n  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n","var global = require('./_global');\nvar navigator = global.navigator;\n\nmodule.exports = navigator && navigator.userAgent || '';\n","var isObject = require('./_is-object');\nmodule.exports = function (it, TYPE) {\n  if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');\n  return it;\n};\n","var global = require('./_global');\nvar core = require('./_core');\nvar LIBRARY = require('./_library');\nvar wksExt = require('./_wks-ext');\nvar defineProperty = require('./_object-dp').f;\nmodule.exports = function (name) {\n  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});\n  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, { value: wksExt.f(name) });\n};\n","exports.f = require('./_wks');\n","var store = require('./_shared')('wks');\nvar uid = require('./_uid');\nvar Symbol = require('./_global').Symbol;\nvar USE_SYMBOL = typeof Symbol == 'function';\n\nvar $exports = module.exports = function (name) {\n  return store[name] || (store[name] =\n    USE_SYMBOL && Symbol[name] || (USE_SYMBOL ? Symbol : uid)('Symbol.' + name));\n};\n\n$exports.store = store;\n","var classof = require('./_classof');\nvar ITERATOR = require('./_wks')('iterator');\nvar Iterators = require('./_iterators');\nmodule.exports = require('./_core').getIteratorMethod = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","// https://github.com/benjamingr/RexExp.escape\nvar $export = require('./_export');\nvar $re = require('./_replacer')(/[\\\\^$*+?.()|[\\]{}]/g, '\\\\$&');\n\n$export($export.S, 'RegExp', { escape: function escape(it) { return $re(it); } });\n","// 22.1.3.3 Array.prototype.copyWithin(target, start, end = this.length)\nvar $export = require('./_export');\n\n$export($export.P, 'Array', { copyWithin: require('./_array-copy-within') });\n\nrequire('./_add-to-unscopables')('copyWithin');\n","'use strict';\nvar $export = require('./_export');\nvar $every = require('./_array-methods')(4);\n\n$export($export.P + $export.F * !require('./_strict-method')([].every, true), 'Array', {\n  // 22.1.3.5 / 15.4.4.16 Array.prototype.every(callbackfn [, thisArg])\n  every: function every(callbackfn /* , thisArg */) {\n    return $every(this, callbackfn, arguments[1]);\n  }\n});\n","// 22.1.3.6 Array.prototype.fill(value, start = 0, end = this.length)\nvar $export = require('./_export');\n\n$export($export.P, 'Array', { fill: require('./_array-fill') });\n\nrequire('./_add-to-unscopables')('fill');\n","'use strict';\nvar $export = require('./_export');\nvar $filter = require('./_array-methods')(2);\n\n$export($export.P + $export.F * !require('./_strict-method')([].filter, true), 'Array', {\n  // 22.1.3.7 / 15.4.4.20 Array.prototype.filter(callbackfn [, thisArg])\n  filter: function filter(callbackfn /* , thisArg */) {\n    return $filter(this, callbackfn, arguments[1]);\n  }\n});\n","'use strict';\n// 22.1.3.9 Array.prototype.findIndex(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(6);\nvar KEY = 'findIndex';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n  findIndex: function findIndex(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\nrequire('./_add-to-unscopables')(KEY);\n","'use strict';\n// 22.1.3.8 Array.prototype.find(predicate, thisArg = undefined)\nvar $export = require('./_export');\nvar $find = require('./_array-methods')(5);\nvar KEY = 'find';\nvar forced = true;\n// Shouldn't skip holes\nif (KEY in []) Array(1)[KEY](function () { forced = false; });\n$export($export.P + $export.F * forced, 'Array', {\n  find: function find(callbackfn /* , that = undefined */) {\n    return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\nrequire('./_add-to-unscopables')(KEY);\n","'use strict';\nvar $export = require('./_export');\nvar $forEach = require('./_array-methods')(0);\nvar STRICT = require('./_strict-method')([].forEach, true);\n\n$export($export.P + $export.F * !STRICT, 'Array', {\n  // 22.1.3.10 / 15.4.4.18 Array.prototype.forEach(callbackfn [, thisArg])\n  forEach: function forEach(callbackfn /* , thisArg */) {\n    return $forEach(this, callbackfn, arguments[1]);\n  }\n});\n","'use strict';\nvar ctx = require('./_ctx');\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar call = require('./_iter-call');\nvar isArrayIter = require('./_is-array-iter');\nvar toLength = require('./_to-length');\nvar createProperty = require('./_create-property');\nvar getIterFn = require('./core.get-iterator-method');\n\n$export($export.S + $export.F * !require('./_iter-detect')(function (iter) { Array.from(iter); }), 'Array', {\n  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)\n  from: function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n    var O = toObject(arrayLike);\n    var C = typeof this == 'function' ? this : Array;\n    var aLen = arguments.length;\n    var mapfn = aLen > 1 ? arguments[1] : undefined;\n    var mapping = mapfn !== undefined;\n    var index = 0;\n    var iterFn = getIterFn(O);\n    var length, result, step, iterator;\n    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);\n    // if object isn't iterable or it's array with default iterator - use simple case\n    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {\n      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {\n        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);\n      }\n    } else {\n      length = toLength(O.length);\n      for (result = new C(length); length > index; index++) {\n        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);\n      }\n    }\n    result.length = index;\n    return result;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $indexOf = require('./_array-includes')(false);\nvar $native = [].indexOf;\nvar NEGATIVE_ZERO = !!$native && 1 / [1].indexOf(1, -0) < 0;\n\n$export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', {\n  // 22.1.3.11 / 15.4.4.14 Array.prototype.indexOf(searchElement [, fromIndex])\n  indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {\n    return NEGATIVE_ZERO\n      // convert -0 to +0\n      ? $native.apply(this, arguments) || 0\n      : $indexOf(this, searchElement, arguments[1]);\n  }\n});\n","// 22.1.2.2 / 15.4.3.2 Array.isArray(arg)\nvar $export = require('./_export');\n\n$export($export.S, 'Array', { isArray: require('./_is-array') });\n","'use strict';\nvar addToUnscopables = require('./_add-to-unscopables');\nvar step = require('./_iter-step');\nvar Iterators = require('./_iterators');\nvar toIObject = require('./_to-iobject');\n\n// 22.1.3.4 Array.prototype.entries()\n// 22.1.3.13 Array.prototype.keys()\n// 22.1.3.29 Array.prototype.values()\n// 22.1.3.30 Array.prototype[@@iterator]()\nmodule.exports = require('./_iter-define')(Array, 'Array', function (iterated, kind) {\n  this._t = toIObject(iterated); // target\n  this._i = 0;                   // next index\n  this._k = kind;                // kind\n// 22.1.5.2.1 %ArrayIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var kind = this._k;\n  var index = this._i++;\n  if (!O || index >= O.length) {\n    this._t = undefined;\n    return step(1);\n  }\n  if (kind == 'keys') return step(0, index);\n  if (kind == 'values') return step(0, O[index]);\n  return step(0, [index, O[index]]);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)\nIterators.Arguments = Iterators.Array;\n\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","'use strict';\n// 22.1.3.13 Array.prototype.join(separator)\nvar $export = require('./_export');\nvar toIObject = require('./_to-iobject');\nvar arrayJoin = [].join;\n\n// fallback for not array-like strings\n$export($export.P + $export.F * (require('./_iobject') != Object || !require('./_strict-method')(arrayJoin)), 'Array', {\n  join: function join(separator) {\n    return arrayJoin.call(toIObject(this), separator === undefined ? ',' : separator);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar toIObject = require('./_to-iobject');\nvar toInteger = require('./_to-integer');\nvar toLength = require('./_to-length');\nvar $native = [].lastIndexOf;\nvar NEGATIVE_ZERO = !!$native && 1 / [1].lastIndexOf(1, -0) < 0;\n\n$export($export.P + $export.F * (NEGATIVE_ZERO || !require('./_strict-method')($native)), 'Array', {\n  // 22.1.3.14 / 15.4.4.15 Array.prototype.lastIndexOf(searchElement [, fromIndex])\n  lastIndexOf: function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {\n    // convert -0 to +0\n    if (NEGATIVE_ZERO) return $native.apply(this, arguments) || 0;\n    var O = toIObject(this);\n    var length = toLength(O.length);\n    var index = length - 1;\n    if (arguments.length > 1) index = Math.min(index, toInteger(arguments[1]));\n    if (index < 0) index = length + index;\n    for (;index >= 0; index--) if (index in O) if (O[index] === searchElement) return index || 0;\n    return -1;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $map = require('./_array-methods')(1);\n\n$export($export.P + $export.F * !require('./_strict-method')([].map, true), 'Array', {\n  // 22.1.3.15 / 15.4.4.19 Array.prototype.map(callbackfn [, thisArg])\n  map: function map(callbackfn /* , thisArg */) {\n    return $map(this, callbackfn, arguments[1]);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar createProperty = require('./_create-property');\n\n// WebKit Array.of isn't generic\n$export($export.S + $export.F * require('./_fails')(function () {\n  function F() { /* empty */ }\n  return !(Array.of.call(F) instanceof F);\n}), 'Array', {\n  // 22.1.2.3 Array.of( ...items)\n  of: function of(/* ...args */) {\n    var index = 0;\n    var aLen = arguments.length;\n    var result = new (typeof this == 'function' ? this : Array)(aLen);\n    while (aLen > index) createProperty(result, index, arguments[index++]);\n    result.length = aLen;\n    return result;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $reduce = require('./_array-reduce');\n\n$export($export.P + $export.F * !require('./_strict-method')([].reduceRight, true), 'Array', {\n  // 22.1.3.19 / 15.4.4.22 Array.prototype.reduceRight(callbackfn [, initialValue])\n  reduceRight: function reduceRight(callbackfn /* , initialValue */) {\n    return $reduce(this, callbackfn, arguments.length, arguments[1], true);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $reduce = require('./_array-reduce');\n\n$export($export.P + $export.F * !require('./_strict-method')([].reduce, true), 'Array', {\n  // 22.1.3.18 / 15.4.4.21 Array.prototype.reduce(callbackfn [, initialValue])\n  reduce: function reduce(callbackfn /* , initialValue */) {\n    return $reduce(this, callbackfn, arguments.length, arguments[1], false);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar html = require('./_html');\nvar cof = require('./_cof');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\nvar arraySlice = [].slice;\n\n// fallback for not array-like ES3 strings and DOM objects\n$export($export.P + $export.F * require('./_fails')(function () {\n  if (html) arraySlice.call(html);\n}), 'Array', {\n  slice: function slice(begin, end) {\n    var len = toLength(this.length);\n    var klass = cof(this);\n    end = end === undefined ? len : end;\n    if (klass == 'Array') return arraySlice.call(this, begin, end);\n    var start = toAbsoluteIndex(begin, len);\n    var upTo = toAbsoluteIndex(end, len);\n    var size = toLength(upTo - start);\n    var cloned = new Array(size);\n    var i = 0;\n    for (; i < size; i++) cloned[i] = klass == 'String'\n      ? this.charAt(start + i)\n      : this[start + i];\n    return cloned;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $some = require('./_array-methods')(3);\n\n$export($export.P + $export.F * !require('./_strict-method')([].some, true), 'Array', {\n  // 22.1.3.23 / 15.4.4.17 Array.prototype.some(callbackfn [, thisArg])\n  some: function some(callbackfn /* , thisArg */) {\n    return $some(this, callbackfn, arguments[1]);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar aFunction = require('./_a-function');\nvar toObject = require('./_to-object');\nvar fails = require('./_fails');\nvar $sort = [].sort;\nvar test = [1, 2, 3];\n\n$export($export.P + $export.F * (fails(function () {\n  // IE8-\n  test.sort(undefined);\n}) || !fails(function () {\n  // V8 bug\n  test.sort(null);\n  // Old WebKit\n}) || !require('./_strict-method')($sort)), 'Array', {\n  // 22.1.3.25 Array.prototype.sort(comparefn)\n  sort: function sort(comparefn) {\n    return comparefn === undefined\n      ? $sort.call(toObject(this))\n      : $sort.call(toObject(this), aFunction(comparefn));\n  }\n});\n","require('./_set-species')('Array');\n","// 20.3.3.1 / 15.9.4.4 Date.now()\nvar $export = require('./_export');\n\n$export($export.S, 'Date', { now: function () { return new Date().getTime(); } });\n","// 20.3.4.36 / 15.9.5.43 Date.prototype.toISOString()\nvar $export = require('./_export');\nvar toISOString = require('./_date-to-iso-string');\n\n// PhantomJS / old WebKit has a broken implementations\n$export($export.P + $export.F * (Date.prototype.toISOString !== toISOString), 'Date', {\n  toISOString: toISOString\n});\n","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar toPrimitive = require('./_to-primitive');\n\n$export($export.P + $export.F * require('./_fails')(function () {\n  return new Date(NaN).toJSON() !== null\n    || Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;\n}), 'Date', {\n  // eslint-disable-next-line no-unused-vars\n  toJSON: function toJSON(key) {\n    var O = toObject(this);\n    var pv = toPrimitive(O);\n    return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();\n  }\n});\n","var TO_PRIMITIVE = require('./_wks')('toPrimitive');\nvar proto = Date.prototype;\n\nif (!(TO_PRIMITIVE in proto)) require('./_hide')(proto, TO_PRIMITIVE, require('./_date-to-primitive'));\n","var DateProto = Date.prototype;\nvar INVALID_DATE = 'Invalid Date';\nvar TO_STRING = 'toString';\nvar $toString = DateProto[TO_STRING];\nvar getTime = DateProto.getTime;\nif (new Date(NaN) + '' != INVALID_DATE) {\n  require('./_redefine')(DateProto, TO_STRING, function toString() {\n    var value = getTime.call(this);\n    // eslint-disable-next-line no-self-compare\n    return value === value ? $toString.call(this) : INVALID_DATE;\n  });\n}\n","// 19.2.3.2 / 15.3.4.5 Function.prototype.bind(thisArg, args...)\nvar $export = require('./_export');\n\n$export($export.P, 'Function', { bind: require('./_bind') });\n","'use strict';\nvar isObject = require('./_is-object');\nvar getPrototypeOf = require('./_object-gpo');\nvar HAS_INSTANCE = require('./_wks')('hasInstance');\nvar FunctionProto = Function.prototype;\n// 19.2.3.6 Function.prototype[@@hasInstance](V)\nif (!(HAS_INSTANCE in FunctionProto)) require('./_object-dp').f(FunctionProto, HAS_INSTANCE, { value: function (O) {\n  if (typeof this != 'function' || !isObject(O)) return false;\n  if (!isObject(this.prototype)) return O instanceof this;\n  // for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:\n  while (O = getPrototypeOf(O)) if (this.prototype === O) return true;\n  return false;\n} });\n","var dP = require('./_object-dp').f;\nvar FProto = Function.prototype;\nvar nameRE = /^\\s*function ([^ (]*)/;\nvar NAME = 'name';\n\n// 19.2.4.2 name\nNAME in FProto || require('./_descriptors') && dP(FProto, NAME, {\n  configurable: true,\n  get: function () {\n    try {\n      return ('' + this).match(nameRE)[1];\n    } catch (e) {\n      return '';\n    }\n  }\n});\n","'use strict';\nvar strong = require('./_collection-strong');\nvar validate = require('./_validate-collection');\nvar MAP = 'Map';\n\n// 23.1 Map Objects\nmodule.exports = require('./_collection')(MAP, function (get) {\n  return function Map() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };\n}, {\n  // 23.1.3.6 Map.prototype.get(key)\n  get: function get(key) {\n    var entry = strong.getEntry(validate(this, MAP), key);\n    return entry && entry.v;\n  },\n  // 23.1.3.9 Map.prototype.set(key, value)\n  set: function set(key, value) {\n    return strong.def(validate(this, MAP), key === 0 ? 0 : key, value);\n  }\n}, strong, true);\n","// 20.2.2.3 Math.acosh(x)\nvar $export = require('./_export');\nvar log1p = require('./_math-log1p');\nvar sqrt = Math.sqrt;\nvar $acosh = Math.acosh;\n\n$export($export.S + $export.F * !($acosh\n  // V8 bug: https://code.google.com/p/v8/issues/detail?id=3509\n  && Math.floor($acosh(Number.MAX_VALUE)) == 710\n  // Tor Browser bug: Math.acosh(Infinity) -> NaN\n  && $acosh(Infinity) == Infinity\n), 'Math', {\n  acosh: function acosh(x) {\n    return (x = +x) < 1 ? NaN : x > 94906265.62425156\n      ? Math.log(x) + Math.LN2\n      : log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));\n  }\n});\n","// 20.2.2.5 Math.asinh(x)\nvar $export = require('./_export');\nvar $asinh = Math.asinh;\n\nfunction asinh(x) {\n  return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : Math.log(x + Math.sqrt(x * x + 1));\n}\n\n// Tor Browser bug: Math.asinh(0) -> -0\n$export($export.S + $export.F * !($asinh && 1 / $asinh(0) > 0), 'Math', { asinh: asinh });\n","// 20.2.2.7 Math.atanh(x)\nvar $export = require('./_export');\nvar $atanh = Math.atanh;\n\n// Tor Browser bug: Math.atanh(-0) -> 0\n$export($export.S + $export.F * !($atanh && 1 / $atanh(-0) < 0), 'Math', {\n  atanh: function atanh(x) {\n    return (x = +x) == 0 ? x : Math.log((1 + x) / (1 - x)) / 2;\n  }\n});\n","// 20.2.2.9 Math.cbrt(x)\nvar $export = require('./_export');\nvar sign = require('./_math-sign');\n\n$export($export.S, 'Math', {\n  cbrt: function cbrt(x) {\n    return sign(x = +x) * Math.pow(Math.abs(x), 1 / 3);\n  }\n});\n","// 20.2.2.11 Math.clz32(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  clz32: function clz32(x) {\n    return (x >>>= 0) ? 31 - Math.floor(Math.log(x + 0.5) * Math.LOG2E) : 32;\n  }\n});\n","// 20.2.2.12 Math.cosh(x)\nvar $export = require('./_export');\nvar exp = Math.exp;\n\n$export($export.S, 'Math', {\n  cosh: function cosh(x) {\n    return (exp(x = +x) + exp(-x)) / 2;\n  }\n});\n","// 20.2.2.14 Math.expm1(x)\nvar $export = require('./_export');\nvar $expm1 = require('./_math-expm1');\n\n$export($export.S + $export.F * ($expm1 != Math.expm1), 'Math', { expm1: $expm1 });\n","// 20.2.2.16 Math.fround(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { fround: require('./_math-fround') });\n","// 20.2.2.17 Math.hypot([value1[, value2[, … ]]])\nvar $export = require('./_export');\nvar abs = Math.abs;\n\n$export($export.S, 'Math', {\n  hypot: function hypot(value1, value2) { // eslint-disable-line no-unused-vars\n    var sum = 0;\n    var i = 0;\n    var aLen = arguments.length;\n    var larg = 0;\n    var arg, div;\n    while (i < aLen) {\n      arg = abs(arguments[i++]);\n      if (larg < arg) {\n        div = larg / arg;\n        sum = sum * div * div + 1;\n        larg = arg;\n      } else if (arg > 0) {\n        div = arg / larg;\n        sum += div * div;\n      } else sum += arg;\n    }\n    return larg === Infinity ? Infinity : larg * Math.sqrt(sum);\n  }\n});\n","// 20.2.2.18 Math.imul(x, y)\nvar $export = require('./_export');\nvar $imul = Math.imul;\n\n// some WebKit versions fails with big numbers, some has wrong arity\n$export($export.S + $export.F * require('./_fails')(function () {\n  return $imul(0xffffffff, 5) != -5 || $imul.length != 2;\n}), 'Math', {\n  imul: function imul(x, y) {\n    var UINT16 = 0xffff;\n    var xn = +x;\n    var yn = +y;\n    var xl = UINT16 & xn;\n    var yl = UINT16 & yn;\n    return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);\n  }\n});\n","// 20.2.2.21 Math.log10(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  log10: function log10(x) {\n    return Math.log(x) * Math.LOG10E;\n  }\n});\n","// 20.2.2.20 Math.log1p(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { log1p: require('./_math-log1p') });\n","// 20.2.2.22 Math.log2(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  log2: function log2(x) {\n    return Math.log(x) / Math.LN2;\n  }\n});\n","// 20.2.2.28 Math.sign(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { sign: require('./_math-sign') });\n","// 20.2.2.30 Math.sinh(x)\nvar $export = require('./_export');\nvar expm1 = require('./_math-expm1');\nvar exp = Math.exp;\n\n// V8 near Chromium 38 has a problem with very small numbers\n$export($export.S + $export.F * require('./_fails')(function () {\n  return !Math.sinh(-2e-17) != -2e-17;\n}), 'Math', {\n  sinh: function sinh(x) {\n    return Math.abs(x = +x) < 1\n      ? (expm1(x) - expm1(-x)) / 2\n      : (exp(x - 1) - exp(-x - 1)) * (Math.E / 2);\n  }\n});\n","// 20.2.2.33 Math.tanh(x)\nvar $export = require('./_export');\nvar expm1 = require('./_math-expm1');\nvar exp = Math.exp;\n\n$export($export.S, 'Math', {\n  tanh: function tanh(x) {\n    var a = expm1(x = +x);\n    var b = expm1(-x);\n    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));\n  }\n});\n","// 20.2.2.34 Math.trunc(x)\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  trunc: function trunc(it) {\n    return (it > 0 ? Math.floor : Math.ceil)(it);\n  }\n});\n","'use strict';\nvar global = require('./_global');\nvar has = require('./_has');\nvar cof = require('./_cof');\nvar inheritIfRequired = require('./_inherit-if-required');\nvar toPrimitive = require('./_to-primitive');\nvar fails = require('./_fails');\nvar gOPN = require('./_object-gopn').f;\nvar gOPD = require('./_object-gopd').f;\nvar dP = require('./_object-dp').f;\nvar $trim = require('./_string-trim').trim;\nvar NUMBER = 'Number';\nvar $Number = global[NUMBER];\nvar Base = $Number;\nvar proto = $Number.prototype;\n// Opera ~12 has broken Object#toString\nvar BROKEN_COF = cof(require('./_object-create')(proto)) == NUMBER;\nvar TRIM = 'trim' in String.prototype;\n\n// 7.1.3 ToNumber(argument)\nvar toNumber = function (argument) {\n  var it = toPrimitive(argument, false);\n  if (typeof it == 'string' && it.length > 2) {\n    it = TRIM ? it.trim() : $trim(it, 3);\n    var first = it.charCodeAt(0);\n    var third, radix, maxCode;\n    if (first === 43 || first === 45) {\n      third = it.charCodeAt(2);\n      if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix\n    } else if (first === 48) {\n      switch (it.charCodeAt(1)) {\n        case 66: case 98: radix = 2; maxCode = 49; break; // fast equal /^0b[01]+$/i\n        case 79: case 111: radix = 8; maxCode = 55; break; // fast equal /^0o[0-7]+$/i\n        default: return +it;\n      }\n      for (var digits = it.slice(2), i = 0, l = digits.length, code; i < l; i++) {\n        code = digits.charCodeAt(i);\n        // parseInt parses a string to a first unavailable symbol\n        // but ToNumber should return NaN if a string contains unavailable symbols\n        if (code < 48 || code > maxCode) return NaN;\n      } return parseInt(digits, radix);\n    }\n  } return +it;\n};\n\nif (!$Number(' 0o1') || !$Number('0b1') || $Number('+0x1')) {\n  $Number = function Number(value) {\n    var it = arguments.length < 1 ? 0 : value;\n    var that = this;\n    return that instanceof $Number\n      // check on 1..constructor(foo) case\n      && (BROKEN_COF ? fails(function () { proto.valueOf.call(that); }) : cof(that) != NUMBER)\n        ? inheritIfRequired(new Base(toNumber(it)), that, $Number) : toNumber(it);\n  };\n  for (var keys = require('./_descriptors') ? gOPN(Base) : (\n    // ES3:\n    'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +\n    // ES6 (in case, if modules with ES6 Number statics required before):\n    'EPSILON,isFinite,isInteger,isNaN,isSafeInteger,MAX_SAFE_INTEGER,' +\n    'MIN_SAFE_INTEGER,parseFloat,parseInt,isInteger'\n  ).split(','), j = 0, key; keys.length > j; j++) {\n    if (has(Base, key = keys[j]) && !has($Number, key)) {\n      dP($Number, key, gOPD(Base, key));\n    }\n  }\n  $Number.prototype = proto;\n  proto.constructor = $Number;\n  require('./_redefine')(global, NUMBER, $Number);\n}\n","// 20.1.2.1 Number.EPSILON\nvar $export = require('./_export');\n\n$export($export.S, 'Number', { EPSILON: Math.pow(2, -52) });\n","// 20.1.2.2 Number.isFinite(number)\nvar $export = require('./_export');\nvar _isFinite = require('./_global').isFinite;\n\n$export($export.S, 'Number', {\n  isFinite: function isFinite(it) {\n    return typeof it == 'number' && _isFinite(it);\n  }\n});\n","// 20.1.2.3 Number.isInteger(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', { isInteger: require('./_is-integer') });\n","// 20.1.2.4 Number.isNaN(number)\nvar $export = require('./_export');\n\n$export($export.S, 'Number', {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare\n    return number != number;\n  }\n});\n","// 20.1.2.5 Number.isSafeInteger(number)\nvar $export = require('./_export');\nvar isInteger = require('./_is-integer');\nvar abs = Math.abs;\n\n$export($export.S, 'Number', {\n  isSafeInteger: function isSafeInteger(number) {\n    return isInteger(number) && abs(number) <= 0x1fffffffffffff;\n  }\n});\n","// 20.1.2.6 Number.MAX_SAFE_INTEGER\nvar $export = require('./_export');\n\n$export($export.S, 'Number', { MAX_SAFE_INTEGER: 0x1fffffffffffff });\n","// 20.1.2.10 Number.MIN_SAFE_INTEGER\nvar $export = require('./_export');\n\n$export($export.S, 'Number', { MIN_SAFE_INTEGER: -0x1fffffffffffff });\n","var $export = require('./_export');\nvar $parseFloat = require('./_parse-float');\n// 20.1.2.12 Number.parseFloat(string)\n$export($export.S + $export.F * (Number.parseFloat != $parseFloat), 'Number', { parseFloat: $parseFloat });\n","var $export = require('./_export');\nvar $parseInt = require('./_parse-int');\n// 20.1.2.13 Number.parseInt(string, radix)\n$export($export.S + $export.F * (Number.parseInt != $parseInt), 'Number', { parseInt: $parseInt });\n","'use strict';\nvar $export = require('./_export');\nvar toInteger = require('./_to-integer');\nvar aNumberValue = require('./_a-number-value');\nvar repeat = require('./_string-repeat');\nvar $toFixed = 1.0.toFixed;\nvar floor = Math.floor;\nvar data = [0, 0, 0, 0, 0, 0];\nvar ERROR = 'Number.toFixed: incorrect invocation!';\nvar ZERO = '0';\n\nvar multiply = function (n, c) {\n  var i = -1;\n  var c2 = c;\n  while (++i < 6) {\n    c2 += n * data[i];\n    data[i] = c2 % 1e7;\n    c2 = floor(c2 / 1e7);\n  }\n};\nvar divide = function (n) {\n  var i = 6;\n  var c = 0;\n  while (--i >= 0) {\n    c += data[i];\n    data[i] = floor(c / n);\n    c = (c % n) * 1e7;\n  }\n};\nvar numToString = function () {\n  var i = 6;\n  var s = '';\n  while (--i >= 0) {\n    if (s !== '' || i === 0 || data[i] !== 0) {\n      var t = String(data[i]);\n      s = s === '' ? t : s + repeat.call(ZERO, 7 - t.length) + t;\n    }\n  } return s;\n};\nvar pow = function (x, n, acc) {\n  return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);\n};\nvar log = function (x) {\n  var n = 0;\n  var x2 = x;\n  while (x2 >= 4096) {\n    n += 12;\n    x2 /= 4096;\n  }\n  while (x2 >= 2) {\n    n += 1;\n    x2 /= 2;\n  } return n;\n};\n\n$export($export.P + $export.F * (!!$toFixed && (\n  0.00008.toFixed(3) !== '0.000' ||\n  0.9.toFixed(0) !== '1' ||\n  1.255.toFixed(2) !== '1.25' ||\n  1000000000000000128.0.toFixed(0) !== '1000000000000000128'\n) || !require('./_fails')(function () {\n  // V8 ~ Android 4.3-\n  $toFixed.call({});\n})), 'Number', {\n  toFixed: function toFixed(fractionDigits) {\n    var x = aNumberValue(this, ERROR);\n    var f = toInteger(fractionDigits);\n    var s = '';\n    var m = ZERO;\n    var e, z, j, k;\n    if (f < 0 || f > 20) throw RangeError(ERROR);\n    // eslint-disable-next-line no-self-compare\n    if (x != x) return 'NaN';\n    if (x <= -1e21 || x >= 1e21) return String(x);\n    if (x < 0) {\n      s = '-';\n      x = -x;\n    }\n    if (x > 1e-21) {\n      e = log(x * pow(2, 69, 1)) - 69;\n      z = e < 0 ? x * pow(2, -e, 1) : x / pow(2, e, 1);\n      z *= 0x10000000000000;\n      e = 52 - e;\n      if (e > 0) {\n        multiply(0, z);\n        j = f;\n        while (j >= 7) {\n          multiply(1e7, 0);\n          j -= 7;\n        }\n        multiply(pow(10, j, 1), 0);\n        j = e - 1;\n        while (j >= 23) {\n          divide(1 << 23);\n          j -= 23;\n        }\n        divide(1 << j);\n        multiply(1, 1);\n        divide(2);\n        m = numToString();\n      } else {\n        multiply(0, z);\n        multiply(1 << -e, 0);\n        m = numToString() + repeat.call(ZERO, f);\n      }\n    }\n    if (f > 0) {\n      k = m.length;\n      m = s + (k <= f ? '0.' + repeat.call(ZERO, f - k) + m : m.slice(0, k - f) + '.' + m.slice(k - f));\n    } else {\n      m = s + m;\n    } return m;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar $fails = require('./_fails');\nvar aNumberValue = require('./_a-number-value');\nvar $toPrecision = 1.0.toPrecision;\n\n$export($export.P + $export.F * ($fails(function () {\n  // IE7-\n  return $toPrecision.call(1, undefined) !== '1';\n}) || !$fails(function () {\n  // V8 ~ Android 4.3-\n  $toPrecision.call({});\n})), 'Number', {\n  toPrecision: function toPrecision(precision) {\n    var that = aNumberValue(this, 'Number#toPrecision: incorrect invocation!');\n    return precision === undefined ? $toPrecision.call(that) : $toPrecision.call(that, precision);\n  }\n});\n","// 19.1.3.1 Object.assign(target, source)\nvar $export = require('./_export');\n\n$export($export.S + $export.F, 'Object', { assign: require('./_object-assign') });\n","var $export = require('./_export');\n// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])\n$export($export.S, 'Object', { create: require('./_object-create') });\n","var $export = require('./_export');\n// 19.1.2.3 / 15.2.3.7 Object.defineProperties(O, Properties)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperties: require('./_object-dps') });\n","var $export = require('./_export');\n// 19.1.2.4 / 15.2.3.6 Object.defineProperty(O, P, Attributes)\n$export($export.S + $export.F * !require('./_descriptors'), 'Object', { defineProperty: require('./_object-dp').f });\n","// 19.1.2.5 Object.freeze(O)\nvar isObject = require('./_is-object');\nvar meta = require('./_meta').onFreeze;\n\nrequire('./_object-sap')('freeze', function ($freeze) {\n  return function freeze(it) {\n    return $freeze && isObject(it) ? $freeze(meta(it)) : it;\n  };\n});\n","// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\nvar toIObject = require('./_to-iobject');\nvar $getOwnPropertyDescriptor = require('./_object-gopd').f;\n\nrequire('./_object-sap')('getOwnPropertyDescriptor', function () {\n  return function getOwnPropertyDescriptor(it, key) {\n    return $getOwnPropertyDescriptor(toIObject(it), key);\n  };\n});\n","// 19.1.2.7 Object.getOwnPropertyNames(O)\nrequire('./_object-sap')('getOwnPropertyNames', function () {\n  return require('./_object-gopn-ext').f;\n});\n","// 19.1.2.9 Object.getPrototypeOf(O)\nvar toObject = require('./_to-object');\nvar $getPrototypeOf = require('./_object-gpo');\n\nrequire('./_object-sap')('getPrototypeOf', function () {\n  return function getPrototypeOf(it) {\n    return $getPrototypeOf(toObject(it));\n  };\n});\n","// 19.1.2.11 Object.isExtensible(O)\nvar isObject = require('./_is-object');\n\nrequire('./_object-sap')('isExtensible', function ($isExtensible) {\n  return function isExtensible(it) {\n    return isObject(it) ? $isExtensible ? $isExtensible(it) : true : false;\n  };\n});\n","// 19.1.2.12 Object.isFrozen(O)\nvar isObject = require('./_is-object');\n\nrequire('./_object-sap')('isFrozen', function ($isFrozen) {\n  return function isFrozen(it) {\n    return isObject(it) ? $isFrozen ? $isFrozen(it) : false : true;\n  };\n});\n","// 19.1.2.13 Object.isSealed(O)\nvar isObject = require('./_is-object');\n\nrequire('./_object-sap')('isSealed', function ($isSealed) {\n  return function isSealed(it) {\n    return isObject(it) ? $isSealed ? $isSealed(it) : false : true;\n  };\n});\n","// 19.1.3.10 Object.is(value1, value2)\nvar $export = require('./_export');\n$export($export.S, 'Object', { is: require('./_same-value') });\n","// 19.1.2.14 Object.keys(O)\nvar toObject = require('./_to-object');\nvar $keys = require('./_object-keys');\n\nrequire('./_object-sap')('keys', function () {\n  return function keys(it) {\n    return $keys(toObject(it));\n  };\n});\n","// 19.1.2.15 Object.preventExtensions(O)\nvar isObject = require('./_is-object');\nvar meta = require('./_meta').onFreeze;\n\nrequire('./_object-sap')('preventExtensions', function ($preventExtensions) {\n  return function preventExtensions(it) {\n    return $preventExtensions && isObject(it) ? $preventExtensions(meta(it)) : it;\n  };\n});\n","// 19.1.2.17 Object.seal(O)\nvar isObject = require('./_is-object');\nvar meta = require('./_meta').onFreeze;\n\nrequire('./_object-sap')('seal', function ($seal) {\n  return function seal(it) {\n    return $seal && isObject(it) ? $seal(meta(it)) : it;\n  };\n});\n","// 19.1.3.19 Object.setPrototypeOf(O, proto)\nvar $export = require('./_export');\n$export($export.S, 'Object', { setPrototypeOf: require('./_set-proto').set });\n","'use strict';\n// 19.1.3.6 Object.prototype.toString()\nvar classof = require('./_classof');\nvar test = {};\ntest[require('./_wks')('toStringTag')] = 'z';\nif (test + '' != '[object z]') {\n  require('./_redefine')(Object.prototype, 'toString', function toString() {\n    return '[object ' + classof(this) + ']';\n  }, true);\n}\n","var $export = require('./_export');\nvar $parseFloat = require('./_parse-float');\n// 18.2.4 parseFloat(string)\n$export($export.G + $export.F * (parseFloat != $parseFloat), { parseFloat: $parseFloat });\n","var $export = require('./_export');\nvar $parseInt = require('./_parse-int');\n// 18.2.5 parseInt(string, radix)\n$export($export.G + $export.F * (parseInt != $parseInt), { parseInt: $parseInt });\n","'use strict';\nvar LIBRARY = require('./_library');\nvar global = require('./_global');\nvar ctx = require('./_ctx');\nvar classof = require('./_classof');\nvar $export = require('./_export');\nvar isObject = require('./_is-object');\nvar aFunction = require('./_a-function');\nvar anInstance = require('./_an-instance');\nvar forOf = require('./_for-of');\nvar speciesConstructor = require('./_species-constructor');\nvar task = require('./_task').set;\nvar microtask = require('./_microtask')();\nvar newPromiseCapabilityModule = require('./_new-promise-capability');\nvar perform = require('./_perform');\nvar userAgent = require('./_user-agent');\nvar promiseResolve = require('./_promise-resolve');\nvar PROMISE = 'Promise';\nvar TypeError = global.TypeError;\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8 || '';\nvar $Promise = global[PROMISE];\nvar isNode = classof(process) == 'process';\nvar empty = function () { /* empty */ };\nvar Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;\nvar newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;\n\nvar USE_NATIVE = !!function () {\n  try {\n    // correct subclassing with @@species support\n    var promise = $Promise.resolve(1);\n    var FakePromise = (promise.constructor = {})[require('./_wks')('species')] = function (exec) {\n      exec(empty, empty);\n    };\n    // unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    return (isNode || typeof PromiseRejectionEvent == 'function')\n      && promise.then(empty) instanceof FakePromise\n      // v8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n      // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n      // we can't detect it synchronously, so just check versions\n      && v8.indexOf('6.6') !== 0\n      && userAgent.indexOf('Chrome/66') === -1;\n  } catch (e) { /* empty */ }\n}();\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\nvar notify = function (promise, isReject) {\n  if (promise._n) return;\n  promise._n = true;\n  var chain = promise._c;\n  microtask(function () {\n    var value = promise._v;\n    var ok = promise._s == 1;\n    var i = 0;\n    var run = function (reaction) {\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (promise._h == 2) onHandleUnhandled(promise);\n            promise._h = 1;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // may throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (e) {\n        if (domain && !exited) domain.exit();\n        reject(e);\n      }\n    };\n    while (chain.length > i) run(chain[i++]); // variable length - can't use forEach\n    promise._c = [];\n    promise._n = false;\n    if (isReject && !promise._h) onUnhandled(promise);\n  });\n};\nvar onUnhandled = function (promise) {\n  task.call(global, function () {\n    var value = promise._v;\n    var unhandled = isUnhandled(promise);\n    var result, handler, console;\n    if (unhandled) {\n      result = perform(function () {\n        if (isNode) {\n          process.emit('unhandledRejection', value, promise);\n        } else if (handler = global.onunhandledrejection) {\n          handler({ promise: promise, reason: value });\n        } else if ((console = global.console) && console.error) {\n          console.error('Unhandled promise rejection', value);\n        }\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      promise._h = isNode || isUnhandled(promise) ? 2 : 1;\n    } promise._a = undefined;\n    if (unhandled && result.e) throw result.v;\n  });\n};\nvar isUnhandled = function (promise) {\n  return promise._h !== 1 && (promise._a || promise._c).length === 0;\n};\nvar onHandleUnhandled = function (promise) {\n  task.call(global, function () {\n    var handler;\n    if (isNode) {\n      process.emit('rejectionHandled', promise);\n    } else if (handler = global.onrejectionhandled) {\n      handler({ promise: promise, reason: promise._v });\n    }\n  });\n};\nvar $reject = function (value) {\n  var promise = this;\n  if (promise._d) return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  promise._v = value;\n  promise._s = 2;\n  if (!promise._a) promise._a = promise._c.slice();\n  notify(promise, true);\n};\nvar $resolve = function (value) {\n  var promise = this;\n  var then;\n  if (promise._d) return;\n  promise._d = true;\n  promise = promise._w || promise; // unwrap\n  try {\n    if (promise === value) throw TypeError(\"Promise can't be resolved itself\");\n    if (then = isThenable(value)) {\n      microtask(function () {\n        var wrapper = { _w: promise, _d: false }; // wrap\n        try {\n          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));\n        } catch (e) {\n          $reject.call(wrapper, e);\n        }\n      });\n    } else {\n      promise._v = value;\n      promise._s = 1;\n      notify(promise, false);\n    }\n  } catch (e) {\n    $reject.call({ _w: promise, _d: false }, e); // wrap\n  }\n};\n\n// constructor polyfill\nif (!USE_NATIVE) {\n  // 25.4.3.1 Promise(executor)\n  $Promise = function Promise(executor) {\n    anInstance(this, $Promise, PROMISE, '_h');\n    aFunction(executor);\n    Internal.call(this);\n    try {\n      executor(ctx($resolve, this, 1), ctx($reject, this, 1));\n    } catch (err) {\n      $reject.call(this, err);\n    }\n  };\n  // eslint-disable-next-line no-unused-vars\n  Internal = function Promise(executor) {\n    this._c = [];             // <- awaiting reactions\n    this._a = undefined;      // <- checked in isUnhandled reactions\n    this._s = 0;              // <- state\n    this._d = false;          // <- done\n    this._v = undefined;      // <- value\n    this._h = 0;              // <- rejection state, 0 - default, 1 - handled, 2 - unhandled\n    this._n = false;          // <- notify\n  };\n  Internal.prototype = require('./_redefine-all')($Promise.prototype, {\n    // 25.4.5.3 Promise.prototype.then(onFulfilled, onRejected)\n    then: function then(onFulfilled, onRejected) {\n      var reaction = newPromiseCapability(speciesConstructor(this, $Promise));\n      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail = typeof onRejected == 'function' && onRejected;\n      reaction.domain = isNode ? process.domain : undefined;\n      this._c.push(reaction);\n      if (this._a) this._a.push(reaction);\n      if (this._s) notify(this, false);\n      return reaction.promise;\n    },\n    // 25.4.5.1 Promise.prototype.catch(onRejected)\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    this.promise = promise;\n    this.resolve = ctx($resolve, promise, 1);\n    this.reject = ctx($reject, promise, 1);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === $Promise || C === Wrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Promise: $Promise });\nrequire('./_set-to-string-tag')($Promise, PROMISE);\nrequire('./_set-species')(PROMISE);\nWrapper = require('./_core')[PROMISE];\n\n// statics\n$export($export.S + $export.F * !USE_NATIVE, PROMISE, {\n  // 25.4.4.5 Promise.reject(r)\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    var $$reject = capability.reject;\n    $$reject(r);\n    return capability.promise;\n  }\n});\n$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {\n  // 25.4.4.6 Promise.resolve(x)\n  resolve: function resolve(x) {\n    return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);\n  }\n});\n$export($export.S + $export.F * !(USE_NATIVE && require('./_iter-detect')(function (iter) {\n  $Promise.all(iter)['catch'](empty);\n})), PROMISE, {\n  // 25.4.4.1 Promise.all(iterable)\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var values = [];\n      var index = 0;\n      var remaining = 1;\n      forOf(iterable, false, function (promise) {\n        var $index = index++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        C.resolve(promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[$index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.e) reject(result.v);\n    return capability.promise;\n  },\n  // 25.4.4.4 Promise.race(iterable)\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      forOf(iterable, false, function (promise) {\n        C.resolve(promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.e) reject(result.v);\n    return capability.promise;\n  }\n});\n","// 26.1.1 Reflect.apply(target, thisArgument, argumentsList)\nvar $export = require('./_export');\nvar aFunction = require('./_a-function');\nvar anObject = require('./_an-object');\nvar rApply = (require('./_global').Reflect || {}).apply;\nvar fApply = Function.apply;\n// MS Edge argumentsList argument is optional\n$export($export.S + $export.F * !require('./_fails')(function () {\n  rApply(function () { /* empty */ });\n}), 'Reflect', {\n  apply: function apply(target, thisArgument, argumentsList) {\n    var T = aFunction(target);\n    var L = anObject(argumentsList);\n    return rApply ? rApply(T, thisArgument, L) : fApply.call(T, thisArgument, L);\n  }\n});\n","// 26.1.2 Reflect.construct(target, argumentsList [, newTarget])\nvar $export = require('./_export');\nvar create = require('./_object-create');\nvar aFunction = require('./_a-function');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar fails = require('./_fails');\nvar bind = require('./_bind');\nvar rConstruct = (require('./_global').Reflect || {}).construct;\n\n// MS Edge supports only 2 arguments and argumentsList argument is optional\n// FF Nightly sets third argument as `new.target`, but does not create `this` from it\nvar NEW_TARGET_BUG = fails(function () {\n  function F() { /* empty */ }\n  return !(rConstruct(function () { /* empty */ }, [], F) instanceof F);\n});\nvar ARGS_BUG = !fails(function () {\n  rConstruct(function () { /* empty */ });\n});\n\n$export($export.S + $export.F * (NEW_TARGET_BUG || ARGS_BUG), 'Reflect', {\n  construct: function construct(Target, args /* , newTarget */) {\n    aFunction(Target);\n    anObject(args);\n    var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]);\n    if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget);\n    if (Target == newTarget) {\n      // w/o altered newTarget, optimization for 0-4 arguments\n      switch (args.length) {\n        case 0: return new Target();\n        case 1: return new Target(args[0]);\n        case 2: return new Target(args[0], args[1]);\n        case 3: return new Target(args[0], args[1], args[2]);\n        case 4: return new Target(args[0], args[1], args[2], args[3]);\n      }\n      // w/o altered newTarget, lot of arguments case\n      var $args = [null];\n      $args.push.apply($args, args);\n      return new (bind.apply(Target, $args))();\n    }\n    // with altered newTarget, not support built-in constructors\n    var proto = newTarget.prototype;\n    var instance = create(isObject(proto) ? proto : Object.prototype);\n    var result = Function.apply.call(Target, instance, args);\n    return isObject(result) ? result : instance;\n  }\n});\n","// 26.1.3 Reflect.defineProperty(target, propertyKey, attributes)\nvar dP = require('./_object-dp');\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\nvar toPrimitive = require('./_to-primitive');\n\n// MS Edge has broken Reflect.defineProperty - throwing instead of returning false\n$export($export.S + $export.F * require('./_fails')(function () {\n  // eslint-disable-next-line no-undef\n  Reflect.defineProperty(dP.f({}, 1, { value: 1 }), 1, { value: 2 });\n}), 'Reflect', {\n  defineProperty: function defineProperty(target, propertyKey, attributes) {\n    anObject(target);\n    propertyKey = toPrimitive(propertyKey, true);\n    anObject(attributes);\n    try {\n      dP.f(target, propertyKey, attributes);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n});\n","// 26.1.4 Reflect.deleteProperty(target, propertyKey)\nvar $export = require('./_export');\nvar gOPD = require('./_object-gopd').f;\nvar anObject = require('./_an-object');\n\n$export($export.S, 'Reflect', {\n  deleteProperty: function deleteProperty(target, propertyKey) {\n    var desc = gOPD(anObject(target), propertyKey);\n    return desc && !desc.configurable ? false : delete target[propertyKey];\n  }\n});\n","'use strict';\n// 26.1.5 Reflect.enumerate(target)\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\nvar Enumerate = function (iterated) {\n  this._t = anObject(iterated); // target\n  this._i = 0;                  // next index\n  var keys = this._k = [];      // keys\n  var key;\n  for (key in iterated) keys.push(key);\n};\nrequire('./_iter-create')(Enumerate, 'Object', function () {\n  var that = this;\n  var keys = that._k;\n  var key;\n  do {\n    if (that._i >= keys.length) return { value: undefined, done: true };\n  } while (!((key = keys[that._i++]) in that._t));\n  return { value: key, done: false };\n});\n\n$export($export.S, 'Reflect', {\n  enumerate: function enumerate(target) {\n    return new Enumerate(target);\n  }\n});\n","// 26.1.7 Reflect.getOwnPropertyDescriptor(target, propertyKey)\nvar gOPD = require('./_object-gopd');\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\n\n$export($export.S, 'Reflect', {\n  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {\n    return gOPD.f(anObject(target), propertyKey);\n  }\n});\n","// 26.1.8 Reflect.getPrototypeOf(target)\nvar $export = require('./_export');\nvar getProto = require('./_object-gpo');\nvar anObject = require('./_an-object');\n\n$export($export.S, 'Reflect', {\n  getPrototypeOf: function getPrototypeOf(target) {\n    return getProto(anObject(target));\n  }\n});\n","// 26.1.6 Reflect.get(target, propertyKey [, receiver])\nvar gOPD = require('./_object-gopd');\nvar getPrototypeOf = require('./_object-gpo');\nvar has = require('./_has');\nvar $export = require('./_export');\nvar isObject = require('./_is-object');\nvar anObject = require('./_an-object');\n\nfunction get(target, propertyKey /* , receiver */) {\n  var receiver = arguments.length < 3 ? target : arguments[2];\n  var desc, proto;\n  if (anObject(target) === receiver) return target[propertyKey];\n  if (desc = gOPD.f(target, propertyKey)) return has(desc, 'value')\n    ? desc.value\n    : desc.get !== undefined\n      ? desc.get.call(receiver)\n      : undefined;\n  if (isObject(proto = getPrototypeOf(target))) return get(proto, propertyKey, receiver);\n}\n\n$export($export.S, 'Reflect', { get: get });\n","// 26.1.9 Reflect.has(target, propertyKey)\nvar $export = require('./_export');\n\n$export($export.S, 'Reflect', {\n  has: function has(target, propertyKey) {\n    return propertyKey in target;\n  }\n});\n","// 26.1.10 Reflect.isExtensible(target)\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\nvar $isExtensible = Object.isExtensible;\n\n$export($export.S, 'Reflect', {\n  isExtensible: function isExtensible(target) {\n    anObject(target);\n    return $isExtensible ? $isExtensible(target) : true;\n  }\n});\n","// 26.1.11 Reflect.ownKeys(target)\nvar $export = require('./_export');\n\n$export($export.S, 'Reflect', { ownKeys: require('./_own-keys') });\n","// 26.1.12 Reflect.preventExtensions(target)\nvar $export = require('./_export');\nvar anObject = require('./_an-object');\nvar $preventExtensions = Object.preventExtensions;\n\n$export($export.S, 'Reflect', {\n  preventExtensions: function preventExtensions(target) {\n    anObject(target);\n    try {\n      if ($preventExtensions) $preventExtensions(target);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n});\n","// 26.1.14 Reflect.setPrototypeOf(target, proto)\nvar $export = require('./_export');\nvar setProto = require('./_set-proto');\n\nif (setProto) $export($export.S, 'Reflect', {\n  setPrototypeOf: function setPrototypeOf(target, proto) {\n    setProto.check(target, proto);\n    try {\n      setProto.set(target, proto);\n      return true;\n    } catch (e) {\n      return false;\n    }\n  }\n});\n","// 26.1.13 Reflect.set(target, propertyKey, V [, receiver])\nvar dP = require('./_object-dp');\nvar gOPD = require('./_object-gopd');\nvar getPrototypeOf = require('./_object-gpo');\nvar has = require('./_has');\nvar $export = require('./_export');\nvar createDesc = require('./_property-desc');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\n\nfunction set(target, propertyKey, V /* , receiver */) {\n  var receiver = arguments.length < 4 ? target : arguments[3];\n  var ownDesc = gOPD.f(anObject(target), propertyKey);\n  var existingDescriptor, proto;\n  if (!ownDesc) {\n    if (isObject(proto = getPrototypeOf(target))) {\n      return set(proto, propertyKey, V, receiver);\n    }\n    ownDesc = createDesc(0);\n  }\n  if (has(ownDesc, 'value')) {\n    if (ownDesc.writable === false || !isObject(receiver)) return false;\n    if (existingDescriptor = gOPD.f(receiver, propertyKey)) {\n      if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;\n      existingDescriptor.value = V;\n      dP.f(receiver, propertyKey, existingDescriptor);\n    } else dP.f(receiver, propertyKey, createDesc(0, V));\n    return true;\n  }\n  return ownDesc.set === undefined ? false : (ownDesc.set.call(receiver, V), true);\n}\n\n$export($export.S, 'Reflect', { set: set });\n","var global = require('./_global');\nvar inheritIfRequired = require('./_inherit-if-required');\nvar dP = require('./_object-dp').f;\nvar gOPN = require('./_object-gopn').f;\nvar isRegExp = require('./_is-regexp');\nvar $flags = require('./_flags');\nvar $RegExp = global.RegExp;\nvar Base = $RegExp;\nvar proto = $RegExp.prototype;\nvar re1 = /a/g;\nvar re2 = /a/g;\n// \"new\" creates a new object, old webkit buggy here\nvar CORRECT_NEW = new $RegExp(re1) !== re1;\n\nif (require('./_descriptors') && (!CORRECT_NEW || require('./_fails')(function () {\n  re2[require('./_wks')('match')] = false;\n  // RegExp constructor can alter flags and IsRegExp works correct with @@match\n  return $RegExp(re1) != re1 || $RegExp(re2) == re2 || $RegExp(re1, 'i') != '/a/i';\n}))) {\n  $RegExp = function RegExp(p, f) {\n    var tiRE = this instanceof $RegExp;\n    var piRE = isRegExp(p);\n    var fiU = f === undefined;\n    return !tiRE && piRE && p.constructor === $RegExp && fiU ? p\n      : inheritIfRequired(CORRECT_NEW\n        ? new Base(piRE && !fiU ? p.source : p, f)\n        : Base((piRE = p instanceof $RegExp) ? p.source : p, piRE && fiU ? $flags.call(p) : f)\n      , tiRE ? this : proto, $RegExp);\n  };\n  var proxy = function (key) {\n    key in $RegExp || dP($RegExp, key, {\n      configurable: true,\n      get: function () { return Base[key]; },\n      set: function (it) { Base[key] = it; }\n    });\n  };\n  for (var keys = gOPN(Base), i = 0; keys.length > i;) proxy(keys[i++]);\n  proto.constructor = $RegExp;\n  $RegExp.prototype = proto;\n  require('./_redefine')(global, 'RegExp', $RegExp);\n}\n\nrequire('./_set-species')('RegExp');\n","'use strict';\nvar regexpExec = require('./_regexp-exec');\nrequire('./_export')({\n  target: 'RegExp',\n  proto: true,\n  forced: regexpExec !== /./.exec\n}, {\n  exec: regexpExec\n});\n","// 21.2.5.3 get RegExp.prototype.flags()\nif (require('./_descriptors') && /./g.flags != 'g') require('./_object-dp').f(RegExp.prototype, 'flags', {\n  configurable: true,\n  get: require('./_flags')\n});\n","'use strict';\n\nvar anObject = require('./_an-object');\nvar toLength = require('./_to-length');\nvar advanceStringIndex = require('./_advance-string-index');\nvar regExpExec = require('./_regexp-exec-abstract');\n\n// @@match logic\nrequire('./_fix-re-wks')('match', 1, function (defined, MATCH, $match, maybeCallNative) {\n  return [\n    // `String.prototype.match` method\n    // https://tc39.github.io/ecma262/#sec-string.prototype.match\n    function match(regexp) {\n      var O = defined(this);\n      var fn = regexp == undefined ? undefined : regexp[MATCH];\n      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[MATCH](String(O));\n    },\n    // `RegExp.prototype[@@match]` method\n    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@match\n    function (regexp) {\n      var res = maybeCallNative($match, regexp, this);\n      if (res.done) return res.value;\n      var rx = anObject(regexp);\n      var S = String(this);\n      if (!rx.global) return regExpExec(rx, S);\n      var fullUnicode = rx.unicode;\n      rx.lastIndex = 0;\n      var A = [];\n      var n = 0;\n      var result;\n      while ((result = regExpExec(rx, S)) !== null) {\n        var matchStr = String(result[0]);\n        A[n] = matchStr;\n        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n        n++;\n      }\n      return n === 0 ? null : A;\n    }\n  ];\n});\n","'use strict';\n\nvar anObject = require('./_an-object');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar toInteger = require('./_to-integer');\nvar advanceStringIndex = require('./_advance-string-index');\nvar regExpExec = require('./_regexp-exec-abstract');\nvar max = Math.max;\nvar min = Math.min;\nvar floor = Math.floor;\nvar SUBSTITUTION_SYMBOLS = /\\$([$&`']|\\d\\d?|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&`']|\\d\\d?)/g;\n\nvar maybeToString = function (it) {\n  return it === undefined ? it : String(it);\n};\n\n// @@replace logic\nrequire('./_fix-re-wks')('replace', 2, function (defined, REPLACE, $replace, maybeCallNative) {\n  return [\n    // `String.prototype.replace` method\n    // https://tc39.github.io/ecma262/#sec-string.prototype.replace\n    function replace(searchValue, replaceValue) {\n      var O = defined(this);\n      var fn = searchValue == undefined ? undefined : searchValue[REPLACE];\n      return fn !== undefined\n        ? fn.call(searchValue, O, replaceValue)\n        : $replace.call(String(O), searchValue, replaceValue);\n    },\n    // `RegExp.prototype[@@replace]` method\n    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@replace\n    function (regexp, replaceValue) {\n      var res = maybeCallNative($replace, regexp, this, replaceValue);\n      if (res.done) return res.value;\n\n      var rx = anObject(regexp);\n      var S = String(this);\n      var functionalReplace = typeof replaceValue === 'function';\n      if (!functionalReplace) replaceValue = String(replaceValue);\n      var global = rx.global;\n      if (global) {\n        var fullUnicode = rx.unicode;\n        rx.lastIndex = 0;\n      }\n      var results = [];\n      while (true) {\n        var result = regExpExec(rx, S);\n        if (result === null) break;\n        results.push(result);\n        if (!global) break;\n        var matchStr = String(result[0]);\n        if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n      }\n      var accumulatedResult = '';\n      var nextSourcePosition = 0;\n      for (var i = 0; i < results.length; i++) {\n        result = results[i];\n        var matched = String(result[0]);\n        var position = max(min(toInteger(result.index), S.length), 0);\n        var captures = [];\n        // NOTE: This is equivalent to\n        //   captures = result.slice(1).map(maybeToString)\n        // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n        // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n        // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n        for (var j = 1; j < result.length; j++) captures.push(maybeToString(result[j]));\n        var namedCaptures = result.groups;\n        if (functionalReplace) {\n          var replacerArgs = [matched].concat(captures, position, S);\n          if (namedCaptures !== undefined) replacerArgs.push(namedCaptures);\n          var replacement = String(replaceValue.apply(undefined, replacerArgs));\n        } else {\n          replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n        }\n        if (position >= nextSourcePosition) {\n          accumulatedResult += S.slice(nextSourcePosition, position) + replacement;\n          nextSourcePosition = position + matched.length;\n        }\n      }\n      return accumulatedResult + S.slice(nextSourcePosition);\n    }\n  ];\n\n    // https://tc39.github.io/ecma262/#sec-getsubstitution\n  function getSubstitution(matched, str, position, captures, namedCaptures, replacement) {\n    var tailPos = position + matched.length;\n    var m = captures.length;\n    var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n    if (namedCaptures !== undefined) {\n      namedCaptures = toObject(namedCaptures);\n      symbols = SUBSTITUTION_SYMBOLS;\n    }\n    return $replace.call(replacement, symbols, function (match, ch) {\n      var capture;\n      switch (ch.charAt(0)) {\n        case '$': return '$';\n        case '&': return matched;\n        case '`': return str.slice(0, position);\n        case \"'\": return str.slice(tailPos);\n        case '<':\n          capture = namedCaptures[ch.slice(1, -1)];\n          break;\n        default: // \\d\\d?\n          var n = +ch;\n          if (n === 0) return match;\n          if (n > m) {\n            var f = floor(n / 10);\n            if (f === 0) return match;\n            if (f <= m) return captures[f - 1] === undefined ? ch.charAt(1) : captures[f - 1] + ch.charAt(1);\n            return match;\n          }\n          capture = captures[n - 1];\n      }\n      return capture === undefined ? '' : capture;\n    });\n  }\n});\n","'use strict';\n\nvar anObject = require('./_an-object');\nvar sameValue = require('./_same-value');\nvar regExpExec = require('./_regexp-exec-abstract');\n\n// @@search logic\nrequire('./_fix-re-wks')('search', 1, function (defined, SEARCH, $search, maybeCallNative) {\n  return [\n    // `String.prototype.search` method\n    // https://tc39.github.io/ecma262/#sec-string.prototype.search\n    function search(regexp) {\n      var O = defined(this);\n      var fn = regexp == undefined ? undefined : regexp[SEARCH];\n      return fn !== undefined ? fn.call(regexp, O) : new RegExp(regexp)[SEARCH](String(O));\n    },\n    // `RegExp.prototype[@@search]` method\n    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@search\n    function (regexp) {\n      var res = maybeCallNative($search, regexp, this);\n      if (res.done) return res.value;\n      var rx = anObject(regexp);\n      var S = String(this);\n      var previousLastIndex = rx.lastIndex;\n      if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;\n      var result = regExpExec(rx, S);\n      if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;\n      return result === null ? -1 : result.index;\n    }\n  ];\n});\n","'use strict';\n\nvar isRegExp = require('./_is-regexp');\nvar anObject = require('./_an-object');\nvar speciesConstructor = require('./_species-constructor');\nvar advanceStringIndex = require('./_advance-string-index');\nvar toLength = require('./_to-length');\nvar callRegExpExec = require('./_regexp-exec-abstract');\nvar regexpExec = require('./_regexp-exec');\nvar fails = require('./_fails');\nvar $min = Math.min;\nvar $push = [].push;\nvar $SPLIT = 'split';\nvar LENGTH = 'length';\nvar LAST_INDEX = 'lastIndex';\nvar MAX_UINT32 = 0xffffffff;\n\n// babel-minify transpiles RegExp('x', 'y') -> /x/y and it causes SyntaxError\nvar SUPPORTS_Y = !fails(function () { RegExp(MAX_UINT32, 'y'); });\n\n// @@split logic\nrequire('./_fix-re-wks')('split', 2, function (defined, SPLIT, $split, maybeCallNative) {\n  var internalSplit;\n  if (\n    'abbc'[$SPLIT](/(b)*/)[1] == 'c' ||\n    'test'[$SPLIT](/(?:)/, -1)[LENGTH] != 4 ||\n    'ab'[$SPLIT](/(?:ab)*/)[LENGTH] != 2 ||\n    '.'[$SPLIT](/(.?)(.?)/)[LENGTH] != 4 ||\n    '.'[$SPLIT](/()()/)[LENGTH] > 1 ||\n    ''[$SPLIT](/.?/)[LENGTH]\n  ) {\n    // based on es5-shim implementation, need to rework it\n    internalSplit = function (separator, limit) {\n      var string = String(this);\n      if (separator === undefined && limit === 0) return [];\n      // If `separator` is not a regex, use native split\n      if (!isRegExp(separator)) return $split.call(string, separator, limit);\n      var output = [];\n      var flags = (separator.ignoreCase ? 'i' : '') +\n                  (separator.multiline ? 'm' : '') +\n                  (separator.unicode ? 'u' : '') +\n                  (separator.sticky ? 'y' : '');\n      var lastLastIndex = 0;\n      var splitLimit = limit === undefined ? MAX_UINT32 : limit >>> 0;\n      // Make `global` and avoid `lastIndex` issues by working with a copy\n      var separatorCopy = new RegExp(separator.source, flags + 'g');\n      var match, lastIndex, lastLength;\n      while (match = regexpExec.call(separatorCopy, string)) {\n        lastIndex = separatorCopy[LAST_INDEX];\n        if (lastIndex > lastLastIndex) {\n          output.push(string.slice(lastLastIndex, match.index));\n          if (match[LENGTH] > 1 && match.index < string[LENGTH]) $push.apply(output, match.slice(1));\n          lastLength = match[0][LENGTH];\n          lastLastIndex = lastIndex;\n          if (output[LENGTH] >= splitLimit) break;\n        }\n        if (separatorCopy[LAST_INDEX] === match.index) separatorCopy[LAST_INDEX]++; // Avoid an infinite loop\n      }\n      if (lastLastIndex === string[LENGTH]) {\n        if (lastLength || !separatorCopy.test('')) output.push('');\n      } else output.push(string.slice(lastLastIndex));\n      return output[LENGTH] > splitLimit ? output.slice(0, splitLimit) : output;\n    };\n  // Chakra, V8\n  } else if ('0'[$SPLIT](undefined, 0)[LENGTH]) {\n    internalSplit = function (separator, limit) {\n      return separator === undefined && limit === 0 ? [] : $split.call(this, separator, limit);\n    };\n  } else {\n    internalSplit = $split;\n  }\n\n  return [\n    // `String.prototype.split` method\n    // https://tc39.github.io/ecma262/#sec-string.prototype.split\n    function split(separator, limit) {\n      var O = defined(this);\n      var splitter = separator == undefined ? undefined : separator[SPLIT];\n      return splitter !== undefined\n        ? splitter.call(separator, O, limit)\n        : internalSplit.call(String(O), separator, limit);\n    },\n    // `RegExp.prototype[@@split]` method\n    // https://tc39.github.io/ecma262/#sec-regexp.prototype-@@split\n    //\n    // NOTE: This cannot be properly polyfilled in engines that don't support\n    // the 'y' flag.\n    function (regexp, limit) {\n      var res = maybeCallNative(internalSplit, regexp, this, limit, internalSplit !== $split);\n      if (res.done) return res.value;\n\n      var rx = anObject(regexp);\n      var S = String(this);\n      var C = speciesConstructor(rx, RegExp);\n\n      var unicodeMatching = rx.unicode;\n      var flags = (rx.ignoreCase ? 'i' : '') +\n                  (rx.multiline ? 'm' : '') +\n                  (rx.unicode ? 'u' : '') +\n                  (SUPPORTS_Y ? 'y' : 'g');\n\n      // ^(? + rx + ) is needed, in combination with some S slicing, to\n      // simulate the 'y' flag.\n      var splitter = new C(SUPPORTS_Y ? rx : '^(?:' + rx.source + ')', flags);\n      var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;\n      if (lim === 0) return [];\n      if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];\n      var p = 0;\n      var q = 0;\n      var A = [];\n      while (q < S.length) {\n        splitter.lastIndex = SUPPORTS_Y ? q : 0;\n        var z = callRegExpExec(splitter, SUPPORTS_Y ? S : S.slice(q));\n        var e;\n        if (\n          z === null ||\n          (e = $min(toLength(splitter.lastIndex + (SUPPORTS_Y ? 0 : q)), S.length)) === p\n        ) {\n          q = advanceStringIndex(S, q, unicodeMatching);\n        } else {\n          A.push(S.slice(p, q));\n          if (A.length === lim) return A;\n          for (var i = 1; i <= z.length - 1; i++) {\n            A.push(z[i]);\n            if (A.length === lim) return A;\n          }\n          q = p = e;\n        }\n      }\n      A.push(S.slice(p));\n      return A;\n    }\n  ];\n});\n","'use strict';\nrequire('./es6.regexp.flags');\nvar anObject = require('./_an-object');\nvar $flags = require('./_flags');\nvar DESCRIPTORS = require('./_descriptors');\nvar TO_STRING = 'toString';\nvar $toString = /./[TO_STRING];\n\nvar define = function (fn) {\n  require('./_redefine')(RegExp.prototype, TO_STRING, fn, true);\n};\n\n// 21.2.5.14 RegExp.prototype.toString()\nif (require('./_fails')(function () { return $toString.call({ source: 'a', flags: 'b' }) != '/a/b'; })) {\n  define(function toString() {\n    var R = anObject(this);\n    return '/'.concat(R.source, '/',\n      'flags' in R ? R.flags : !DESCRIPTORS && R instanceof RegExp ? $flags.call(R) : undefined);\n  });\n// FF44- RegExp#toString has a wrong name\n} else if ($toString.name != TO_STRING) {\n  define(function toString() {\n    return $toString.call(this);\n  });\n}\n","'use strict';\nvar strong = require('./_collection-strong');\nvar validate = require('./_validate-collection');\nvar SET = 'Set';\n\n// 23.2 Set Objects\nmodule.exports = require('./_collection')(SET, function (get) {\n  return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };\n}, {\n  // 23.2.3.1 Set.prototype.add(value)\n  add: function add(value) {\n    return strong.def(validate(this, SET), value = value === 0 ? 0 : value, value);\n  }\n}, strong);\n","'use strict';\n// B.2.3.2 String.prototype.anchor(name)\nrequire('./_string-html')('anchor', function (createHTML) {\n  return function anchor(name) {\n    return createHTML(this, 'a', 'name', name);\n  };\n});\n","'use strict';\n// B.2.3.3 String.prototype.big()\nrequire('./_string-html')('big', function (createHTML) {\n  return function big() {\n    return createHTML(this, 'big', '', '');\n  };\n});\n","'use strict';\n// B.2.3.4 String.prototype.blink()\nrequire('./_string-html')('blink', function (createHTML) {\n  return function blink() {\n    return createHTML(this, 'blink', '', '');\n  };\n});\n","'use strict';\n// B.2.3.5 String.prototype.bold()\nrequire('./_string-html')('bold', function (createHTML) {\n  return function bold() {\n    return createHTML(this, 'b', '', '');\n  };\n});\n","'use strict';\nvar $export = require('./_export');\nvar $at = require('./_string-at')(false);\n$export($export.P, 'String', {\n  // 21.1.3.3 String.prototype.codePointAt(pos)\n  codePointAt: function codePointAt(pos) {\n    return $at(this, pos);\n  }\n});\n","// 21.1.3.6 String.prototype.endsWith(searchString [, endPosition])\n'use strict';\nvar $export = require('./_export');\nvar toLength = require('./_to-length');\nvar context = require('./_string-context');\nvar ENDS_WITH = 'endsWith';\nvar $endsWith = ''[ENDS_WITH];\n\n$export($export.P + $export.F * require('./_fails-is-regexp')(ENDS_WITH), 'String', {\n  endsWith: function endsWith(searchString /* , endPosition = @length */) {\n    var that = context(this, searchString, ENDS_WITH);\n    var endPosition = arguments.length > 1 ? arguments[1] : undefined;\n    var len = toLength(that.length);\n    var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);\n    var search = String(searchString);\n    return $endsWith\n      ? $endsWith.call(that, search, end)\n      : that.slice(end - search.length, end) === search;\n  }\n});\n","'use strict';\n// B.2.3.6 String.prototype.fixed()\nrequire('./_string-html')('fixed', function (createHTML) {\n  return function fixed() {\n    return createHTML(this, 'tt', '', '');\n  };\n});\n","'use strict';\n// B.2.3.7 String.prototype.fontcolor(color)\nrequire('./_string-html')('fontcolor', function (createHTML) {\n  return function fontcolor(color) {\n    return createHTML(this, 'font', 'color', color);\n  };\n});\n","'use strict';\n// B.2.3.8 String.prototype.fontsize(size)\nrequire('./_string-html')('fontsize', function (createHTML) {\n  return function fontsize(size) {\n    return createHTML(this, 'font', 'size', size);\n  };\n});\n","var $export = require('./_export');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar fromCharCode = String.fromCharCode;\nvar $fromCodePoint = String.fromCodePoint;\n\n// length should be 1, old FF problem\n$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {\n  // 21.1.2.2 String.fromCodePoint(...codePoints)\n  fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars\n    var res = [];\n    var aLen = arguments.length;\n    var i = 0;\n    var code;\n    while (aLen > i) {\n      code = +arguments[i++];\n      if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');\n      res.push(code < 0x10000\n        ? fromCharCode(code)\n        : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00)\n      );\n    } return res.join('');\n  }\n});\n","// 21.1.3.7 String.prototype.includes(searchString, position = 0)\n'use strict';\nvar $export = require('./_export');\nvar context = require('./_string-context');\nvar INCLUDES = 'includes';\n\n$export($export.P + $export.F * require('./_fails-is-regexp')(INCLUDES), 'String', {\n  includes: function includes(searchString /* , position = 0 */) {\n    return !!~context(this, searchString, INCLUDES)\n      .indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","'use strict';\n// B.2.3.9 String.prototype.italics()\nrequire('./_string-html')('italics', function (createHTML) {\n  return function italics() {\n    return createHTML(this, 'i', '', '');\n  };\n});\n","'use strict';\nvar $at = require('./_string-at')(true);\n\n// 21.1.3.27 String.prototype[@@iterator]()\nrequire('./_iter-define')(String, 'String', function (iterated) {\n  this._t = String(iterated); // target\n  this._i = 0;                // next index\n// 21.1.5.2.1 %StringIteratorPrototype%.next()\n}, function () {\n  var O = this._t;\n  var index = this._i;\n  var point;\n  if (index >= O.length) return { value: undefined, done: true };\n  point = $at(O, index);\n  this._i += point.length;\n  return { value: point, done: false };\n});\n","'use strict';\n// B.2.3.10 String.prototype.link(url)\nrequire('./_string-html')('link', function (createHTML) {\n  return function link(url) {\n    return createHTML(this, 'a', 'href', url);\n  };\n});\n","var $export = require('./_export');\nvar toIObject = require('./_to-iobject');\nvar toLength = require('./_to-length');\n\n$export($export.S, 'String', {\n  // 21.1.2.4 String.raw(callSite, ...substitutions)\n  raw: function raw(callSite) {\n    var tpl = toIObject(callSite.raw);\n    var len = toLength(tpl.length);\n    var aLen = arguments.length;\n    var res = [];\n    var i = 0;\n    while (len > i) {\n      res.push(String(tpl[i++]));\n      if (i < aLen) res.push(String(arguments[i]));\n    } return res.join('');\n  }\n});\n","var $export = require('./_export');\n\n$export($export.P, 'String', {\n  // 21.1.3.13 String.prototype.repeat(count)\n  repeat: require('./_string-repeat')\n});\n","'use strict';\n// B.2.3.11 String.prototype.small()\nrequire('./_string-html')('small', function (createHTML) {\n  return function small() {\n    return createHTML(this, 'small', '', '');\n  };\n});\n","// 21.1.3.18 String.prototype.startsWith(searchString [, position ])\n'use strict';\nvar $export = require('./_export');\nvar toLength = require('./_to-length');\nvar context = require('./_string-context');\nvar STARTS_WITH = 'startsWith';\nvar $startsWith = ''[STARTS_WITH];\n\n$export($export.P + $export.F * require('./_fails-is-regexp')(STARTS_WITH), 'String', {\n  startsWith: function startsWith(searchString /* , position = 0 */) {\n    var that = context(this, searchString, STARTS_WITH);\n    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n    var search = String(searchString);\n    return $startsWith\n      ? $startsWith.call(that, search, index)\n      : that.slice(index, index + search.length) === search;\n  }\n});\n","'use strict';\n// B.2.3.12 String.prototype.strike()\nrequire('./_string-html')('strike', function (createHTML) {\n  return function strike() {\n    return createHTML(this, 'strike', '', '');\n  };\n});\n","'use strict';\n// B.2.3.13 String.prototype.sub()\nrequire('./_string-html')('sub', function (createHTML) {\n  return function sub() {\n    return createHTML(this, 'sub', '', '');\n  };\n});\n","'use strict';\n// B.2.3.14 String.prototype.sup()\nrequire('./_string-html')('sup', function (createHTML) {\n  return function sup() {\n    return createHTML(this, 'sup', '', '');\n  };\n});\n","'use strict';\n// 21.1.3.25 String.prototype.trim()\nrequire('./_string-trim')('trim', function ($trim) {\n  return function trim() {\n    return $trim(this, 3);\n  };\n});\n","'use strict';\n// ECMAScript 6 symbols shim\nvar global = require('./_global');\nvar has = require('./_has');\nvar DESCRIPTORS = require('./_descriptors');\nvar $export = require('./_export');\nvar redefine = require('./_redefine');\nvar META = require('./_meta').KEY;\nvar $fails = require('./_fails');\nvar shared = require('./_shared');\nvar setToStringTag = require('./_set-to-string-tag');\nvar uid = require('./_uid');\nvar wks = require('./_wks');\nvar wksExt = require('./_wks-ext');\nvar wksDefine = require('./_wks-define');\nvar enumKeys = require('./_enum-keys');\nvar isArray = require('./_is-array');\nvar anObject = require('./_an-object');\nvar isObject = require('./_is-object');\nvar toIObject = require('./_to-iobject');\nvar toPrimitive = require('./_to-primitive');\nvar createDesc = require('./_property-desc');\nvar _create = require('./_object-create');\nvar gOPNExt = require('./_object-gopn-ext');\nvar $GOPD = require('./_object-gopd');\nvar $DP = require('./_object-dp');\nvar $keys = require('./_object-keys');\nvar gOPD = $GOPD.f;\nvar dP = $DP.f;\nvar gOPN = gOPNExt.f;\nvar $Symbol = global.Symbol;\nvar $JSON = global.JSON;\nvar _stringify = $JSON && $JSON.stringify;\nvar PROTOTYPE = 'prototype';\nvar HIDDEN = wks('_hidden');\nvar TO_PRIMITIVE = wks('toPrimitive');\nvar isEnum = {}.propertyIsEnumerable;\nvar SymbolRegistry = shared('symbol-registry');\nvar AllSymbols = shared('symbols');\nvar OPSymbols = shared('op-symbols');\nvar ObjectProto = Object[PROTOTYPE];\nvar USE_NATIVE = typeof $Symbol == 'function';\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDesc = DESCRIPTORS && $fails(function () {\n  return _create(dP({}, 'a', {\n    get: function () { return dP(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (it, key, D) {\n  var protoDesc = gOPD(ObjectProto, key);\n  if (protoDesc) delete ObjectProto[key];\n  dP(it, key, D);\n  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);\n} : dP;\n\nvar wrap = function (tag) {\n  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);\n  sym._k = tag;\n  return sym;\n};\n\nvar isSymbol = USE_NATIVE && typeof $Symbol.iterator == 'symbol' ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  return it instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(it, key, D) {\n  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);\n  anObject(it);\n  key = toPrimitive(key, true);\n  anObject(D);\n  if (has(AllSymbols, key)) {\n    if (!D.enumerable) {\n      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));\n      it[HIDDEN][key] = true;\n    } else {\n      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;\n      D = _create(D, { enumerable: createDesc(0, false) });\n    } return setSymbolDesc(it, key, D);\n  } return dP(it, key, D);\n};\nvar $defineProperties = function defineProperties(it, P) {\n  anObject(it);\n  var keys = enumKeys(P = toIObject(P));\n  var i = 0;\n  var l = keys.length;\n  var key;\n  while (l > i) $defineProperty(it, key = keys[i++], P[key]);\n  return it;\n};\nvar $create = function create(it, P) {\n  return P === undefined ? _create(it) : $defineProperties(_create(it), P);\n};\nvar $propertyIsEnumerable = function propertyIsEnumerable(key) {\n  var E = isEnum.call(this, key = toPrimitive(key, true));\n  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;\n  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;\n};\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {\n  it = toIObject(it);\n  key = toPrimitive(key, true);\n  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;\n  var D = gOPD(it, key);\n  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;\n  return D;\n};\nvar $getOwnPropertyNames = function getOwnPropertyNames(it) {\n  var names = gOPN(toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);\n  } return result;\n};\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(it) {\n  var IS_OP = it === ObjectProto;\n  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));\n  var result = [];\n  var i = 0;\n  var key;\n  while (names.length > i) {\n    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);\n  } return result;\n};\n\n// 19.4.1.1 Symbol([description])\nif (!USE_NATIVE) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');\n    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);\n    var $set = function (value) {\n      if (this === ObjectProto) $set.call(OPSymbols, value);\n      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDesc(this, tag, createDesc(1, value));\n    };\n    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, { configurable: true, set: $set });\n    return wrap(tag);\n  };\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return this._k;\n  });\n\n  $GOPD.f = $getOwnPropertyDescriptor;\n  $DP.f = $defineProperty;\n  require('./_object-gopn').f = gOPNExt.f = $getOwnPropertyNames;\n  require('./_object-pie').f = $propertyIsEnumerable;\n  require('./_object-gops').f = $getOwnPropertySymbols;\n\n  if (DESCRIPTORS && !require('./_library')) {\n    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);\n  }\n\n  wksExt.f = function (name) {\n    return wrap(wks(name));\n  };\n}\n\n$export($export.G + $export.W + $export.F * !USE_NATIVE, { Symbol: $Symbol });\n\nfor (var es6Symbols = (\n  // 19.4.2.2, 19.4.2.3, 19.4.2.4, 19.4.2.6, 19.4.2.8, 19.4.2.9, 19.4.2.10, 19.4.2.11, 19.4.2.12, 19.4.2.13, 19.4.2.14\n  'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'\n).split(','), j = 0; es6Symbols.length > j;)wks(es6Symbols[j++]);\n\nfor (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) wksDefine(wellKnownSymbols[k++]);\n\n$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {\n  // 19.4.2.1 Symbol.for(key)\n  'for': function (key) {\n    return has(SymbolRegistry, key += '')\n      ? SymbolRegistry[key]\n      : SymbolRegistry[key] = $Symbol(key);\n  },\n  // 19.4.2.5 Symbol.keyFor(sym)\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');\n    for (var key in SymbolRegistry) if (SymbolRegistry[key] === sym) return key;\n  },\n  useSetter: function () { setter = true; },\n  useSimple: function () { setter = false; }\n});\n\n$export($export.S + $export.F * !USE_NATIVE, 'Object', {\n  // 19.1.2.2 Object.create(O [, Properties])\n  create: $create,\n  // 19.1.2.4 Object.defineProperty(O, P, Attributes)\n  defineProperty: $defineProperty,\n  // 19.1.2.3 Object.defineProperties(O, Properties)\n  defineProperties: $defineProperties,\n  // 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,\n  // 19.1.2.7 Object.getOwnPropertyNames(O)\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // 19.1.2.8 Object.getOwnPropertySymbols(O)\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// 24.3.2 JSON.stringify(value [, replacer [, space]])\n$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {\n  var S = $Symbol();\n  // MS Edge converts symbol values to JSON as {}\n  // WebKit converts symbol values to JSON as null\n  // V8 throws on boxed symbols\n  return _stringify([S]) != '[null]' || _stringify({ a: S }) != '{}' || _stringify(Object(S)) != '{}';\n})), 'JSON', {\n  stringify: function stringify(it) {\n    var args = [it];\n    var i = 1;\n    var replacer, $replacer;\n    while (arguments.length > i) args.push(arguments[i++]);\n    $replacer = replacer = args[1];\n    if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n    if (!isArray(replacer)) replacer = function (key, value) {\n      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);\n      if (!isSymbol(value)) return value;\n    };\n    args[1] = replacer;\n    return _stringify.apply($JSON, args);\n  }\n});\n\n// 19.4.3.4 Symbol.prototype[@@toPrimitive](hint)\n$Symbol[PROTOTYPE][TO_PRIMITIVE] || require('./_hide')($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n// 19.4.3.5 Symbol.prototype[@@toStringTag]\nsetToStringTag($Symbol, 'Symbol');\n// 20.2.1.9 Math[@@toStringTag]\nsetToStringTag(Math, 'Math', true);\n// 24.3.3 JSON[@@toStringTag]\nsetToStringTag(global.JSON, 'JSON', true);\n","'use strict';\nvar $export = require('./_export');\nvar $typed = require('./_typed');\nvar buffer = require('./_typed-buffer');\nvar anObject = require('./_an-object');\nvar toAbsoluteIndex = require('./_to-absolute-index');\nvar toLength = require('./_to-length');\nvar isObject = require('./_is-object');\nvar ArrayBuffer = require('./_global').ArrayBuffer;\nvar speciesConstructor = require('./_species-constructor');\nvar $ArrayBuffer = buffer.ArrayBuffer;\nvar $DataView = buffer.DataView;\nvar $isView = $typed.ABV && ArrayBuffer.isView;\nvar $slice = $ArrayBuffer.prototype.slice;\nvar VIEW = $typed.VIEW;\nvar ARRAY_BUFFER = 'ArrayBuffer';\n\n$export($export.G + $export.W + $export.F * (ArrayBuffer !== $ArrayBuffer), { ArrayBuffer: $ArrayBuffer });\n\n$export($export.S + $export.F * !$typed.CONSTR, ARRAY_BUFFER, {\n  // 24.1.3.1 ArrayBuffer.isView(arg)\n  isView: function isView(it) {\n    return $isView && $isView(it) || isObject(it) && VIEW in it;\n  }\n});\n\n$export($export.P + $export.U + $export.F * require('./_fails')(function () {\n  return !new $ArrayBuffer(2).slice(1, undefined).byteLength;\n}), ARRAY_BUFFER, {\n  // 24.1.4.3 ArrayBuffer.prototype.slice(start, end)\n  slice: function slice(start, end) {\n    if ($slice !== undefined && end === undefined) return $slice.call(anObject(this), start); // FF fix\n    var len = anObject(this).byteLength;\n    var first = toAbsoluteIndex(start, len);\n    var fin = toAbsoluteIndex(end === undefined ? len : end, len);\n    var result = new (speciesConstructor(this, $ArrayBuffer))(toLength(fin - first));\n    var viewS = new $DataView(this);\n    var viewT = new $DataView(result);\n    var index = 0;\n    while (first < fin) {\n      viewT.setUint8(index++, viewS.getUint8(first++));\n    } return result;\n  }\n});\n\nrequire('./_set-species')(ARRAY_BUFFER);\n","var $export = require('./_export');\n$export($export.G + $export.W + $export.F * !require('./_typed').ABV, {\n  DataView: require('./_typed-buffer').DataView\n});\n","require('./_typed-array')('Float32', 4, function (init) {\n  return function Float32Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Float64', 8, function (init) {\n  return function Float64Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Int16', 2, function (init) {\n  return function Int16Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Int32', 4, function (init) {\n  return function Int32Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Int8', 1, function (init) {\n  return function Int8Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Uint16', 2, function (init) {\n  return function Uint16Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Uint32', 4, function (init) {\n  return function Uint32Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Uint8', 1, function (init) {\n  return function Uint8Array(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n});\n","require('./_typed-array')('Uint8', 1, function (init) {\n  return function Uint8ClampedArray(data, byteOffset, length) {\n    return init(this, data, byteOffset, length);\n  };\n}, true);\n","'use strict';\nvar global = require('./_global');\nvar each = require('./_array-methods')(0);\nvar redefine = require('./_redefine');\nvar meta = require('./_meta');\nvar assign = require('./_object-assign');\nvar weak = require('./_collection-weak');\nvar isObject = require('./_is-object');\nvar validate = require('./_validate-collection');\nvar NATIVE_WEAK_MAP = require('./_validate-collection');\nvar IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;\nvar WEAK_MAP = 'WeakMap';\nvar getWeak = meta.getWeak;\nvar isExtensible = Object.isExtensible;\nvar uncaughtFrozenStore = weak.ufstore;\nvar InternalMap;\n\nvar wrapper = function (get) {\n  return function WeakMap() {\n    return get(this, arguments.length > 0 ? arguments[0] : undefined);\n  };\n};\n\nvar methods = {\n  // 23.3.3.3 WeakMap.prototype.get(key)\n  get: function get(key) {\n    if (isObject(key)) {\n      var data = getWeak(key);\n      if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);\n      return data ? data[this._i] : undefined;\n    }\n  },\n  // 23.3.3.5 WeakMap.prototype.set(key, value)\n  set: function set(key, value) {\n    return weak.def(validate(this, WEAK_MAP), key, value);\n  }\n};\n\n// 23.3 WeakMap Objects\nvar $WeakMap = module.exports = require('./_collection')(WEAK_MAP, wrapper, methods, weak, true, true);\n\n// IE11 WeakMap frozen keys fix\nif (NATIVE_WEAK_MAP && IS_IE11) {\n  InternalMap = weak.getConstructor(wrapper, WEAK_MAP);\n  assign(InternalMap.prototype, methods);\n  meta.NEED = true;\n  each(['delete', 'has', 'get', 'set'], function (key) {\n    var proto = $WeakMap.prototype;\n    var method = proto[key];\n    redefine(proto, key, function (a, b) {\n      // store frozen objects on internal weakmap shim\n      if (isObject(a) && !isExtensible(a)) {\n        if (!this._f) this._f = new InternalMap();\n        var result = this._f[key](a, b);\n        return key == 'set' ? this : result;\n      // store all the rest on native weakmap\n      } return method.call(this, a, b);\n    });\n  });\n}\n","'use strict';\nvar weak = require('./_collection-weak');\nvar validate = require('./_validate-collection');\nvar WEAK_SET = 'WeakSet';\n\n// 23.4 WeakSet Objects\nrequire('./_collection')(WEAK_SET, function (get) {\n  return function WeakSet() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };\n}, {\n  // 23.4.3.1 WeakSet.prototype.add(value)\n  add: function add(value) {\n    return weak.def(validate(this, WEAK_SET), value, true);\n  }\n}, weak, false, true);\n","'use strict';\n// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap\nvar $export = require('./_export');\nvar flattenIntoArray = require('./_flatten-into-array');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar aFunction = require('./_a-function');\nvar arraySpeciesCreate = require('./_array-species-create');\n\n$export($export.P, 'Array', {\n  flatMap: function flatMap(callbackfn /* , thisArg */) {\n    var O = toObject(this);\n    var sourceLen, A;\n    aFunction(callbackfn);\n    sourceLen = toLength(O.length);\n    A = arraySpeciesCreate(O, 0);\n    flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments[1]);\n    return A;\n  }\n});\n\nrequire('./_add-to-unscopables')('flatMap');\n","'use strict';\n// https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatten\nvar $export = require('./_export');\nvar flattenIntoArray = require('./_flatten-into-array');\nvar toObject = require('./_to-object');\nvar toLength = require('./_to-length');\nvar toInteger = require('./_to-integer');\nvar arraySpeciesCreate = require('./_array-species-create');\n\n$export($export.P, 'Array', {\n  flatten: function flatten(/* depthArg = 1 */) {\n    var depthArg = arguments[0];\n    var O = toObject(this);\n    var sourceLen = toLength(O.length);\n    var A = arraySpeciesCreate(O, 0);\n    flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toInteger(depthArg));\n    return A;\n  }\n});\n\nrequire('./_add-to-unscopables')('flatten');\n","'use strict';\n// https://github.com/tc39/Array.prototype.includes\nvar $export = require('./_export');\nvar $includes = require('./_array-includes')(true);\n\n$export($export.P, 'Array', {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\nrequire('./_add-to-unscopables')('includes');\n","// https://github.com/rwaldron/tc39-notes/blob/master/es6/2014-09/sept-25.md#510-globalasap-for-enqueuing-a-microtask\nvar $export = require('./_export');\nvar microtask = require('./_microtask')();\nvar process = require('./_global').process;\nvar isNode = require('./_cof')(process) == 'process';\n\n$export($export.G, {\n  asap: function asap(fn) {\n    var domain = isNode && process.domain;\n    microtask(domain ? domain.bind(fn) : fn);\n  }\n});\n","// https://github.com/ljharb/proposal-is-error\nvar $export = require('./_export');\nvar cof = require('./_cof');\n\n$export($export.S, 'Error', {\n  isError: function isError(it) {\n    return cof(it) === 'Error';\n  }\n});\n","// https://github.com/tc39/proposal-global\nvar $export = require('./_export');\n\n$export($export.G, { global: require('./_global') });\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-map.from\nrequire('./_set-collection-from')('Map');\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-map.of\nrequire('./_set-collection-of')('Map');\n","// https://github.com/DavidBruant/Map-Set.prototype.toJSON\nvar $export = require('./_export');\n\n$export($export.P + $export.R, 'Map', { toJSON: require('./_collection-to-json')('Map') });\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  clamp: function clamp(x, lower, upper) {\n    return Math.min(upper, Math.max(lower, x));\n  }\n});\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { DEG_PER_RAD: Math.PI / 180 });\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\nvar RAD_PER_DEG = 180 / Math.PI;\n\n$export($export.S, 'Math', {\n  degrees: function degrees(radians) {\n    return radians * RAD_PER_DEG;\n  }\n});\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\nvar scale = require('./_math-scale');\nvar fround = require('./_math-fround');\n\n$export($export.S, 'Math', {\n  fscale: function fscale(x, inLow, inHigh, outLow, outHigh) {\n    return fround(scale(x, inLow, inHigh, outLow, outHigh));\n  }\n});\n","// https://gist.github.com/BrendanEich/4294d5c212a6d2254703\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  iaddh: function iaddh(x0, x1, y0, y1) {\n    var $x0 = x0 >>> 0;\n    var $x1 = x1 >>> 0;\n    var $y0 = y0 >>> 0;\n    return $x1 + (y1 >>> 0) + (($x0 & $y0 | ($x0 | $y0) & ~($x0 + $y0 >>> 0)) >>> 31) | 0;\n  }\n});\n","// https://gist.github.com/BrendanEich/4294d5c212a6d2254703\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  imulh: function imulh(u, v) {\n    var UINT16 = 0xffff;\n    var $u = +u;\n    var $v = +v;\n    var u0 = $u & UINT16;\n    var v0 = $v & UINT16;\n    var u1 = $u >> 16;\n    var v1 = $v >> 16;\n    var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);\n    return u1 * v1 + (t >> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >> 16);\n  }\n});\n","// https://gist.github.com/BrendanEich/4294d5c212a6d2254703\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  isubh: function isubh(x0, x1, y0, y1) {\n    var $x0 = x0 >>> 0;\n    var $x1 = x1 >>> 0;\n    var $y0 = y0 >>> 0;\n    return $x1 - (y1 >>> 0) - ((~$x0 & $y0 | ~($x0 ^ $y0) & $x0 - $y0 >>> 0) >>> 31) | 0;\n  }\n});\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { RAD_PER_DEG: 180 / Math.PI });\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\nvar DEG_PER_RAD = Math.PI / 180;\n\n$export($export.S, 'Math', {\n  radians: function radians(degrees) {\n    return degrees * DEG_PER_RAD;\n  }\n});\n","// https://rwaldron.github.io/proposal-math-extensions/\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { scale: require('./_math-scale') });\n","// http://jfbastien.github.io/papers/Math.signbit.html\nvar $export = require('./_export');\n\n$export($export.S, 'Math', { signbit: function signbit(x) {\n  // eslint-disable-next-line no-self-compare\n  return (x = +x) != x ? x : x == 0 ? 1 / x == Infinity : x > 0;\n} });\n","// https://gist.github.com/BrendanEich/4294d5c212a6d2254703\nvar $export = require('./_export');\n\n$export($export.S, 'Math', {\n  umulh: function umulh(u, v) {\n    var UINT16 = 0xffff;\n    var $u = +u;\n    var $v = +v;\n    var u0 = $u & UINT16;\n    var v0 = $v & UINT16;\n    var u1 = $u >>> 16;\n    var v1 = $v >>> 16;\n    var t = (u1 * v0 >>> 0) + (u0 * v0 >>> 16);\n    return u1 * v1 + (t >>> 16) + ((u0 * v1 >>> 0) + (t & UINT16) >>> 16);\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar aFunction = require('./_a-function');\nvar $defineProperty = require('./_object-dp');\n\n// B.2.2.2 Object.prototype.__defineGetter__(P, getter)\nrequire('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {\n  __defineGetter__: function __defineGetter__(P, getter) {\n    $defineProperty.f(toObject(this), P, { get: aFunction(getter), enumerable: true, configurable: true });\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar aFunction = require('./_a-function');\nvar $defineProperty = require('./_object-dp');\n\n// B.2.2.3 Object.prototype.__defineSetter__(P, setter)\nrequire('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {\n  __defineSetter__: function __defineSetter__(P, setter) {\n    $defineProperty.f(toObject(this), P, { set: aFunction(setter), enumerable: true, configurable: true });\n  }\n});\n","// https://github.com/tc39/proposal-object-values-entries\nvar $export = require('./_export');\nvar $entries = require('./_object-to-array')(true);\n\n$export($export.S, 'Object', {\n  entries: function entries(it) {\n    return $entries(it);\n  }\n});\n","// https://github.com/tc39/proposal-object-getownpropertydescriptors\nvar $export = require('./_export');\nvar ownKeys = require('./_own-keys');\nvar toIObject = require('./_to-iobject');\nvar gOPD = require('./_object-gopd');\nvar createProperty = require('./_create-property');\n\n$export($export.S, 'Object', {\n  getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {\n    var O = toIObject(object);\n    var getDesc = gOPD.f;\n    var keys = ownKeys(O);\n    var result = {};\n    var i = 0;\n    var key, desc;\n    while (keys.length > i) {\n      desc = getDesc(O, key = keys[i++]);\n      if (desc !== undefined) createProperty(result, key, desc);\n    }\n    return result;\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar toPrimitive = require('./_to-primitive');\nvar getPrototypeOf = require('./_object-gpo');\nvar getOwnPropertyDescriptor = require('./_object-gopd').f;\n\n// B.2.2.4 Object.prototype.__lookupGetter__(P)\nrequire('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {\n  __lookupGetter__: function __lookupGetter__(P) {\n    var O = toObject(this);\n    var K = toPrimitive(P, true);\n    var D;\n    do {\n      if (D = getOwnPropertyDescriptor(O, K)) return D.get;\n    } while (O = getPrototypeOf(O));\n  }\n});\n","'use strict';\nvar $export = require('./_export');\nvar toObject = require('./_to-object');\nvar toPrimitive = require('./_to-primitive');\nvar getPrototypeOf = require('./_object-gpo');\nvar getOwnPropertyDescriptor = require('./_object-gopd').f;\n\n// B.2.2.5 Object.prototype.__lookupSetter__(P)\nrequire('./_descriptors') && $export($export.P + require('./_object-forced-pam'), 'Object', {\n  __lookupSetter__: function __lookupSetter__(P) {\n    var O = toObject(this);\n    var K = toPrimitive(P, true);\n    var D;\n    do {\n      if (D = getOwnPropertyDescriptor(O, K)) return D.set;\n    } while (O = getPrototypeOf(O));\n  }\n});\n","// https://github.com/tc39/proposal-object-values-entries\nvar $export = require('./_export');\nvar $values = require('./_object-to-array')(false);\n\n$export($export.S, 'Object', {\n  values: function values(it) {\n    return $values(it);\n  }\n});\n","'use strict';\n// https://github.com/zenparsing/es-observable\nvar $export = require('./_export');\nvar global = require('./_global');\nvar core = require('./_core');\nvar microtask = require('./_microtask')();\nvar OBSERVABLE = require('./_wks')('observable');\nvar aFunction = require('./_a-function');\nvar anObject = require('./_an-object');\nvar anInstance = require('./_an-instance');\nvar redefineAll = require('./_redefine-all');\nvar hide = require('./_hide');\nvar forOf = require('./_for-of');\nvar RETURN = forOf.RETURN;\n\nvar getMethod = function (fn) {\n  return fn == null ? undefined : aFunction(fn);\n};\n\nvar cleanupSubscription = function (subscription) {\n  var cleanup = subscription._c;\n  if (cleanup) {\n    subscription._c = undefined;\n    cleanup();\n  }\n};\n\nvar subscriptionClosed = function (subscription) {\n  return subscription._o === undefined;\n};\n\nvar closeSubscription = function (subscription) {\n  if (!subscriptionClosed(subscription)) {\n    subscription._o = undefined;\n    cleanupSubscription(subscription);\n  }\n};\n\nvar Subscription = function (observer, subscriber) {\n  anObject(observer);\n  this._c = undefined;\n  this._o = observer;\n  observer = new SubscriptionObserver(this);\n  try {\n    var cleanup = subscriber(observer);\n    var subscription = cleanup;\n    if (cleanup != null) {\n      if (typeof cleanup.unsubscribe === 'function') cleanup = function () { subscription.unsubscribe(); };\n      else aFunction(cleanup);\n      this._c = cleanup;\n    }\n  } catch (e) {\n    observer.error(e);\n    return;\n  } if (subscriptionClosed(this)) cleanupSubscription(this);\n};\n\nSubscription.prototype = redefineAll({}, {\n  unsubscribe: function unsubscribe() { closeSubscription(this); }\n});\n\nvar SubscriptionObserver = function (subscription) {\n  this._s = subscription;\n};\n\nSubscriptionObserver.prototype = redefineAll({}, {\n  next: function next(value) {\n    var subscription = this._s;\n    if (!subscriptionClosed(subscription)) {\n      var observer = subscription._o;\n      try {\n        var m = getMethod(observer.next);\n        if (m) return m.call(observer, value);\n      } catch (e) {\n        try {\n          closeSubscription(subscription);\n        } finally {\n          throw e;\n        }\n      }\n    }\n  },\n  error: function error(value) {\n    var subscription = this._s;\n    if (subscriptionClosed(subscription)) throw value;\n    var observer = subscription._o;\n    subscription._o = undefined;\n    try {\n      var m = getMethod(observer.error);\n      if (!m) throw value;\n      value = m.call(observer, value);\n    } catch (e) {\n      try {\n        cleanupSubscription(subscription);\n      } finally {\n        throw e;\n      }\n    } cleanupSubscription(subscription);\n    return value;\n  },\n  complete: function complete(value) {\n    var subscription = this._s;\n    if (!subscriptionClosed(subscription)) {\n      var observer = subscription._o;\n      subscription._o = undefined;\n      try {\n        var m = getMethod(observer.complete);\n        value = m ? m.call(observer, value) : undefined;\n      } catch (e) {\n        try {\n          cleanupSubscription(subscription);\n        } finally {\n          throw e;\n        }\n      } cleanupSubscription(subscription);\n      return value;\n    }\n  }\n});\n\nvar $Observable = function Observable(subscriber) {\n  anInstance(this, $Observable, 'Observable', '_f')._f = aFunction(subscriber);\n};\n\nredefineAll($Observable.prototype, {\n  subscribe: function subscribe(observer) {\n    return new Subscription(observer, this._f);\n  },\n  forEach: function forEach(fn) {\n    var that = this;\n    return new (core.Promise || global.Promise)(function (resolve, reject) {\n      aFunction(fn);\n      var subscription = that.subscribe({\n        next: function (value) {\n          try {\n            return fn(value);\n          } catch (e) {\n            reject(e);\n            subscription.unsubscribe();\n          }\n        },\n        error: reject,\n        complete: resolve\n      });\n    });\n  }\n});\n\nredefineAll($Observable, {\n  from: function from(x) {\n    var C = typeof this === 'function' ? this : $Observable;\n    var method = getMethod(anObject(x)[OBSERVABLE]);\n    if (method) {\n      var observable = anObject(method.call(x));\n      return observable.constructor === C ? observable : new C(function (observer) {\n        return observable.subscribe(observer);\n      });\n    }\n    return new C(function (observer) {\n      var done = false;\n      microtask(function () {\n        if (!done) {\n          try {\n            if (forOf(x, false, function (it) {\n              observer.next(it);\n              if (done) return RETURN;\n            }) === RETURN) return;\n          } catch (e) {\n            if (done) throw e;\n            observer.error(e);\n            return;\n          } observer.complete();\n        }\n      });\n      return function () { done = true; };\n    });\n  },\n  of: function of() {\n    for (var i = 0, l = arguments.length, items = new Array(l); i < l;) items[i] = arguments[i++];\n    return new (typeof this === 'function' ? this : $Observable)(function (observer) {\n      var done = false;\n      microtask(function () {\n        if (!done) {\n          for (var j = 0; j < items.length; ++j) {\n            observer.next(items[j]);\n            if (done) return;\n          } observer.complete();\n        }\n      });\n      return function () { done = true; };\n    });\n  }\n});\n\nhide($Observable.prototype, OBSERVABLE, function () { return this; });\n\n$export($export.G, { Observable: $Observable });\n\nrequire('./_set-species')('Observable');\n","// https://github.com/tc39/proposal-promise-finally\n'use strict';\nvar $export = require('./_export');\nvar core = require('./_core');\nvar global = require('./_global');\nvar speciesConstructor = require('./_species-constructor');\nvar promiseResolve = require('./_promise-resolve');\n\n$export($export.P + $export.R, 'Promise', { 'finally': function (onFinally) {\n  var C = speciesConstructor(this, core.Promise || global.Promise);\n  var isFunction = typeof onFinally == 'function';\n  return this.then(\n    isFunction ? function (x) {\n      return promiseResolve(C, onFinally()).then(function () { return x; });\n    } : onFinally,\n    isFunction ? function (e) {\n      return promiseResolve(C, onFinally()).then(function () { throw e; });\n    } : onFinally\n  );\n} });\n","'use strict';\n// https://github.com/tc39/proposal-promise-try\nvar $export = require('./_export');\nvar newPromiseCapability = require('./_new-promise-capability');\nvar perform = require('./_perform');\n\n$export($export.S, 'Promise', { 'try': function (callbackfn) {\n  var promiseCapability = newPromiseCapability.f(this);\n  var result = perform(callbackfn);\n  (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);\n  return promiseCapability.promise;\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar toMetaKey = metadata.key;\nvar ordinaryDefineOwnMetadata = metadata.set;\n\nmetadata.exp({ defineMetadata: function defineMetadata(metadataKey, metadataValue, target, targetKey) {\n  ordinaryDefineOwnMetadata(metadataKey, metadataValue, anObject(target), toMetaKey(targetKey));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar toMetaKey = metadata.key;\nvar getOrCreateMetadataMap = metadata.map;\nvar store = metadata.store;\n\nmetadata.exp({ deleteMetadata: function deleteMetadata(metadataKey, target /* , targetKey */) {\n  var targetKey = arguments.length < 3 ? undefined : toMetaKey(arguments[2]);\n  var metadataMap = getOrCreateMetadataMap(anObject(target), targetKey, false);\n  if (metadataMap === undefined || !metadataMap['delete'](metadataKey)) return false;\n  if (metadataMap.size) return true;\n  var targetMetadata = store.get(target);\n  targetMetadata['delete'](targetKey);\n  return !!targetMetadata.size || store['delete'](target);\n} });\n","var Set = require('./es6.set');\nvar from = require('./_array-from-iterable');\nvar metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar getPrototypeOf = require('./_object-gpo');\nvar ordinaryOwnMetadataKeys = metadata.keys;\nvar toMetaKey = metadata.key;\n\nvar ordinaryMetadataKeys = function (O, P) {\n  var oKeys = ordinaryOwnMetadataKeys(O, P);\n  var parent = getPrototypeOf(O);\n  if (parent === null) return oKeys;\n  var pKeys = ordinaryMetadataKeys(parent, P);\n  return pKeys.length ? oKeys.length ? from(new Set(oKeys.concat(pKeys))) : pKeys : oKeys;\n};\n\nmetadata.exp({ getMetadataKeys: function getMetadataKeys(target /* , targetKey */) {\n  return ordinaryMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar getPrototypeOf = require('./_object-gpo');\nvar ordinaryHasOwnMetadata = metadata.has;\nvar ordinaryGetOwnMetadata = metadata.get;\nvar toMetaKey = metadata.key;\n\nvar ordinaryGetMetadata = function (MetadataKey, O, P) {\n  var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);\n  if (hasOwn) return ordinaryGetOwnMetadata(MetadataKey, O, P);\n  var parent = getPrototypeOf(O);\n  return parent !== null ? ordinaryGetMetadata(MetadataKey, parent, P) : undefined;\n};\n\nmetadata.exp({ getMetadata: function getMetadata(metadataKey, target /* , targetKey */) {\n  return ordinaryGetMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar ordinaryOwnMetadataKeys = metadata.keys;\nvar toMetaKey = metadata.key;\n\nmetadata.exp({ getOwnMetadataKeys: function getOwnMetadataKeys(target /* , targetKey */) {\n  return ordinaryOwnMetadataKeys(anObject(target), arguments.length < 2 ? undefined : toMetaKey(arguments[1]));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar ordinaryGetOwnMetadata = metadata.get;\nvar toMetaKey = metadata.key;\n\nmetadata.exp({ getOwnMetadata: function getOwnMetadata(metadataKey, target /* , targetKey */) {\n  return ordinaryGetOwnMetadata(metadataKey, anObject(target)\n    , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar getPrototypeOf = require('./_object-gpo');\nvar ordinaryHasOwnMetadata = metadata.has;\nvar toMetaKey = metadata.key;\n\nvar ordinaryHasMetadata = function (MetadataKey, O, P) {\n  var hasOwn = ordinaryHasOwnMetadata(MetadataKey, O, P);\n  if (hasOwn) return true;\n  var parent = getPrototypeOf(O);\n  return parent !== null ? ordinaryHasMetadata(MetadataKey, parent, P) : false;\n};\n\nmetadata.exp({ hasMetadata: function hasMetadata(metadataKey, target /* , targetKey */) {\n  return ordinaryHasMetadata(metadataKey, anObject(target), arguments.length < 3 ? undefined : toMetaKey(arguments[2]));\n} });\n","var metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar ordinaryHasOwnMetadata = metadata.has;\nvar toMetaKey = metadata.key;\n\nmetadata.exp({ hasOwnMetadata: function hasOwnMetadata(metadataKey, target /* , targetKey */) {\n  return ordinaryHasOwnMetadata(metadataKey, anObject(target)\n    , arguments.length < 3 ? undefined : toMetaKey(arguments[2]));\n} });\n","var $metadata = require('./_metadata');\nvar anObject = require('./_an-object');\nvar aFunction = require('./_a-function');\nvar toMetaKey = $metadata.key;\nvar ordinaryDefineOwnMetadata = $metadata.set;\n\n$metadata.exp({ metadata: function metadata(metadataKey, metadataValue) {\n  return function decorator(target, targetKey) {\n    ordinaryDefineOwnMetadata(\n      metadataKey, metadataValue,\n      (targetKey !== undefined ? anObject : aFunction)(target),\n      toMetaKey(targetKey)\n    );\n  };\n} });\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from\nrequire('./_set-collection-from')('Set');\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of\nrequire('./_set-collection-of')('Set');\n","// https://github.com/DavidBruant/Map-Set.prototype.toJSON\nvar $export = require('./_export');\n\n$export($export.P + $export.R, 'Set', { toJSON: require('./_collection-to-json')('Set') });\n","'use strict';\n// https://github.com/mathiasbynens/String.prototype.at\nvar $export = require('./_export');\nvar $at = require('./_string-at')(true);\n\n$export($export.P, 'String', {\n  at: function at(pos) {\n    return $at(this, pos);\n  }\n});\n","'use strict';\n// https://tc39.github.io/String.prototype.matchAll/\nvar $export = require('./_export');\nvar defined = require('./_defined');\nvar toLength = require('./_to-length');\nvar isRegExp = require('./_is-regexp');\nvar getFlags = require('./_flags');\nvar RegExpProto = RegExp.prototype;\n\nvar $RegExpStringIterator = function (regexp, string) {\n  this._r = regexp;\n  this._s = string;\n};\n\nrequire('./_iter-create')($RegExpStringIterator, 'RegExp String', function next() {\n  var match = this._r.exec(this._s);\n  return { value: match, done: match === null };\n});\n\n$export($export.P, 'String', {\n  matchAll: function matchAll(regexp) {\n    defined(this);\n    if (!isRegExp(regexp)) throw TypeError(regexp + ' is not a regexp!');\n    var S = String(this);\n    var flags = 'flags' in RegExpProto ? String(regexp.flags) : getFlags.call(regexp);\n    var rx = new RegExp(regexp.source, ~flags.indexOf('g') ? flags : 'g' + flags);\n    rx.lastIndex = toLength(regexp.lastIndex);\n    return new $RegExpStringIterator(rx, S);\n  }\n});\n","'use strict';\n// https://github.com/tc39/proposal-string-pad-start-end\nvar $export = require('./_export');\nvar $pad = require('./_string-pad');\nvar userAgent = require('./_user-agent');\n\n// https://github.com/zloirock/core-js/issues/280\n$export($export.P + $export.F * /Version\\/10\\.\\d+(\\.\\d+)? Safari\\//.test(userAgent), 'String', {\n  padEnd: function padEnd(maxLength /* , fillString = ' ' */) {\n    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);\n  }\n});\n","'use strict';\n// https://github.com/tc39/proposal-string-pad-start-end\nvar $export = require('./_export');\nvar $pad = require('./_string-pad');\nvar userAgent = require('./_user-agent');\n\n// https://github.com/zloirock/core-js/issues/280\n$export($export.P + $export.F * /Version\\/10\\.\\d+(\\.\\d+)? Safari\\//.test(userAgent), 'String', {\n  padStart: function padStart(maxLength /* , fillString = ' ' */) {\n    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);\n  }\n});\n","'use strict';\n// https://github.com/sebmarkbage/ecmascript-string-left-right-trim\nrequire('./_string-trim')('trimLeft', function ($trim) {\n  return function trimLeft() {\n    return $trim(this, 1);\n  };\n}, 'trimStart');\n","'use strict';\n// https://github.com/sebmarkbage/ecmascript-string-left-right-trim\nrequire('./_string-trim')('trimRight', function ($trim) {\n  return function trimRight() {\n    return $trim(this, 2);\n  };\n}, 'trimEnd');\n","require('./_wks-define')('asyncIterator');\n","require('./_wks-define')('observable');\n","// https://github.com/tc39/proposal-global\nvar $export = require('./_export');\n\n$export($export.S, 'System', { global: require('./_global') });\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.from\nrequire('./_set-collection-from')('WeakMap');\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakmap.of\nrequire('./_set-collection-of')('WeakMap');\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.from\nrequire('./_set-collection-from')('WeakSet');\n","// https://tc39.github.io/proposal-setmap-offrom/#sec-weakset.of\nrequire('./_set-collection-of')('WeakSet');\n","var $iterators = require('./es6.array.iterator');\nvar getKeys = require('./_object-keys');\nvar redefine = require('./_redefine');\nvar global = require('./_global');\nvar hide = require('./_hide');\nvar Iterators = require('./_iterators');\nvar wks = require('./_wks');\nvar ITERATOR = wks('iterator');\nvar TO_STRING_TAG = wks('toStringTag');\nvar ArrayValues = Iterators.Array;\n\nvar DOMIterables = {\n  CSSRuleList: true, // TODO: Not spec compliant, should be false.\n  CSSStyleDeclaration: false,\n  CSSValueList: false,\n  ClientRectList: false,\n  DOMRectList: false,\n  DOMStringList: false,\n  DOMTokenList: true,\n  DataTransferItemList: false,\n  FileList: false,\n  HTMLAllCollection: false,\n  HTMLCollection: false,\n  HTMLFormElement: false,\n  HTMLSelectElement: false,\n  MediaList: true, // TODO: Not spec compliant, should be false.\n  MimeTypeArray: false,\n  NamedNodeMap: false,\n  NodeList: true,\n  PaintRequestList: false,\n  Plugin: false,\n  PluginArray: false,\n  SVGLengthList: false,\n  SVGNumberList: false,\n  SVGPathSegList: false,\n  SVGPointList: false,\n  SVGStringList: false,\n  SVGTransformList: false,\n  SourceBufferList: false,\n  StyleSheetList: true, // TODO: Not spec compliant, should be false.\n  TextTrackCueList: false,\n  TextTrackList: false,\n  TouchList: false\n};\n\nfor (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {\n  var NAME = collections[i];\n  var explicit = DOMIterables[NAME];\n  var Collection = global[NAME];\n  var proto = Collection && Collection.prototype;\n  var key;\n  if (proto) {\n    if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);\n    if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);\n    Iterators[NAME] = ArrayValues;\n    if (explicit) for (key in $iterators) if (!proto[key]) redefine(proto, key, $iterators[key], true);\n  }\n}\n","var $export = require('./_export');\nvar $task = require('./_task');\n$export($export.G + $export.B, {\n  setImmediate: $task.set,\n  clearImmediate: $task.clear\n});\n","// ie9- setTimeout & setInterval additional parameters fix\nvar global = require('./_global');\nvar $export = require('./_export');\nvar userAgent = require('./_user-agent');\nvar slice = [].slice;\nvar MSIE = /MSIE .\\./.test(userAgent); // <- dirty ie9- check\nvar wrap = function (set) {\n  return function (fn, time /* , ...args */) {\n    var boundArgs = arguments.length > 2;\n    var args = boundArgs ? slice.call(arguments, 2) : false;\n    return set(boundArgs ? function () {\n      // eslint-disable-next-line no-new-func\n      (typeof fn == 'function' ? fn : Function(fn)).apply(this, args);\n    } : fn, time);\n  };\n};\n$export($export.G + $export.B + $export.F * MSIE, {\n  setTimeout: wrap(global.setTimeout),\n  setInterval: wrap(global.setInterval)\n});\n","require('./modules/es6.symbol');\nrequire('./modules/es6.object.create');\nrequire('./modules/es6.object.define-property');\nrequire('./modules/es6.object.define-properties');\nrequire('./modules/es6.object.get-own-property-descriptor');\nrequire('./modules/es6.object.get-prototype-of');\nrequire('./modules/es6.object.keys');\nrequire('./modules/es6.object.get-own-property-names');\nrequire('./modules/es6.object.freeze');\nrequire('./modules/es6.object.seal');\nrequire('./modules/es6.object.prevent-extensions');\nrequire('./modules/es6.object.is-frozen');\nrequire('./modules/es6.object.is-sealed');\nrequire('./modules/es6.object.is-extensible');\nrequire('./modules/es6.object.assign');\nrequire('./modules/es6.object.is');\nrequire('./modules/es6.object.set-prototype-of');\nrequire('./modules/es6.object.to-string');\nrequire('./modules/es6.function.bind');\nrequire('./modules/es6.function.name');\nrequire('./modules/es6.function.has-instance');\nrequire('./modules/es6.parse-int');\nrequire('./modules/es6.parse-float');\nrequire('./modules/es6.number.constructor');\nrequire('./modules/es6.number.to-fixed');\nrequire('./modules/es6.number.to-precision');\nrequire('./modules/es6.number.epsilon');\nrequire('./modules/es6.number.is-finite');\nrequire('./modules/es6.number.is-integer');\nrequire('./modules/es6.number.is-nan');\nrequire('./modules/es6.number.is-safe-integer');\nrequire('./modules/es6.number.max-safe-integer');\nrequire('./modules/es6.number.min-safe-integer');\nrequire('./modules/es6.number.parse-float');\nrequire('./modules/es6.number.parse-int');\nrequire('./modules/es6.math.acosh');\nrequire('./modules/es6.math.asinh');\nrequire('./modules/es6.math.atanh');\nrequire('./modules/es6.math.cbrt');\nrequire('./modules/es6.math.clz32');\nrequire('./modules/es6.math.cosh');\nrequire('./modules/es6.math.expm1');\nrequire('./modules/es6.math.fround');\nrequire('./modules/es6.math.hypot');\nrequire('./modules/es6.math.imul');\nrequire('./modules/es6.math.log10');\nrequire('./modules/es6.math.log1p');\nrequire('./modules/es6.math.log2');\nrequire('./modules/es6.math.sign');\nrequire('./modules/es6.math.sinh');\nrequire('./modules/es6.math.tanh');\nrequire('./modules/es6.math.trunc');\nrequire('./modules/es6.string.from-code-point');\nrequire('./modules/es6.string.raw');\nrequire('./modules/es6.string.trim');\nrequire('./modules/es6.string.iterator');\nrequire('./modules/es6.string.code-point-at');\nrequire('./modules/es6.string.ends-with');\nrequire('./modules/es6.string.includes');\nrequire('./modules/es6.string.repeat');\nrequire('./modules/es6.string.starts-with');\nrequire('./modules/es6.string.anchor');\nrequire('./modules/es6.string.big');\nrequire('./modules/es6.string.blink');\nrequire('./modules/es6.string.bold');\nrequire('./modules/es6.string.fixed');\nrequire('./modules/es6.string.fontcolor');\nrequire('./modules/es6.string.fontsize');\nrequire('./modules/es6.string.italics');\nrequire('./modules/es6.string.link');\nrequire('./modules/es6.string.small');\nrequire('./modules/es6.string.strike');\nrequire('./modules/es6.string.sub');\nrequire('./modules/es6.string.sup');\nrequire('./modules/es6.date.now');\nrequire('./modules/es6.date.to-json');\nrequire('./modules/es6.date.to-iso-string');\nrequire('./modules/es6.date.to-string');\nrequire('./modules/es6.date.to-primitive');\nrequire('./modules/es6.array.is-array');\nrequire('./modules/es6.array.from');\nrequire('./modules/es6.array.of');\nrequire('./modules/es6.array.join');\nrequire('./modules/es6.array.slice');\nrequire('./modules/es6.array.sort');\nrequire('./modules/es6.array.for-each');\nrequire('./modules/es6.array.map');\nrequire('./modules/es6.array.filter');\nrequire('./modules/es6.array.some');\nrequire('./modules/es6.array.every');\nrequire('./modules/es6.array.reduce');\nrequire('./modules/es6.array.reduce-right');\nrequire('./modules/es6.array.index-of');\nrequire('./modules/es6.array.last-index-of');\nrequire('./modules/es6.array.copy-within');\nrequire('./modules/es6.array.fill');\nrequire('./modules/es6.array.find');\nrequire('./modules/es6.array.find-index');\nrequire('./modules/es6.array.species');\nrequire('./modules/es6.array.iterator');\nrequire('./modules/es6.regexp.constructor');\nrequire('./modules/es6.regexp.exec');\nrequire('./modules/es6.regexp.to-string');\nrequire('./modules/es6.regexp.flags');\nrequire('./modules/es6.regexp.match');\nrequire('./modules/es6.regexp.replace');\nrequire('./modules/es6.regexp.search');\nrequire('./modules/es6.regexp.split');\nrequire('./modules/es6.promise');\nrequire('./modules/es6.map');\nrequire('./modules/es6.set');\nrequire('./modules/es6.weak-map');\nrequire('./modules/es6.weak-set');\nrequire('./modules/es6.typed.array-buffer');\nrequire('./modules/es6.typed.data-view');\nrequire('./modules/es6.typed.int8-array');\nrequire('./modules/es6.typed.uint8-array');\nrequire('./modules/es6.typed.uint8-clamped-array');\nrequire('./modules/es6.typed.int16-array');\nrequire('./modules/es6.typed.uint16-array');\nrequire('./modules/es6.typed.int32-array');\nrequire('./modules/es6.typed.uint32-array');\nrequire('./modules/es6.typed.float32-array');\nrequire('./modules/es6.typed.float64-array');\nrequire('./modules/es6.reflect.apply');\nrequire('./modules/es6.reflect.construct');\nrequire('./modules/es6.reflect.define-property');\nrequire('./modules/es6.reflect.delete-property');\nrequire('./modules/es6.reflect.enumerate');\nrequire('./modules/es6.reflect.get');\nrequire('./modules/es6.reflect.get-own-property-descriptor');\nrequire('./modules/es6.reflect.get-prototype-of');\nrequire('./modules/es6.reflect.has');\nrequire('./modules/es6.reflect.is-extensible');\nrequire('./modules/es6.reflect.own-keys');\nrequire('./modules/es6.reflect.prevent-extensions');\nrequire('./modules/es6.reflect.set');\nrequire('./modules/es6.reflect.set-prototype-of');\nrequire('./modules/es7.array.includes');\nrequire('./modules/es7.array.flat-map');\nrequire('./modules/es7.array.flatten');\nrequire('./modules/es7.string.at');\nrequire('./modules/es7.string.pad-start');\nrequire('./modules/es7.string.pad-end');\nrequire('./modules/es7.string.trim-left');\nrequire('./modules/es7.string.trim-right');\nrequire('./modules/es7.string.match-all');\nrequire('./modules/es7.symbol.async-iterator');\nrequire('./modules/es7.symbol.observable');\nrequire('./modules/es7.object.get-own-property-descriptors');\nrequire('./modules/es7.object.values');\nrequire('./modules/es7.object.entries');\nrequire('./modules/es7.object.define-getter');\nrequire('./modules/es7.object.define-setter');\nrequire('./modules/es7.object.lookup-getter');\nrequire('./modules/es7.object.lookup-setter');\nrequire('./modules/es7.map.to-json');\nrequire('./modules/es7.set.to-json');\nrequire('./modules/es7.map.of');\nrequire('./modules/es7.set.of');\nrequire('./modules/es7.weak-map.of');\nrequire('./modules/es7.weak-set.of');\nrequire('./modules/es7.map.from');\nrequire('./modules/es7.set.from');\nrequire('./modules/es7.weak-map.from');\nrequire('./modules/es7.weak-set.from');\nrequire('./modules/es7.global');\nrequire('./modules/es7.system.global');\nrequire('./modules/es7.error.is-error');\nrequire('./modules/es7.math.clamp');\nrequire('./modules/es7.math.deg-per-rad');\nrequire('./modules/es7.math.degrees');\nrequire('./modules/es7.math.fscale');\nrequire('./modules/es7.math.iaddh');\nrequire('./modules/es7.math.isubh');\nrequire('./modules/es7.math.imulh');\nrequire('./modules/es7.math.rad-per-deg');\nrequire('./modules/es7.math.radians');\nrequire('./modules/es7.math.scale');\nrequire('./modules/es7.math.umulh');\nrequire('./modules/es7.math.signbit');\nrequire('./modules/es7.promise.finally');\nrequire('./modules/es7.promise.try');\nrequire('./modules/es7.reflect.define-metadata');\nrequire('./modules/es7.reflect.delete-metadata');\nrequire('./modules/es7.reflect.get-metadata');\nrequire('./modules/es7.reflect.get-metadata-keys');\nrequire('./modules/es7.reflect.get-own-metadata');\nrequire('./modules/es7.reflect.get-own-metadata-keys');\nrequire('./modules/es7.reflect.has-metadata');\nrequire('./modules/es7.reflect.has-own-metadata');\nrequire('./modules/es7.reflect.metadata');\nrequire('./modules/es7.asap');\nrequire('./modules/es7.observable');\nrequire('./modules/web.timers');\nrequire('./modules/web.immediate');\nrequire('./modules/web.dom.iterable');\nmodule.exports = require('./modules/_core');\n","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n","/**\n * Convert array of 16 byte values to UUID string format of the form:\n * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX\n */\nvar byteToHex = [];\nfor (var i = 0; i < 256; ++i) {\n  byteToHex[i] = (i + 0x100).toString(16).substr(1);\n}\n\nfunction bytesToUuid(buf, offset) {\n  var i = offset || 0;\n  var bth = byteToHex;\n  // join used to fix memory issue caused by concatenation: https://bugs.chromium.org/p/v8/issues/detail?id=3175#c4\n  return ([bth[buf[i++]], bth[buf[i++]], \n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]], '-',\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]],\n\tbth[buf[i++]], bth[buf[i++]]]).join('');\n}\n\nmodule.exports = bytesToUuid;\n","// Unique ID creation requires a high quality random # generator.  In the\n// browser this is a little complicated due to unknown quality of Math.random()\n// and inconsistent support for the `crypto` API.  We do the best we can via\n// feature-detection\n\n// getRandomValues needs to be invoked in a context where \"this\" is a Crypto\n// implementation. Also, find the complete implementation of crypto on IE11.\nvar getRandomValues = (typeof(crypto) != 'undefined' && crypto.getRandomValues && crypto.getRandomValues.bind(crypto)) ||\n                      (typeof(msCrypto) != 'undefined' && typeof window.msCrypto.getRandomValues == 'function' && msCrypto.getRandomValues.bind(msCrypto));\n\nif (getRandomValues) {\n  // WHATWG crypto RNG - http://wiki.whatwg.org/wiki/Crypto\n  var rnds8 = new Uint8Array(16); // eslint-disable-line no-undef\n\n  module.exports = function whatwgRNG() {\n    getRandomValues(rnds8);\n    return rnds8;\n  };\n} else {\n  // Math.random()-based (RNG)\n  //\n  // If all else fails, use Math.random().  It's fast, but is of unspecified\n  // quality.\n  var rnds = new Array(16);\n\n  module.exports = function mathRNG() {\n    for (var i = 0, r; i < 16; i++) {\n      if ((i & 0x03) === 0) r = Math.random() * 0x100000000;\n      rnds[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return rnds;\n  };\n}\n","var rng = require('./lib/rng');\nvar bytesToUuid = require('./lib/bytesToUuid');\n\nfunction v4(options, buf, offset) {\n  var i = buf && offset || 0;\n\n  if (typeof(options) == 'string') {\n    buf = options === 'binary' ? new Array(16) : null;\n    options = null;\n  }\n  options = options || {};\n\n  var rnds = options.random || (options.rng || rng)();\n\n  // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`\n  rnds[6] = (rnds[6] & 0x0f) | 0x40;\n  rnds[8] = (rnds[8] & 0x3f) | 0x80;\n\n  // Copy bytes to buffer, if provided\n  if (buf) {\n    for (var ii = 0; ii < 16; ++ii) {\n      buf[i + ii] = rnds[ii];\n    }\n  }\n\n  return buf || bytesToUuid(rnds);\n}\n\nmodule.exports = v4;\n","var g;\n\n// This works in non-strict mode\ng = (function() {\n\treturn this;\n})();\n\ntry {\n\t// This works if eval is allowed (see CSP)\n\tg = g || new Function(\"return this\")();\n} catch (e) {\n\t// This works if the window reference is available\n\tif (typeof window === \"object\") g = window;\n}\n\n// g can still be undefined, but nothing to do about it...\n// We return undefined, instead of nothing here, so it's\n// easier to handle this case. if(!global) { ...}\n\nmodule.exports = g;\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { Timer } from './Timer.js';\r\n\r\nconst DefaultAccessTokenExpiringNotificationTime = 60; // seconds\r\n\r\nexport class AccessTokenEvents {\r\n\r\n    constructor({\r\n        accessTokenExpiringNotificationTime = DefaultAccessTokenExpiringNotificationTime,\r\n        accessTokenExpiringTimer = new Timer(\"Access token expiring\"),\r\n        accessTokenExpiredTimer = new Timer(\"Access token expired\")\r\n    } = {}) {\r\n        this._accessTokenExpiringNotificationTime = accessTokenExpiringNotificationTime;\r\n\r\n        this._accessTokenExpiring = accessTokenExpiringTimer;\r\n        this._accessTokenExpired = accessTokenExpiredTimer;\r\n    }\r\n\r\n    load(container) {\r\n        // only register events if there's an access token and it has an expiration\r\n        if (container.access_token && container.expires_in !== undefined) {\r\n            let duration = container.expires_in;\r\n            Log.debug(\"AccessTokenEvents.load: access token present, remaining duration:\", duration);\r\n\r\n            if (duration > 0) {\r\n                // only register expiring if we still have time\r\n                let expiring = duration - this._accessTokenExpiringNotificationTime;\r\n                if (expiring <= 0){\r\n                    expiring = 1;\r\n                }\r\n                \r\n                Log.debug(\"AccessTokenEvents.load: registering expiring timer in:\", expiring);\r\n                this._accessTokenExpiring.init(expiring);\r\n            }\r\n            else {\r\n                Log.debug(\"AccessTokenEvents.load: canceling existing expiring timer becase we're past expiration.\");\r\n                this._accessTokenExpiring.cancel();\r\n            }\r\n\r\n            // if it's negative, it will still fire\r\n            let expired = duration + 1;\r\n            Log.debug(\"AccessTokenEvents.load: registering expired timer in:\", expired);\r\n            this._accessTokenExpired.init(expired);\r\n        }\r\n        else {\r\n            this._accessTokenExpiring.cancel();\r\n            this._accessTokenExpired.cancel();\r\n        }\r\n    }\r\n\r\n    unload() {\r\n        Log.debug(\"AccessTokenEvents.unload: canceling existing access token timers\");\r\n        this._accessTokenExpiring.cancel();\r\n        this._accessTokenExpired.cancel();\r\n    }\r\n\r\n    addAccessTokenExpiring(cb) {\r\n        this._accessTokenExpiring.addHandler(cb);\r\n    }\r\n    removeAccessTokenExpiring(cb) {\r\n        this._accessTokenExpiring.removeHandler(cb);\r\n    }\r\n\r\n    addAccessTokenExpired(cb) {\r\n        this._accessTokenExpired.addHandler(cb);\r\n    }\r\n    removeAccessTokenExpired(cb) {\r\n        this._accessTokenExpired.removeHandler(cb);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nconst DefaultInterval = 2000;\r\n\r\nexport class CheckSessionIFrame {\r\n    constructor(callback, client_id, url, interval, stopOnError = true) {\r\n        this._callback = callback;\r\n        this._client_id = client_id;\r\n        this._url = url;\r\n        this._interval = interval || DefaultInterval;\r\n        this._stopOnError = stopOnError;\r\n\r\n        var idx = url.indexOf(\"/\", url.indexOf(\"//\") + 2);\r\n        this._frame_origin = url.substr(0, idx);\r\n\r\n        this._frame = window.document.createElement(\"iframe\");\r\n\r\n        // shotgun approach\r\n        this._frame.style.visibility = \"hidden\";\r\n        this._frame.style.position = \"absolute\";\r\n        this._frame.style.display = \"none\";\r\n        this._frame.style.width = 0;\r\n        this._frame.style.height = 0;\r\n\r\n        this._frame.src = url;\r\n    }\r\n    load() {\r\n        return new Promise((resolve) => {\r\n            this._frame.onload = () => {\r\n                resolve();\r\n            }\r\n\r\n            window.document.body.appendChild(this._frame);\r\n            this._boundMessageEvent = this._message.bind(this);\r\n            window.addEventListener(\"message\", this._boundMessageEvent, false);\r\n        });\r\n    }\r\n    _message(e) {\r\n        if (e.origin === this._frame_origin &&\r\n            e.source === this._frame.contentWindow\r\n        ) {\r\n            if (e.data === \"error\") {\r\n                Log.error(\"CheckSessionIFrame: error message from check session op iframe\");\r\n                if (this._stopOnError) {\r\n                    this.stop();\r\n                }\r\n            }\r\n            else if (e.data === \"changed\") {\r\n                Log.debug(\"CheckSessionIFrame: changed message from check session op iframe\");\r\n                this.stop();\r\n                this._callback();\r\n            }\r\n            else {\r\n                Log.debug(\"CheckSessionIFrame: \" + e.data + \" message from check session op iframe\");\r\n            }\r\n        }\r\n    }\r\n    start(session_state) {\r\n        if (this._session_state !== session_state) {\r\n            Log.debug(\"CheckSessionIFrame.start\");\r\n\r\n            this.stop();\r\n\r\n            this._session_state = session_state;\r\n\r\n            let send = () => {\r\n                this._frame.contentWindow.postMessage(this._client_id + \" \" + this._session_state, this._frame_origin);\r\n            };\r\n            \r\n            // trigger now\r\n            send();\r\n\r\n            // and setup timer\r\n            this._timer = window.setInterval(send, this._interval);\r\n        }\r\n    }\r\n\r\n    stop() {\r\n        this._session_state = null;\r\n\r\n        if (this._timer) {\r\n            Log.debug(\"CheckSessionIFrame.stop\");\r\n\r\n            window.clearInterval(this._timer);\r\n            this._timer = null;\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { CordovaPopupWindow } from './CordovaPopupWindow.js';\r\n\r\nexport class CordovaIFrameNavigator {\r\n\r\n    prepare(params) {\r\n        params.popupWindowFeatures = 'hidden=yes';\r\n        let popup = new CordovaPopupWindow(params);\r\n        return Promise.resolve(popup);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { CordovaPopupWindow } from './CordovaPopupWindow.js';\r\n\r\nexport class CordovaPopupNavigator {\r\n\r\n    prepare(params) {\r\n        let popup = new CordovaPopupWindow(params);\r\n        return Promise.resolve(popup);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nconst DefaultPopupFeatures = 'location=no,toolbar=no,zoom=no';\r\nconst DefaultPopupTarget = \"_blank\";\r\n\r\nexport class CordovaPopupWindow {\r\n\r\n    constructor(params) {\r\n        this._promise = new Promise((resolve, reject) => {\r\n            this._resolve = resolve;\r\n            this._reject = reject;\r\n        });\r\n\r\n        this.features = params.popupWindowFeatures || DefaultPopupFeatures;\r\n        this.target = params.popupWindowTarget || DefaultPopupTarget;\r\n        \r\n        this.redirect_uri = params.startUrl;\r\n        Log.debug(\"CordovaPopupWindow.ctor: redirect_uri: \" + this.redirect_uri);\r\n    }\r\n\r\n    _isInAppBrowserInstalled(cordovaMetadata) {\r\n        return [\"cordova-plugin-inappbrowser\", \"cordova-plugin-inappbrowser.inappbrowser\", \"org.apache.cordova.inappbrowser\"].some(function (name) {\r\n            return cordovaMetadata.hasOwnProperty(name)\r\n        })\r\n    }\r\n    \r\n    navigate(params) {\r\n        if (!params || !params.url) {\r\n            this._error(\"No url provided\");\r\n        } else {\r\n            if (!window.cordova) {\r\n                return this._error(\"cordova is undefined\")\r\n            }\r\n            \r\n            var cordovaMetadata = window.cordova.require(\"cordova/plugin_list\").metadata;\r\n            if (this._isInAppBrowserInstalled(cordovaMetadata) === false) {\r\n                return this._error(\"InAppBrowser plugin not found\")\r\n            }\r\n            this._popup = cordova.InAppBrowser.open(params.url, this.target, this.features);\r\n            if (this._popup) {\r\n                Log.debug(\"CordovaPopupWindow.navigate: popup successfully created\");\r\n                \r\n                this._exitCallbackEvent = this._exitCallback.bind(this); \r\n                this._loadStartCallbackEvent = this._loadStartCallback.bind(this);\r\n                \r\n                this._popup.addEventListener(\"exit\", this._exitCallbackEvent, false);\r\n                this._popup.addEventListener(\"loadstart\", this._loadStartCallbackEvent, false);\r\n            } else {\r\n                this._error(\"Error opening popup window\");\r\n            }\r\n        }\r\n        return this.promise;\r\n    }\r\n\r\n    get promise() {\r\n        return this._promise;\r\n    }\r\n\r\n    _loadStartCallback(event) {\r\n        if (event.url.indexOf(this.redirect_uri) === 0) {\r\n            this._success({ url: event.url });\r\n        }    \r\n    }\r\n    _exitCallback(message) {\r\n        this._error(message);    \r\n    }\r\n    \r\n    _success(data) {\r\n        this._cleanup();\r\n\r\n        Log.debug(\"CordovaPopupWindow: Successful response from cordova popup window\");\r\n        this._resolve(data);\r\n    }\r\n    _error(message) {\r\n        this._cleanup();\r\n\r\n        Log.error(message);\r\n        this._reject(new Error(message));\r\n    }\r\n\r\n    close() {\r\n        this._cleanup();\r\n    }\r\n\r\n    _cleanup() {\r\n        if (this._popup){\r\n            Log.debug(\"CordovaPopupWindow: cleaning up popup\");\r\n            this._popup.removeEventListener(\"exit\", this._exitCallbackEvent, false);\r\n            this._popup.removeEventListener(\"loadstart\", this._loadStartCallbackEvent, false);\r\n            this._popup.close();\r\n        }\r\n        this._popup = null;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class ErrorResponse extends Error {\r\n    constructor({error, error_description, error_uri, state, session_state}={}\r\n    ) {\r\n         if (!error){\r\n            Log.error(\"No error passed to ErrorResponse\");\r\n            throw new Error(\"error\");\r\n        }\r\n\r\n        super(error_description || error);\r\n\r\n        this.name = \"ErrorResponse\";\r\n\r\n        this.error = error;\r\n        this.error_description = error_description;\r\n        this.error_uri = error_uri;\r\n\r\n        this.state = state;\r\n        this.session_state = session_state;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class Event {\r\n\r\n    constructor(name) {\r\n        this._name = name;\r\n        this._callbacks = [];\r\n    }\r\n\r\n    addHandler(cb) {\r\n        this._callbacks.push(cb);\r\n    }\r\n\r\n    removeHandler(cb) {\r\n        var idx = this._callbacks.findIndex(item => item === cb);\r\n        if (idx >= 0) {\r\n            this._callbacks.splice(idx, 1);\r\n        }\r\n    }\r\n\r\n    raise(...params) {\r\n        Log.debug(\"Event: Raising event: \" + this._name);\r\n        for (let i = 0; i < this._callbacks.length; i++) {\r\n            this._callbacks[i](...params);\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nconst timer = {\r\n    setInterval: function (cb, duration) {\r\n        return setInterval(cb, duration);\r\n    },\r\n    clearInterval: function (handle) {\r\n        return clearInterval(handle);\r\n    }\r\n};\r\n\r\nlet testing = false;\r\nlet request = null;\r\n\r\nexport class Global {\r\n\r\n    static _testing() {\r\n        testing = true;\r\n    }\r\n\r\n    static get location() {\r\n        if (!testing) {\r\n            return location;\r\n        }\r\n    }\r\n\r\n    static get localStorage() {\r\n        if (!testing && typeof window !== 'undefined') {\r\n            return localStorage;\r\n        }\r\n    }\r\n\r\n    static get sessionStorage() {\r\n        if (!testing && typeof window !== 'undefined') {\r\n            return sessionStorage;\r\n        }\r\n    }\r\n\r\n    static setXMLHttpRequest(newRequest) {\r\n        request = newRequest;\r\n    }\r\n\r\n    static get XMLHttpRequest() {\r\n        if (!testing && typeof window !== 'undefined') {\r\n            return request || XMLHttpRequest;\r\n        }\r\n    }\r\n\r\n    static get timer() {\r\n        if (!testing) {\r\n            return timer;\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { IFrameWindow } from './IFrameWindow.js';\r\n\r\nexport class IFrameNavigator {\r\n\r\n    prepare(params) {\r\n        let frame = new IFrameWindow(params);\r\n        return Promise.resolve(frame);\r\n    }\r\n\r\n    callback(url) {\r\n        Log.debug(\"IFrameNavigator.callback\");\r\n\r\n        try {\r\n            IFrameWindow.notifyParent(url);\r\n            return Promise.resolve();\r\n        }\r\n        catch (e) {\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nconst DefaultTimeout = 10000;\r\n\r\nexport class IFrameWindow {\r\n\r\n    constructor(params) {\r\n        this._promise = new Promise((resolve, reject) => {\r\n            this._resolve = resolve;\r\n            this._reject = reject;\r\n        });\r\n\r\n        this._boundMessageEvent = this._message.bind(this);\r\n        window.addEventListener(\"message\", this._boundMessageEvent, false);\r\n\r\n        this._frame = window.document.createElement(\"iframe\");\r\n\r\n        // shotgun approach\r\n        this._frame.style.visibility = \"hidden\";\r\n        this._frame.style.position = \"absolute\";\r\n        this._frame.style.display = \"none\";\r\n        this._frame.style.width = 0;\r\n        this._frame.style.height = 0;\r\n\r\n        window.document.body.appendChild(this._frame);\r\n    }\r\n\r\n    navigate(params) {\r\n        if (!params || !params.url) {\r\n            this._error(\"No url provided\");\r\n        }\r\n        else {\r\n            let timeout = params.silentRequestTimeout || DefaultTimeout;\r\n            Log.debug(\"IFrameWindow.navigate: Using timeout of:\", timeout);\r\n            this._timer = window.setTimeout(this._timeout.bind(this), timeout);\r\n            this._frame.src = params.url;\r\n        }\r\n\r\n        return this.promise;\r\n    }\r\n\r\n    get promise() {\r\n        return this._promise;\r\n    }\r\n\r\n    _success(data) {\r\n        this._cleanup();\r\n\r\n        Log.debug(\"IFrameWindow: Successful response from frame window\");\r\n        this._resolve(data);\r\n    }\r\n    _error(message) {\r\n        this._cleanup();\r\n\r\n        Log.error(message);\r\n        this._reject(new Error(message));\r\n    }\r\n\r\n    close() {\r\n        this._cleanup();\r\n    }\r\n\r\n    _cleanup() {\r\n        if (this._frame) {\r\n            Log.debug(\"IFrameWindow: cleanup\");\r\n\r\n            window.removeEventListener(\"message\", this._boundMessageEvent, false);\r\n            window.clearTimeout(this._timer);\r\n            window.document.body.removeChild(this._frame);\r\n\r\n            this._timer = null;\r\n            this._frame = null;\r\n            this._boundMessageEvent = null;\r\n        }\r\n    }\r\n\r\n    _timeout() {\r\n        Log.debug(\"IFrameWindow.timeout\");\r\n        this._error(\"Frame window timed out\");\r\n    }\r\n\r\n    _message(e) {\r\n        Log.debug(\"IFrameWindow.message\");\r\n\r\n        if (this._timer &&\r\n            e.origin === this._origin &&\r\n            e.source === this._frame.contentWindow\r\n        ) {\r\n            let url = e.data;\r\n            if (url) {\r\n                this._success({ url: url });\r\n            }\r\n            else {\r\n                this._error(\"Invalid response from frame\");\r\n            }\r\n        }\r\n    }\r\n\r\n    get _origin() {\r\n        return location.protocol + \"//\" + location.host;\r\n    }\r\n\r\n    static notifyParent(url) {\r\n        Log.debug(\"IFrameWindow.notifyParent\");\r\n        if (window.frameElement) {\r\n            url = url || window.location.href;\r\n            if (url) {\r\n                Log.debug(\"IFrameWindow.notifyParent: posting url message to parent\");\r\n                window.parent.postMessage(url, location.protocol + \"//\" + location.host);\r\n            }\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class InMemoryWebStorage{\r\n    constructor(){\r\n        this._data = {};\r\n    }\r\n\r\n    getItem(key) {\r\n        Log.debug(\"InMemoryWebStorage.getItem\", key);\r\n        return this._data[key];\r\n    }\r\n\r\n    setItem(key, value){\r\n        Log.debug(\"InMemoryWebStorage.setItem\", key);\r\n        this._data[key] = value;\r\n    }\r\n\r\n    removeItem(key){\r\n        Log.debug(\"InMemoryWebStorage.removeItem\", key);\r\n        delete this._data[key];\r\n    }\r\n\r\n    get length() {\r\n        return Object.getOwnPropertyNames(this._data).length;\r\n    }\r\n\r\n    key(index) {\r\n        return Object.getOwnPropertyNames(this._data)[index];\r\n    }\r\n}\r\n","import { jws, KeyUtil, X509, crypto, hextob64u, b64tohex, AllowedSigningAlgs } from './crypto/jsrsasign';\r\nimport getJoseUtil from './JoseUtilImpl';\r\n\r\nexport const JoseUtil = getJoseUtil({ jws, KeyUtil, X509, crypto, hextob64u, b64tohex, AllowedSigningAlgs });\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport default function getJoseUtil({ jws, KeyUtil, X509, crypto, hextob64u, b64tohex, AllowedSigningAlgs }) {\r\n    return class JoseUtil {\r\n\r\n        static parseJwt(jwt) {\r\n            Log.debug(\"JoseUtil.parseJwt\");\r\n            try {\r\n                var token = jws.JWS.parse(jwt);\r\n                return {\r\n                    header: token.headerObj,\r\n                    payload: token.payloadObj\r\n                }\r\n            } catch (e) {\r\n                Log.error(e);\r\n            }\r\n        }\r\n\r\n        static validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive) {\r\n            Log.debug(\"JoseUtil.validateJwt\");\r\n\r\n            try {\r\n                if (key.kty === \"RSA\") {\r\n                    if (key.e && key.n) {\r\n                        key = KeyUtil.getKey(key);\r\n                    } else if (key.x5c && key.x5c.length) {\r\n                        var hex = b64tohex(key.x5c[0]);\r\n                        key = X509.getPublicKeyFromCertHex(hex);\r\n                    } else {\r\n                        Log.error(\"JoseUtil.validateJwt: RSA key missing key material\", key);\r\n                        return Promise.reject(new Error(\"RSA key missing key material\"));\r\n                    }\r\n                } else if (key.kty === \"EC\") {\r\n                    if (key.crv && key.x && key.y) {\r\n                        key = KeyUtil.getKey(key);\r\n                    } else {\r\n                        Log.error(\"JoseUtil.validateJwt: EC key missing key material\", key);\r\n                        return Promise.reject(new Error(\"EC key missing key material\"));\r\n                    }\r\n                } else {\r\n                    Log.error(\"JoseUtil.validateJwt: Unsupported key type\", key && key.kty);\r\n                    return Promise.reject(new Error(\"Unsupported key type: \" + key && key.kty));\r\n                }\r\n\r\n                return JoseUtil._validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive);\r\n            } catch (e) {\r\n                Log.error(e && e.message || e);\r\n                return Promise.reject(\"JWT validation failed\");\r\n            }\r\n        }\r\n\r\n        static validateJwtAttributes(jwt, issuer, audience, clockSkew, now, timeInsensitive) {\r\n            if (!clockSkew) {\r\n                clockSkew = 0;\r\n            }\r\n\r\n            if (!now) {\r\n                now = parseInt(Date.now() / 1000);\r\n            }\r\n\r\n            var payload = JoseUtil.parseJwt(jwt).payload;\r\n\r\n            if (!payload.iss) {\r\n                Log.error(\"JoseUtil._validateJwt: issuer was not provided\");\r\n                return Promise.reject(new Error(\"issuer was not provided\"));\r\n            }\r\n            if (payload.iss !== issuer) {\r\n                Log.error(\"JoseUtil._validateJwt: Invalid issuer in token\", payload.iss);\r\n                return Promise.reject(new Error(\"Invalid issuer in token: \" + payload.iss));\r\n            }\r\n\r\n            if (!payload.aud) {\r\n                Log.error(\"JoseUtil._validateJwt: aud was not provided\");\r\n                return Promise.reject(new Error(\"aud was not provided\"));\r\n            }\r\n            var validAudience = payload.aud === audience || (Array.isArray(payload.aud) && payload.aud.indexOf(audience) >= 0);\r\n            if (!validAudience) {\r\n                Log.error(\"JoseUtil._validateJwt: Invalid audience in token\", payload.aud);\r\n                return Promise.reject(new Error(\"Invalid audience in token: \" + payload.aud));\r\n            }\r\n            if (payload.azp && payload.azp !== audience) {\r\n                Log.error(\"JoseUtil._validateJwt: Invalid azp in token\", payload.azp);\r\n                return Promise.reject(new Error(\"Invalid azp in token: \" + payload.azp));\r\n            }\r\n\r\n            if (!timeInsensitive) {\r\n                var lowerNow = now + clockSkew;\r\n                var upperNow = now - clockSkew;\r\n\r\n                if (!payload.iat) {\r\n                    Log.error(\"JoseUtil._validateJwt: iat was not provided\");\r\n                    return Promise.reject(new Error(\"iat was not provided\"));\r\n                }\r\n                if (lowerNow < payload.iat) {\r\n                    Log.error(\"JoseUtil._validateJwt: iat is in the future\", payload.iat);\r\n                    return Promise.reject(new Error(\"iat is in the future: \" + payload.iat));\r\n                }\r\n\r\n                if (payload.nbf && lowerNow < payload.nbf) {\r\n                    Log.error(\"JoseUtil._validateJwt: nbf is in the future\", payload.nbf);\r\n                    return Promise.reject(new Error(\"nbf is in the future: \" + payload.nbf));\r\n                }\r\n\r\n                if (!payload.exp) {\r\n                    Log.error(\"JoseUtil._validateJwt: exp was not provided\");\r\n                    return Promise.reject(new Error(\"exp was not provided\"));\r\n                }\r\n                if (payload.exp < upperNow) {\r\n                    Log.error(\"JoseUtil._validateJwt: exp is in the past\", payload.exp);\r\n                    return Promise.reject(new Error(\"exp is in the past:\" + payload.exp));\r\n                }\r\n            }\r\n\r\n            return Promise.resolve(payload);\r\n        }\r\n\r\n        static _validateJwt(jwt, key, issuer, audience, clockSkew, now, timeInsensitive) {\r\n\r\n            return JoseUtil.validateJwtAttributes(jwt, issuer, audience, clockSkew, now, timeInsensitive).then(payload => {\r\n                try {\r\n                    if (!jws.JWS.verify(jwt, key, AllowedSigningAlgs)) {\r\n                        Log.error(\"JoseUtil._validateJwt: signature validation failed\");\r\n                        return Promise.reject(new Error(\"signature validation failed\"));\r\n                    }\r\n\r\n                    return payload;\r\n                } catch (e) {\r\n                    Log.error(e && e.message || e);\r\n                    return Promise.reject(new Error(\"signature validation failed\"));\r\n                }\r\n            });\r\n        }\r\n\r\n        static hashString(value, alg) {\r\n            try {\r\n                return crypto.Util.hashString(value, alg);\r\n            } catch (e) {\r\n                Log.error(e);\r\n            }\r\n        }\r\n\r\n        static hexToBase64Url(value) {\r\n            try {\r\n                return hextob64u(value);\r\n            } catch (e) {\r\n                Log.error(e);\r\n            }\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { Global } from './Global.js';\r\n\r\nexport class JsonService {\r\n    constructor(\r\n        additionalContentTypes = null, \r\n        XMLHttpRequestCtor = Global.XMLHttpRequest, \r\n        jwtHandler = null\r\n    ) {\r\n        if (additionalContentTypes && Array.isArray(additionalContentTypes))\r\n        {\r\n            this._contentTypes = additionalContentTypes.slice();\r\n        }\r\n        else\r\n        {\r\n            this._contentTypes = [];\r\n        }\r\n        this._contentTypes.push('application/json');\r\n        if (jwtHandler) {\r\n            this._contentTypes.push('application/jwt');\r\n        }\r\n\r\n        this._XMLHttpRequest = XMLHttpRequestCtor;\r\n        this._jwtHandler = jwtHandler;\r\n    }\r\n\r\n    getJson(url, token) {\r\n        if (!url){\r\n            Log.error(\"JsonService.getJson: No url passed\");\r\n            throw new Error(\"url\");\r\n        }\r\n\r\n        Log.debug(\"JsonService.getJson, url: \", url);\r\n\r\n        return new Promise((resolve, reject) => {\r\n\r\n            var req = new this._XMLHttpRequest();\r\n            req.open('GET', url);\r\n\r\n            var allowedContentTypes = this._contentTypes;\r\n            var jwtHandler = this._jwtHandler;\r\n\r\n            req.onload = function() {\r\n                Log.debug(\"JsonService.getJson: HTTP response received, status\", req.status);\r\n\r\n                if (req.status === 200) {\r\n\r\n                    var contentType = req.getResponseHeader(\"Content-Type\");\r\n                    if (contentType) {\r\n\r\n                        var found = allowedContentTypes.find(item=>{\r\n                            if (contentType.startsWith(item)) {\r\n                                return true;\r\n                            }\r\n                        });\r\n\r\n                        if (found == \"application/jwt\") {\r\n                            jwtHandler(req).then(resolve, reject);\r\n                            return;\r\n                        }\r\n\r\n                        if (found) {\r\n                            try {\r\n                                resolve(JSON.parse(req.responseText));\r\n                                return;\r\n                            }\r\n                            catch (e) {\r\n                                Log.error(\"JsonService.getJson: Error parsing JSON response\", e.message);\r\n                                reject(e);\r\n                                return;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    reject(Error(\"Invalid response Content-Type: \" + contentType + \", from URL: \" + url));\r\n                }\r\n                else {\r\n                    reject(Error(req.statusText + \" (\" + req.status + \")\"));\r\n                }\r\n            };\r\n\r\n            req.onerror = function() {\r\n                Log.error(\"JsonService.getJson: network error\");\r\n                reject(Error(\"Network Error\"));\r\n            };\r\n\r\n            if (token) {\r\n                Log.debug(\"JsonService.getJson: token passed, setting Authorization header\");\r\n                req.setRequestHeader(\"Authorization\", \"Bearer \" + token);\r\n            }\r\n\r\n            req.send();\r\n        });\r\n    }\r\n\r\n    postForm(url, payload) {\r\n        if (!url){\r\n            Log.error(\"JsonService.postForm: No url passed\");\r\n            throw new Error(\"url\");\r\n        }\r\n\r\n        Log.debug(\"JsonService.postForm, url: \", url);\r\n\r\n        return new Promise((resolve, reject) => {\r\n\r\n            var req = new this._XMLHttpRequest();\r\n            req.open('POST', url);\r\n\r\n            var allowedContentTypes = this._contentTypes;\r\n\r\n            req.onload = function() {\r\n                Log.debug(\"JsonService.postForm: HTTP response received, status\", req.status);\r\n\r\n                if (req.status === 200) {\r\n\r\n                    var contentType = req.getResponseHeader(\"Content-Type\");\r\n                    if (contentType) {\r\n\r\n                        var found = allowedContentTypes.find(item=>{\r\n                            if (contentType.startsWith(item)) {\r\n                                return true;\r\n                            }\r\n                        });\r\n\r\n                        if (found) {\r\n                            try {\r\n                                resolve(JSON.parse(req.responseText));\r\n                                return;\r\n                            }\r\n                            catch (e) {\r\n                                Log.error(\"JsonService.postForm: Error parsing JSON response\", e.message);\r\n                                reject(e);\r\n                                return;\r\n                            }\r\n                        }\r\n                    }\r\n\r\n                    reject(Error(\"Invalid response Content-Type: \" + contentType + \", from URL: \" + url));\r\n                    return;\r\n                }\r\n\r\n                if (req.status === 400) {\r\n\r\n                    var contentType = req.getResponseHeader(\"Content-Type\");\r\n                    if (contentType) {\r\n\r\n                        var found = allowedContentTypes.find(item=>{\r\n                            if (contentType.startsWith(item)) {\r\n                                return true;\r\n                            }\r\n                        });\r\n\r\n                        if (found) {\r\n                            try {\r\n                                var payload = JSON.parse(req.responseText);\r\n                                if (payload && payload.error) {\r\n                                    Log.error(\"JsonService.postForm: Error from server: \", payload.error);\r\n                                    reject(new Error(payload.error));\r\n                                    return;\r\n                                }\r\n                            }\r\n                            catch (e) {\r\n                                Log.error(\"JsonService.postForm: Error parsing JSON response\", e.message);\r\n                                reject(e);\r\n                                return;\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n\r\n                reject(Error(req.statusText + \" (\" + req.status + \")\"));\r\n            };\r\n\r\n            req.onerror = function() {\r\n                Log.error(\"JsonService.postForm: network error\");\r\n                reject(Error(\"Network Error\"));\r\n            };\r\n\r\n            let body = \"\";\r\n            for(let key in payload) {\r\n\r\n                let value = payload[key];\r\n\r\n                if (value) {\r\n\r\n                    if (body.length > 0) {\r\n                        body += \"&\";\r\n                    }\r\n\r\n                    body += encodeURIComponent(key);\r\n                    body += \"=\";\r\n                    body += encodeURIComponent(value);\r\n                }\r\n            }\r\n\r\n            req.setRequestHeader(\"Content-Type\", \"application/x-www-form-urlencoded\");\r\n            req.send(body);\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nlet nopLogger = {\r\n    debug(){},\r\n    info(){},\r\n    warn(){},\r\n    error(){}\r\n};\r\n\r\nconst NONE = 0;\r\nconst ERROR = 1;\r\nconst WARN = 2;\r\nconst INFO = 3;\r\nconst DEBUG = 4;\r\n\r\nlet logger;\r\nlet level;\r\n\r\nexport class Log {\r\n    static get NONE() {return NONE};\r\n    static get ERROR() {return ERROR};\r\n    static get WARN() {return WARN};\r\n    static get INFO() {return INFO};\r\n    static get DEBUG() {return DEBUG};\r\n    \r\n    static reset(){\r\n        level = INFO;\r\n        logger = nopLogger;\r\n    }\r\n    \r\n    static get level(){\r\n        return level;\r\n    }\r\n    static set level(value){\r\n        if (NONE <= value && value <= DEBUG){\r\n            level = value;\r\n        }\r\n        else {\r\n            throw new Error(\"Invalid log level\");\r\n        }\r\n    }\r\n    \r\n    static get logger(){\r\n        return logger;\r\n    }\r\n    static set logger(value){\r\n        if (!value.debug && value.info) {\r\n            // just to stay backwards compat. can remove in 2.0\r\n            value.debug = value.info;\r\n        }\r\n\r\n        if (value.debug && value.info && value.warn && value.error){\r\n            logger = value;\r\n        }\r\n        else {\r\n            throw new Error(\"Invalid logger\");\r\n        }\r\n    }\r\n    \r\n    static debug(...args){\r\n        if (level >= DEBUG){\r\n            logger.debug.apply(logger, Array.from(args));\r\n        }\r\n    }\r\n    static info(...args){\r\n        if (level >= INFO){\r\n            logger.info.apply(logger, Array.from(args));\r\n        }\r\n    }\r\n    static warn(...args){\r\n        if (level >= WARN){\r\n            logger.warn.apply(logger, Array.from(args));\r\n        }\r\n    }\r\n    static error(...args){\r\n        if (level >= ERROR){\r\n            logger.error.apply(logger, Array.from(args));\r\n        }\r\n    }\r\n}\r\n\r\nLog.reset();\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { JsonService } from './JsonService.js';\r\n\r\nconst OidcMetadataUrlPath = '.well-known/openid-configuration';\r\n\r\nexport class MetadataService {\r\n    constructor(settings, JsonServiceCtor = JsonService) {\r\n        if (!settings) {\r\n            Log.error(\"MetadataService: No settings passed to MetadataService\");\r\n            throw new Error(\"settings\");\r\n        }\r\n\r\n        this._settings = settings;\r\n        this._jsonService = new JsonServiceCtor(['application/jwk-set+json']);\r\n    }\r\n\r\n    get metadataUrl() {\r\n        if (!this._metadataUrl) {\r\n            if (this._settings.metadataUrl) {\r\n                this._metadataUrl = this._settings.metadataUrl;\r\n            }\r\n            else {\r\n                this._metadataUrl = this._settings.authority;\r\n\r\n                if (this._metadataUrl && this._metadataUrl.indexOf(OidcMetadataUrlPath) < 0) {\r\n                    if (this._metadataUrl[this._metadataUrl.length - 1] !== '/') {\r\n                        this._metadataUrl += '/';\r\n                    }\r\n                    this._metadataUrl += OidcMetadataUrlPath;\r\n                }\r\n            }\r\n        }\r\n\r\n        return this._metadataUrl;\r\n    }\r\n\r\n    getMetadata() {\r\n        if (this._settings.metadata) {\r\n            Log.debug(\"MetadataService.getMetadata: Returning metadata from settings\");\r\n            return Promise.resolve(this._settings.metadata);\r\n        }\r\n\r\n        if (!this.metadataUrl) {\r\n            Log.error(\"MetadataService.getMetadata: No authority or metadataUrl configured on settings\");\r\n            return Promise.reject(new Error(\"No authority or metadataUrl configured on settings\"));\r\n        }\r\n\r\n        Log.debug(\"MetadataService.getMetadata: getting metadata from\", this.metadataUrl);\r\n\r\n        return this._jsonService.getJson(this.metadataUrl)\r\n            .then(metadata => {\r\n                Log.debug(\"MetadataService.getMetadata: json received\");\r\n                this._settings.metadata = metadata;\r\n                return metadata;\r\n            });\r\n    }\r\n\r\n    getIssuer() {\r\n        return this._getMetadataProperty(\"issuer\");\r\n    }\r\n\r\n    getAuthorizationEndpoint() {\r\n        return this._getMetadataProperty(\"authorization_endpoint\");\r\n    }\r\n\r\n    getUserInfoEndpoint() {\r\n        return this._getMetadataProperty(\"userinfo_endpoint\");\r\n    }\r\n\r\n    getTokenEndpoint(optional=true) {\r\n        return this._getMetadataProperty(\"token_endpoint\", optional);\r\n    }\r\n\r\n    getCheckSessionIframe() {\r\n        return this._getMetadataProperty(\"check_session_iframe\", true);\r\n    }\r\n\r\n    getEndSessionEndpoint() {\r\n        return this._getMetadataProperty(\"end_session_endpoint\", true);\r\n    }\r\n\r\n    getRevocationEndpoint() {\r\n        return this._getMetadataProperty(\"revocation_endpoint\", true);\r\n    }\r\n\r\n    getKeysEndpoint() {\r\n        return this._getMetadataProperty(\"jwks_uri\", true);\r\n    }\r\n\r\n    _getMetadataProperty(name, optional=false) {\r\n        Log.debug(\"MetadataService.getMetadataProperty for: \" + name);\r\n\r\n        return this.getMetadata().then(metadata => {\r\n            Log.debug(\"MetadataService.getMetadataProperty: metadata recieved\");\r\n\r\n            if (metadata[name] === undefined) {\r\n\r\n                if (optional === true) {\r\n                    Log.warn(\"MetadataService.getMetadataProperty: Metadata does not contain optional property \" + name);\r\n                    return undefined;\r\n                }\r\n                else {\r\n                    Log.error(\"MetadataService.getMetadataProperty: Metadata does not contain property \" + name);\r\n                    throw new Error(\"Metadata does not contain property \" + name);\r\n                }\r\n            }\r\n\r\n            return metadata[name];\r\n        });\r\n    }\r\n\r\n    getSigningKeys() {\r\n        if (this._settings.signingKeys) {\r\n            Log.debug(\"MetadataService.getSigningKeys: Returning signingKeys from settings\");\r\n            return Promise.resolve(this._settings.signingKeys);\r\n        }\r\n\r\n        return this._getMetadataProperty(\"jwks_uri\").then(jwks_uri => {\r\n            Log.debug(\"MetadataService.getSigningKeys: jwks_uri received\", jwks_uri);\r\n\r\n            return this._jsonService.getJson(jwks_uri).then(keySet => {\r\n                Log.debug(\"MetadataService.getSigningKeys: key set received\", keySet);\r\n\r\n                if (!keySet.keys) {\r\n                    Log.error(\"MetadataService.getSigningKeys: Missing keys on keyset\");\r\n                    throw new Error(\"Missing keys on keyset\");\r\n                }\r\n\r\n                this._settings.signingKeys = keySet.keys;\r\n                return this._settings.signingKeys;\r\n            });\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { OidcClientSettings } from './OidcClientSettings.js';\r\nimport { ErrorResponse } from './ErrorResponse.js';\r\nimport { SigninRequest } from './SigninRequest.js';\r\nimport { SigninResponse } from './SigninResponse.js';\r\nimport { SignoutRequest } from './SignoutRequest.js';\r\nimport { SignoutResponse } from './SignoutResponse.js';\r\nimport { SigninState } from './SigninState.js';\r\nimport { State } from './State.js';\r\n\r\nexport class OidcClient {\r\n    constructor(settings = {}) {\r\n        if (settings instanceof OidcClientSettings) {\r\n            this._settings = settings;\r\n        }\r\n        else {\r\n            this._settings = new OidcClientSettings(settings);\r\n        }\r\n    }\r\n\r\n    get _stateStore() {\r\n        return this.settings.stateStore;\r\n    }\r\n    get _validator() {\r\n        return this.settings.validator;\r\n    }\r\n    get _metadataService() {\r\n        return this.settings.metadataService;\r\n    }\r\n\r\n    get settings() {\r\n        return this._settings;\r\n    }\r\n    get metadataService() {\r\n        return this._metadataService;\r\n    }\r\n\r\n    createSigninRequest({\r\n        response_type, scope, redirect_uri,\r\n        // data was meant to be the place a caller could indicate the data to\r\n        // have round tripped, but people were getting confused, so i added state (since that matches the spec)\r\n        // and so now if data is not passed, but state is then state will be used\r\n        data, state, prompt, display, max_age, ui_locales, id_token_hint, login_hint, acr_values,\r\n        resource, request, request_uri, response_mode, extraQueryParams, extraTokenParams, request_type, skipUserInfo } = {},\r\n        stateStore\r\n    ) {\r\n        Log.debug(\"OidcClient.createSigninRequest\");\r\n\r\n        let client_id = this._settings.client_id;\r\n        response_type = response_type || this._settings.response_type;\r\n        scope = scope || this._settings.scope;\r\n        redirect_uri = redirect_uri || this._settings.redirect_uri;\r\n\r\n        // id_token_hint, login_hint aren't allowed on _settings\r\n        prompt = prompt || this._settings.prompt;\r\n        display = display || this._settings.display;\r\n        max_age = max_age || this._settings.max_age;\r\n        ui_locales = ui_locales || this._settings.ui_locales;\r\n        acr_values = acr_values || this._settings.acr_values;\r\n        resource = resource || this._settings.resource;\r\n        response_mode = response_mode || this._settings.response_mode;\r\n        extraQueryParams = extraQueryParams || this._settings.extraQueryParams;\r\n        extraTokenParams = extraTokenParams || this._settings.extraTokenParams;\r\n\r\n        let authority = this._settings.authority;\r\n\r\n        if (SigninRequest.isCode(response_type) && response_type !== \"code\") {\r\n            return Promise.reject(new Error(\"OpenID Connect hybrid flow is not supported\"));\r\n        }\r\n\r\n        return this._metadataService.getAuthorizationEndpoint().then(url => {\r\n            Log.debug(\"OidcClient.createSigninRequest: Received authorization endpoint\", url);\r\n\r\n            let signinRequest = new SigninRequest({\r\n                url,\r\n                client_id,\r\n                redirect_uri,\r\n                response_type,\r\n                scope,\r\n                data: data || state,\r\n                authority,\r\n                prompt, display, max_age, ui_locales, id_token_hint, login_hint, acr_values,\r\n                resource, request, request_uri, extraQueryParams, extraTokenParams, request_type, response_mode,\r\n                client_secret: this._settings.client_secret,\r\n                skipUserInfo\r\n            });\r\n\r\n            var signinState = signinRequest.state;\r\n            stateStore = stateStore || this._stateStore;\r\n\r\n            return stateStore.set(signinState.id, signinState.toStorageString()).then(() => {\r\n                return signinRequest;\r\n            });\r\n        });\r\n    }\r\n\r\n    readSigninResponseState(url, stateStore, removeState = false) {\r\n        Log.debug(\"OidcClient.readSigninResponseState\");\r\n\r\n        let useQuery = this._settings.response_mode === \"query\" || \r\n            (!this._settings.response_mode && SigninRequest.isCode(this._settings.response_type));\r\n        let delimiter = useQuery ? \"?\" : \"#\";\r\n\r\n        var response = new SigninResponse(url, delimiter);\r\n\r\n        if (!response.state) {\r\n            Log.error(\"OidcClient.readSigninResponseState: No state in response\");\r\n            return Promise.reject(new Error(\"No state in response\"));\r\n        }\r\n\r\n        stateStore = stateStore || this._stateStore;\r\n\r\n        var stateApi = removeState ? stateStore.remove.bind(stateStore) : stateStore.get.bind(stateStore);\r\n\r\n        return stateApi(response.state).then(storedStateString => {\r\n            if (!storedStateString) {\r\n                Log.error(\"OidcClient.readSigninResponseState: No matching state found in storage\");\r\n                throw new Error(\"No matching state found in storage\");\r\n            }\r\n\r\n            let state = SigninState.fromStorageString(storedStateString);\r\n            return {state, response};\r\n        });\r\n    }\r\n\r\n    processSigninResponse(url, stateStore) {\r\n        Log.debug(\"OidcClient.processSigninResponse\");\r\n\r\n        return this.readSigninResponseState(url, stateStore, true).then(({state, response}) => {\r\n            Log.debug(\"OidcClient.processSigninResponse: Received state from storage; validating response\");\r\n            return this._validator.validateSigninResponse(state, response);\r\n        });\r\n    }\r\n\r\n    createSignoutRequest({id_token_hint, data, state, post_logout_redirect_uri, extraQueryParams, request_type } = {},\r\n        stateStore\r\n    ) {\r\n        Log.debug(\"OidcClient.createSignoutRequest\");\r\n\r\n        post_logout_redirect_uri = post_logout_redirect_uri || this._settings.post_logout_redirect_uri;\r\n        extraQueryParams = extraQueryParams || this._settings.extraQueryParams;\r\n\r\n        return this._metadataService.getEndSessionEndpoint().then(url => {\r\n            if (!url) {\r\n                Log.error(\"OidcClient.createSignoutRequest: No end session endpoint url returned\");\r\n                throw new Error(\"no end session endpoint\");\r\n            }\r\n\r\n            Log.debug(\"OidcClient.createSignoutRequest: Received end session endpoint\", url);\r\n\r\n            let request = new SignoutRequest({\r\n                url,\r\n                id_token_hint,\r\n                post_logout_redirect_uri,\r\n                data: data || state,\r\n                extraQueryParams,\r\n                request_type\r\n            });\r\n\r\n            var signoutState = request.state;\r\n            if (signoutState) {\r\n                Log.debug(\"OidcClient.createSignoutRequest: Signout request has state to persist\");\r\n\r\n                stateStore = stateStore || this._stateStore;\r\n                stateStore.set(signoutState.id, signoutState.toStorageString());\r\n            }\r\n\r\n            return request;\r\n        });\r\n    }\r\n\r\n    readSignoutResponseState(url, stateStore, removeState = false) {\r\n        Log.debug(\"OidcClient.readSignoutResponseState\");\r\n\r\n        var response = new SignoutResponse(url);\r\n        if (!response.state) {\r\n            Log.debug(\"OidcClient.readSignoutResponseState: No state in response\");\r\n\r\n            if (response.error) {\r\n                Log.warn(\"OidcClient.readSignoutResponseState: Response was error: \", response.error);\r\n                return Promise.reject(new ErrorResponse(response));\r\n            }\r\n\r\n            return Promise.resolve({undefined, response});\r\n        }\r\n\r\n        var stateKey = response.state;\r\n\r\n        stateStore = stateStore || this._stateStore;\r\n\r\n        var stateApi = removeState ? stateStore.remove.bind(stateStore) : stateStore.get.bind(stateStore);\r\n        return stateApi(stateKey).then(storedStateString => {\r\n            if (!storedStateString) {\r\n                Log.error(\"OidcClient.readSignoutResponseState: No matching state found in storage\");\r\n                throw new Error(\"No matching state found in storage\");\r\n            }\r\n\r\n            let state = State.fromStorageString(storedStateString);\r\n\r\n            return {state, response};\r\n        });\r\n    }\r\n\r\n    processSignoutResponse(url, stateStore) {\r\n        Log.debug(\"OidcClient.processSignoutResponse\");\r\n\r\n        return this.readSignoutResponseState(url, stateStore, true).then(({state, response}) => {\r\n            if (state) {\r\n                Log.debug(\"OidcClient.processSignoutResponse: Received state from storage; validating response\");\r\n                return this._validator.validateSignoutResponse(state, response);\r\n            }\r\n            else {\r\n                Log.debug(\"OidcClient.processSignoutResponse: No state from storage; skipping validating response\");\r\n                return response;\r\n            }\r\n        });\r\n    }\r\n\r\n    clearStaleState(stateStore) {\r\n        Log.debug(\"OidcClient.clearStaleState\");\r\n\r\n        stateStore = stateStore || this._stateStore;\r\n\r\n        return State.clearStaleState(stateStore, this.settings.staleStateAge);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { WebStorageStateStore } from './WebStorageStateStore.js';\r\nimport { ResponseValidator } from './ResponseValidator.js';\r\nimport { MetadataService } from './MetadataService.js';\r\n\r\nconst OidcMetadataUrlPath = '.well-known/openid-configuration';\r\n\r\nconst DefaultResponseType = \"id_token\";\r\nconst DefaultScope = \"openid\";\r\nconst DefaultStaleStateAge = 60 * 15; // seconds\r\nconst DefaultClockSkewInSeconds = 60 * 5;\r\n\r\nexport class OidcClientSettings {\r\n    constructor({\r\n        // metadata related\r\n        authority, metadataUrl, metadata, signingKeys,\r\n        // client related\r\n        client_id, client_secret, response_type = DefaultResponseType, scope = DefaultScope,\r\n        redirect_uri, post_logout_redirect_uri,\r\n        // optional protocol\r\n        prompt, display, max_age, ui_locales, acr_values, resource, response_mode,\r\n        // behavior flags\r\n        filterProtocolClaims = true, loadUserInfo = true,\r\n        staleStateAge = DefaultStaleStateAge, clockSkew = DefaultClockSkewInSeconds,\r\n        userInfoJwtIssuer = 'OP',\r\n        // other behavior\r\n        stateStore = new WebStorageStateStore(),\r\n        ResponseValidatorCtor = ResponseValidator,\r\n        MetadataServiceCtor = MetadataService,\r\n        // extra query params\r\n        extraQueryParams = {},\r\n        extraTokenParams = {}\r\n    } = {}) {\r\n\r\n        this._authority = authority;\r\n        this._metadataUrl = metadataUrl;\r\n        this._metadata = metadata;\r\n        this._signingKeys = signingKeys;\r\n\r\n        this._client_id = client_id;\r\n        this._client_secret = client_secret;\r\n        this._response_type = response_type;\r\n        this._scope = scope;\r\n        this._redirect_uri = redirect_uri;\r\n        this._post_logout_redirect_uri = post_logout_redirect_uri;\r\n\r\n        this._prompt = prompt;\r\n        this._display = display;\r\n        this._max_age = max_age;\r\n        this._ui_locales = ui_locales;\r\n        this._acr_values = acr_values;\r\n        this._resource = resource;\r\n        this._response_mode = response_mode;\r\n\r\n        this._filterProtocolClaims = !!filterProtocolClaims;\r\n        this._loadUserInfo = !!loadUserInfo;\r\n        this._staleStateAge = staleStateAge;\r\n        this._clockSkew = clockSkew;\r\n        this._userInfoJwtIssuer = userInfoJwtIssuer;\r\n\r\n        this._stateStore = stateStore;\r\n        this._validator = new ResponseValidatorCtor(this);\r\n        this._metadataService = new MetadataServiceCtor(this);\r\n\r\n        this._extraQueryParams = typeof extraQueryParams === 'object' ? extraQueryParams : {};\r\n        this._extraTokenParams = typeof extraTokenParams === 'object' ? extraTokenParams : {};\r\n    }\r\n\r\n    // client config\r\n    get client_id() {\r\n        return this._client_id;\r\n    }\r\n    set client_id(value) {\r\n        if (!this._client_id) {\r\n            // one-time set only\r\n            this._client_id = value;\r\n        }\r\n        else {\r\n            Log.error(\"OidcClientSettings.set_client_id: client_id has already been assigned.\")\r\n            throw new Error(\"client_id has already been assigned.\")\r\n        }\r\n    }\r\n    get client_secret() {\r\n        return this._client_secret;\r\n    }\r\n    get response_type() {\r\n        return this._response_type;\r\n    }\r\n    get scope() {\r\n        return this._scope;\r\n    }\r\n    get redirect_uri() {\r\n        return this._redirect_uri;\r\n    }\r\n    get post_logout_redirect_uri() {\r\n        return this._post_logout_redirect_uri;\r\n    }\r\n\r\n\r\n    // optional protocol params\r\n    get prompt() {\r\n        return this._prompt;\r\n    }\r\n    get display() {\r\n        return this._display;\r\n    }\r\n    get max_age() {\r\n        return this._max_age;\r\n    }\r\n    get ui_locales() {\r\n        return this._ui_locales;\r\n    }\r\n    get acr_values() {\r\n        return this._acr_values;\r\n    }\r\n    get resource() {\r\n        return this._resource;\r\n    }\r\n    get response_mode() {\r\n        return this._response_mode;\r\n    }\r\n\r\n\r\n    // metadata\r\n    get authority() {\r\n        return this._authority;\r\n    }\r\n    set authority(value) {\r\n        if (!this._authority) {\r\n            // one-time set only\r\n            this._authority = value;\r\n        }\r\n        else {\r\n            Log.error(\"OidcClientSettings.set_authority: authority has already been assigned.\")\r\n            throw new Error(\"authority has already been assigned.\")\r\n        }\r\n    }\r\n    get metadataUrl() {\r\n        if (!this._metadataUrl) {\r\n            this._metadataUrl = this.authority;\r\n\r\n            if (this._metadataUrl && this._metadataUrl.indexOf(OidcMetadataUrlPath) < 0) {\r\n                if (this._metadataUrl[this._metadataUrl.length - 1] !== '/') {\r\n                    this._metadataUrl += '/';\r\n                }\r\n                this._metadataUrl += OidcMetadataUrlPath;\r\n            }\r\n        }\r\n\r\n        return this._metadataUrl;\r\n    }\r\n\r\n    // settable/cachable metadata values\r\n    get metadata() {\r\n        return this._metadata;\r\n    }\r\n    set metadata(value) {\r\n        this._metadata = value;\r\n    }\r\n\r\n    get signingKeys() {\r\n        return this._signingKeys;\r\n    }\r\n    set signingKeys(value) {\r\n        this._signingKeys = value;\r\n    }\r\n\r\n    // behavior flags\r\n    get filterProtocolClaims() {\r\n        return this._filterProtocolClaims;\r\n    }\r\n    get loadUserInfo() {\r\n        return this._loadUserInfo;\r\n    }\r\n    get staleStateAge() {\r\n        return this._staleStateAge;\r\n    }\r\n    get clockSkew() {\r\n        return this._clockSkew;\r\n    }\r\n    get userInfoJwtIssuer() {\r\n        return this._userInfoJwtIssuer;\r\n    }\r\n\r\n    get stateStore() {\r\n        return this._stateStore;\r\n    }\r\n    get validator() {\r\n        return this._validator;\r\n    }\r\n    get metadataService() {\r\n        return this._metadataService;\r\n    }\r\n\r\n    // extra query params\r\n    get extraQueryParams() {\r\n        return this._extraQueryParams;\r\n    }\r\n    set extraQueryParams(value) {\r\n        if (typeof value === 'object'){\r\n            this._extraQueryParams = value;\r\n        } else {\r\n            this._extraQueryParams = {};\r\n        }\r\n    }\r\n\r\n    // extra token params\r\n    get extraTokenParams() {\r\n        return this._extraTokenParams;\r\n    }\r\n    set extraTokenParams(value) {\r\n        if (typeof value === 'object'){\r\n            this._extraTokenParams = value;\r\n        } else {\r\n            this._extraTokenParams = {};\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { PopupWindow } from './PopupWindow.js';\r\n\r\nexport class PopupNavigator {\r\n\r\n    prepare(params) {\r\n        let popup = new PopupWindow(params);\r\n        return Promise.resolve(popup);\r\n    }\r\n\r\n    callback(url, keepOpen, delimiter) {\r\n        Log.debug(\"PopupNavigator.callback\");\r\n\r\n        try {\r\n            PopupWindow.notifyOpener(url, keepOpen, delimiter);\r\n            return Promise.resolve();\r\n        }\r\n        catch (e) {\r\n            return Promise.reject(e);\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { UrlUtility } from './UrlUtility.js';\r\n\r\nconst CheckForPopupClosedInterval = 500;\r\nconst DefaultPopupFeatures = 'location=no,toolbar=no,width=500,height=500,left=100,top=100;';\r\n//const DefaultPopupFeatures = 'location=no,toolbar=no,width=500,height=500,left=100,top=100;resizable=yes';\r\n\r\nconst DefaultPopupTarget = \"_blank\";\r\n\r\nexport class PopupWindow {\r\n\r\n    constructor(params) {\r\n        this._promise = new Promise((resolve, reject) => {\r\n            this._resolve = resolve;\r\n            this._reject = reject;\r\n        });\r\n\r\n        let target = params.popupWindowTarget || DefaultPopupTarget;\r\n        let features = params.popupWindowFeatures || DefaultPopupFeatures;\r\n\r\n        this._popup = window.open('', target, features);\r\n        if (this._popup) {\r\n            Log.debug(\"PopupWindow.ctor: popup successfully created\");\r\n            this._checkForPopupClosedTimer = window.setInterval(this._checkForPopupClosed.bind(this), CheckForPopupClosedInterval);\r\n        }\r\n    }\r\n\r\n    get promise() {\r\n        return this._promise;\r\n    }\r\n\r\n    navigate(params) {\r\n        if (!this._popup) {\r\n            this._error(\"PopupWindow.navigate: Error opening popup window\");\r\n        }\r\n        else if (!params || !params.url) {\r\n            this._error(\"PopupWindow.navigate: no url provided\");\r\n            this._error(\"No url provided\");\r\n        }\r\n        else {\r\n            Log.debug(\"PopupWindow.navigate: Setting URL in popup\");\r\n\r\n            this._id = params.id;\r\n            if (this._id) {\r\n                window[\"popupCallback_\" + params.id] = this._callback.bind(this);\r\n            }\r\n\r\n            this._popup.focus();\r\n            this._popup.window.location = params.url;\r\n        }\r\n\r\n        return this.promise;\r\n    }\r\n\r\n    _success(data) {\r\n        Log.debug(\"PopupWindow.callback: Successful response from popup window\");\r\n\r\n        this._cleanup();\r\n        this._resolve(data);\r\n    }\r\n    _error(message) {\r\n        Log.error(\"PopupWindow.error: \", message);\r\n        \r\n        this._cleanup();\r\n        this._reject(new Error(message));\r\n    }\r\n\r\n    close() {\r\n        this._cleanup(false);\r\n    }\r\n\r\n    _cleanup(keepOpen) {\r\n        Log.debug(\"PopupWindow.cleanup\");\r\n\r\n        window.clearInterval(this._checkForPopupClosedTimer);\r\n        this._checkForPopupClosedTimer = null;\r\n\r\n        delete window[\"popupCallback_\" + this._id];\r\n\r\n        if (this._popup && !keepOpen) {\r\n            this._popup.close();\r\n        }\r\n        this._popup = null;\r\n    }\r\n\r\n    _checkForPopupClosed() {\r\n        if (!this._popup || this._popup.closed) {\r\n            this._error(\"Popup window closed\");\r\n        }\r\n    }\r\n\r\n    _callback(url, keepOpen) {\r\n        this._cleanup(keepOpen);\r\n\r\n        if (url) {\r\n            Log.debug(\"PopupWindow.callback success\");\r\n            this._success({ url: url });\r\n        }\r\n        else {\r\n            Log.debug(\"PopupWindow.callback: Invalid response from popup\");\r\n            this._error(\"Invalid response from popup\");\r\n        }\r\n    }\r\n\r\n    static notifyOpener(url, keepOpen, delimiter) {\r\n        if (window.opener) {\r\n            url = url || window.location.href;\r\n            if (url) {\r\n                var data = UrlUtility.parseUrlFragment(url, delimiter);\r\n\r\n                if (data.state) {\r\n                    var name = \"popupCallback_\" + data.state;\r\n                    var callback = window.opener[name];\r\n                    if (callback) {\r\n                        Log.debug(\"PopupWindow.notifyOpener: passing url message to opener\");\r\n                        callback(url, keepOpen);\r\n                    }\r\n                    else {\r\n                        Log.warn(\"PopupWindow.notifyOpener: no matching callback found on opener\");\r\n                    }\r\n                }\r\n                else {\r\n                    Log.warn(\"PopupWindow.notifyOpener: no state found in response url\");\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            Log.warn(\"PopupWindow.notifyOpener: no window.opener. Can't complete notification.\");\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class RedirectNavigator {\r\n\r\n    prepare() {\r\n        return Promise.resolve(this);\r\n    }\r\n\r\n    navigate(params) {\r\n        if (!params || !params.url) {\r\n            Log.error(\"RedirectNavigator.navigate: No url provided\");\r\n            return Promise.reject(new Error(\"No url provided\"));\r\n        }\r\n\r\n        if (params.useReplaceToNavigate) {\r\n            window.location.replace(params.url);\r\n        }\r\n        else {\r\n            window.location = params.url;\r\n        }\r\n\r\n        return Promise.resolve();\r\n    }\r\n\r\n    get url() {\r\n        return window.location.href;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { MetadataService } from './MetadataService.js';\r\nimport { UserInfoService } from './UserInfoService.js';\r\nimport { TokenClient } from './TokenClient.js';\r\nimport { ErrorResponse } from './ErrorResponse.js';\r\nimport { JoseUtil } from './JoseUtil.js';\r\n\r\nconst ProtocolClaims = [\"nonce\", \"at_hash\", \"iat\", \"nbf\", \"exp\", \"aud\", \"iss\", \"c_hash\"];\r\n\r\nexport class ResponseValidator {\r\n\r\n    constructor(settings, \r\n        MetadataServiceCtor = MetadataService,\r\n        UserInfoServiceCtor = UserInfoService, \r\n        joseUtil = JoseUtil,\r\n        TokenClientCtor = TokenClient) {\r\n        if (!settings) {\r\n            Log.error(\"ResponseValidator.ctor: No settings passed to ResponseValidator\");\r\n            throw new Error(\"settings\");\r\n        }\r\n\r\n        this._settings = settings;\r\n        this._metadataService = new MetadataServiceCtor(this._settings);\r\n        this._userInfoService = new UserInfoServiceCtor(this._settings);\r\n        this._joseUtil = joseUtil;\r\n        this._tokenClient = new TokenClientCtor(this._settings);\r\n    }\r\n\r\n    validateSigninResponse(state, response) {\r\n        Log.debug(\"ResponseValidator.validateSigninResponse\");\r\n\r\n        return this._processSigninParams(state, response).then(response => {\r\n            Log.debug(\"ResponseValidator.validateSigninResponse: state processed\");\r\n            return this._validateTokens(state, response).then(response => {\r\n                Log.debug(\"ResponseValidator.validateSigninResponse: tokens validated\");\r\n                return this._processClaims(state, response).then(response => {\r\n                    Log.debug(\"ResponseValidator.validateSigninResponse: claims processed\");\r\n                    return response;\r\n                });\r\n            });\r\n        });\r\n    }\r\n\r\n    validateSignoutResponse(state, response) {\r\n        if (state.id !== response.state) {\r\n            Log.error(\"ResponseValidator.validateSignoutResponse: State does not match\");\r\n            return Promise.reject(new Error(\"State does not match\"));\r\n        }\r\n\r\n        // now that we know the state matches, take the stored data\r\n        // and set it into the response so callers can get their state\r\n        // this is important for both success & error outcomes\r\n        Log.debug(\"ResponseValidator.validateSignoutResponse: state validated\");\r\n        response.state = state.data;\r\n\r\n        if (response.error) {\r\n            Log.warn(\"ResponseValidator.validateSignoutResponse: Response was error\", response.error);\r\n            return Promise.reject(new ErrorResponse(response));\r\n        }\r\n\r\n        return Promise.resolve(response);\r\n    }\r\n\r\n    _processSigninParams(state, response) {\r\n        if (state.id !== response.state) {\r\n            Log.error(\"ResponseValidator._processSigninParams: State does not match\");\r\n            return Promise.reject(new Error(\"State does not match\"));\r\n        }\r\n\r\n        if (!state.client_id) {\r\n            Log.error(\"ResponseValidator._processSigninParams: No client_id on state\");\r\n            return Promise.reject(new Error(\"No client_id on state\"));\r\n        }\r\n\r\n        if (!state.authority) {\r\n            Log.error(\"ResponseValidator._processSigninParams: No authority on state\");\r\n            return Promise.reject(new Error(\"No authority on state\"));\r\n        }\r\n\r\n        // this allows the authority to be loaded from the signin state\r\n        if (!this._settings.authority) {\r\n            this._settings.authority = state.authority;\r\n        }\r\n        // ensure we're using the correct authority if the authority is not loaded from signin state\r\n        else if (this._settings.authority && this._settings.authority !== state.authority) {\r\n            Log.error(\"ResponseValidator._processSigninParams: authority mismatch on settings vs. signin state\");\r\n            return Promise.reject(new Error(\"authority mismatch on settings vs. signin state\"));\r\n        }\r\n        // this allows the client_id to be loaded from the signin state\r\n        if (!this._settings.client_id) {\r\n            this._settings.client_id = state.client_id;\r\n        }\r\n        // ensure we're using the correct client_id if the client_id is not loaded from signin state\r\n        else if (this._settings.client_id && this._settings.client_id !== state.client_id) {\r\n            Log.error(\"ResponseValidator._processSigninParams: client_id mismatch on settings vs. signin state\");\r\n            return Promise.reject(new Error(\"client_id mismatch on settings vs. signin state\"));\r\n        }\r\n\r\n        // now that we know the state matches, take the stored data\r\n        // and set it into the response so callers can get their state\r\n        // this is important for both success & error outcomes\r\n        Log.debug(\"ResponseValidator._processSigninParams: state validated\");\r\n        response.state = state.data;\r\n\r\n        if (response.error) {\r\n            Log.warn(\"ResponseValidator._processSigninParams: Response was error\", response.error);\r\n            return Promise.reject(new ErrorResponse(response));\r\n        }\r\n\r\n        if (state.nonce && !response.id_token) {\r\n            Log.error(\"ResponseValidator._processSigninParams: Expecting id_token in response\");\r\n            return Promise.reject(new Error(\"No id_token in response\"));\r\n        }\r\n\r\n        if (!state.nonce && response.id_token) {\r\n            Log.error(\"ResponseValidator._processSigninParams: Not expecting id_token in response\");\r\n            return Promise.reject(new Error(\"Unexpected id_token in response\"));\r\n        }\r\n\r\n        if (state.code_verifier && !response.code) {\r\n            Log.error(\"ResponseValidator._processSigninParams: Expecting code in response\");\r\n            return Promise.reject(new Error(\"No code in response\"));\r\n        }\r\n\r\n        if (!state.code_verifier && response.code) {\r\n            Log.error(\"ResponseValidator._processSigninParams: Not expecting code in response\");\r\n            return Promise.reject(new Error(\"Unexpected code in response\"));\r\n        }\r\n\r\n        if (!response.scope) {\r\n            // if there's no scope on the response, then assume all scopes granted (per-spec) and copy over scopes from original request\r\n            response.scope = state.scope;\r\n        }\r\n\r\n        return Promise.resolve(response);\r\n    }\r\n\r\n    _processClaims(state, response) {\r\n        if (response.isOpenIdConnect) {\r\n            Log.debug(\"ResponseValidator._processClaims: response is OIDC, processing claims\");\r\n\r\n            response.profile = this._filterProtocolClaims(response.profile);\r\n\r\n            if (state.skipUserInfo !== true && this._settings.loadUserInfo && response.access_token) {\r\n                Log.debug(\"ResponseValidator._processClaims: loading user info\");\r\n\r\n                return this._userInfoService.getClaims(response.access_token).then(claims => {\r\n                    Log.debug(\"ResponseValidator._processClaims: user info claims received from user info endpoint\");\r\n\r\n                    if (claims.sub !== response.profile.sub) {\r\n                        Log.error(\"ResponseValidator._processClaims: sub from user info endpoint does not match sub in access_token\");\r\n                        return Promise.reject(new Error(\"sub from user info endpoint does not match sub in access_token\"));\r\n                    }\r\n\r\n                    response.profile = this._mergeClaims(response.profile, claims);\r\n                    Log.debug(\"ResponseValidator._processClaims: user info claims received, updated profile:\", response.profile);\r\n\r\n                    return response;\r\n                });\r\n            }\r\n            else {\r\n                Log.debug(\"ResponseValidator._processClaims: not loading user info\");\r\n            }\r\n        }\r\n        else {\r\n            Log.debug(\"ResponseValidator._processClaims: response is not OIDC, not processing claims\");\r\n        }\r\n\r\n        return Promise.resolve(response);\r\n    }\r\n\r\n    _mergeClaims(claims1, claims2) {\r\n        var result = Object.assign({}, claims1);\r\n\r\n        for (let name in claims2) {\r\n            var values = claims2[name];\r\n            if (!Array.isArray(values)) {\r\n                values = [values];\r\n            }\r\n\r\n            for (let i = 0; i < values.length; i++) {\r\n                let value = values[i];\r\n                if (!result[name]) {\r\n                    result[name] = value;\r\n                }\r\n                else if (Array.isArray(result[name])) {\r\n                    if (result[name].indexOf(value) < 0) {\r\n                        result[name].push(value);\r\n                    }\r\n                }\r\n                else if (result[name] !== value) {\r\n                    if (typeof value === 'object') {\r\n                        result[name] = this._mergeClaims(result[name], value);\r\n                    } \r\n                    else {\r\n                        result[name] = [result[name], value];\r\n                    }\r\n                }\r\n            }\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    _filterProtocolClaims(claims) {\r\n        Log.debug(\"ResponseValidator._filterProtocolClaims, incoming claims:\", claims);\r\n\r\n        var result = Object.assign({}, claims);\r\n\r\n        if (this._settings._filterProtocolClaims) {\r\n            ProtocolClaims.forEach(type => {\r\n                delete result[type];\r\n            });\r\n\r\n            Log.debug(\"ResponseValidator._filterProtocolClaims: protocol claims filtered\", result);\r\n        }\r\n        else {\r\n            Log.debug(\"ResponseValidator._filterProtocolClaims: protocol claims not filtered\")\r\n        }\r\n\r\n        return result;\r\n    }\r\n\r\n    _validateTokens(state, response) {\r\n        if (response.code) {\r\n            Log.debug(\"ResponseValidator._validateTokens: Validating code\");\r\n            return this._processCode(state, response);\r\n        }\r\n\r\n        if (response.id_token) {\r\n            if (response.access_token) {\r\n                Log.debug(\"ResponseValidator._validateTokens: Validating id_token and access_token\");\r\n                return this._validateIdTokenAndAccessToken(state, response);\r\n            }\r\n\r\n            Log.debug(\"ResponseValidator._validateTokens: Validating id_token\");\r\n            return this._validateIdToken(state, response);\r\n        }\r\n\r\n        Log.debug(\"ResponseValidator._validateTokens: No code to process or id_token to validate\");\r\n        return Promise.resolve(response);\r\n    }\r\n\r\n    _processCode(state, response) {\r\n        var request = {\r\n            client_id: state.client_id,\r\n            client_secret: state.client_secret,\r\n            code : response.code,\r\n            redirect_uri: state.redirect_uri,\r\n            code_verifier: state.code_verifier\r\n        };\r\n\r\n        if (state.extraTokenParams && typeof(state.extraTokenParams) === 'object') {\r\n            Object.assign(request, state.extraTokenParams);\r\n        }\r\n        \r\n        return this._tokenClient.exchangeCode(request).then(tokenResponse => {\r\n            \r\n            for(var key in tokenResponse) {\r\n                response[key] = tokenResponse[key];\r\n            }\r\n\r\n            if (response.id_token) {\r\n                Log.debug(\"ResponseValidator._processCode: token response successful, processing id_token\");\r\n                return this._validateIdTokenAttributes(state, response);\r\n            }\r\n            else {\r\n                Log.debug(\"ResponseValidator._processCode: token response successful, returning response\");\r\n            }\r\n            \r\n            return response;\r\n        });\r\n    }\r\n\r\n    _validateIdTokenAttributes(state, response) {\r\n        return this._metadataService.getIssuer().then(issuer => {\r\n\r\n            let audience = state.client_id;\r\n            let clockSkewInSeconds = this._settings.clockSkew;\r\n            Log.debug(\"ResponseValidator._validateIdTokenAttributes: Validaing JWT attributes; using clock skew (in seconds) of: \", clockSkewInSeconds);\r\n\r\n            return this._joseUtil.validateJwtAttributes(response.id_token, issuer, audience, clockSkewInSeconds).then(payload => {\r\n            \r\n                if (state.nonce && state.nonce !== payload.nonce) {\r\n                    Log.error(\"ResponseValidator._validateIdTokenAttributes: Invalid nonce in id_token\");\r\n                    return Promise.reject(new Error(\"Invalid nonce in id_token\"));\r\n                }\r\n\r\n                if (!payload.sub) {\r\n                    Log.error(\"ResponseValidator._validateIdTokenAttributes: No sub present in id_token\");\r\n                    return Promise.reject(new Error(\"No sub present in id_token\"));\r\n                }\r\n\r\n                response.profile = payload;\r\n                return response;\r\n            });\r\n        });\r\n    }\r\n\r\n    _validateIdTokenAndAccessToken(state, response) {\r\n        return this._validateIdToken(state, response).then(response => {\r\n            return this._validateAccessToken(response);\r\n        });\r\n    }\r\n\r\n    _validateIdToken(state, response) {\r\n        if (!state.nonce) {\r\n            Log.error(\"ResponseValidator._validateIdToken: No nonce on state\");\r\n            return Promise.reject(new Error(\"No nonce on state\"));\r\n        }\r\n\r\n        let jwt = this._joseUtil.parseJwt(response.id_token);\r\n        if (!jwt || !jwt.header || !jwt.payload) {\r\n            Log.error(\"ResponseValidator._validateIdToken: Failed to parse id_token\", jwt);\r\n            return Promise.reject(new Error(\"Failed to parse id_token\"));\r\n        }\r\n\r\n        if (state.nonce !== jwt.payload.nonce) {\r\n            Log.error(\"ResponseValidator._validateIdToken: Invalid nonce in id_token\");\r\n            return Promise.reject(new Error(\"Invalid nonce in id_token\"));\r\n        }\r\n\r\n        var kid = jwt.header.kid;\r\n\r\n        return this._metadataService.getIssuer().then(issuer => {\r\n            Log.debug(\"ResponseValidator._validateIdToken: Received issuer\");\r\n\r\n            return this._metadataService.getSigningKeys().then(keys => {\r\n                if (!keys) {\r\n                    Log.error(\"ResponseValidator._validateIdToken: No signing keys from metadata\");\r\n                    return Promise.reject(new Error(\"No signing keys from metadata\"));\r\n                }\r\n\r\n                Log.debug(\"ResponseValidator._validateIdToken: Received signing keys\");\r\n                let key;\r\n                if (!kid) {\r\n                    keys = this._filterByAlg(keys, jwt.header.alg);\r\n\r\n                    if (keys.length > 1) {\r\n                        Log.error(\"ResponseValidator._validateIdToken: No kid found in id_token and more than one key found in metadata\");\r\n                        return Promise.reject(new Error(\"No kid found in id_token and more than one key found in metadata\"));\r\n                    }\r\n                    else {\r\n                        // kid is mandatory only when there are multiple keys in the referenced JWK Set document\r\n                        // see http://openid.net/specs/openid-connect-core-1_0.html#Signing\r\n                        key = keys[0];\r\n                    }\r\n                }\r\n                else {\r\n                    key = keys.filter(key => {\r\n                        return key.kid === kid;\r\n                    })[0];\r\n                }\r\n\r\n                if (!key) {\r\n                    Log.error(\"ResponseValidator._validateIdToken: No key matching kid or alg found in signing keys\");\r\n                    return Promise.reject(new Error(\"No key matching kid or alg found in signing keys\"));\r\n                }\r\n\r\n                let audience = state.client_id;\r\n\r\n                let clockSkewInSeconds = this._settings.clockSkew;\r\n                Log.debug(\"ResponseValidator._validateIdToken: Validaing JWT; using clock skew (in seconds) of: \", clockSkewInSeconds);\r\n\r\n                return this._joseUtil.validateJwt(response.id_token, key, issuer, audience, clockSkewInSeconds).then(()=>{\r\n                    Log.debug(\"ResponseValidator._validateIdToken: JWT validation successful\");\r\n\r\n                    if (!jwt.payload.sub) {\r\n                        Log.error(\"ResponseValidator._validateIdToken: No sub present in id_token\");\r\n                        return Promise.reject(new Error(\"No sub present in id_token\"));\r\n                    }\r\n\r\n                    response.profile = jwt.payload;\r\n\r\n                    return response;\r\n                });\r\n            });\r\n        });\r\n    }\r\n\r\n    _filterByAlg(keys, alg){\r\n        var kty = null;\r\n        if (alg.startsWith(\"RS\")) {\r\n            kty = \"RSA\";\r\n        }\r\n        else if (alg.startsWith(\"PS\")) {\r\n            kty = \"PS\";\r\n        }\r\n        else if (alg.startsWith(\"ES\")) {\r\n            kty = \"EC\";\r\n        }\r\n        else {\r\n            Log.debug(\"ResponseValidator._filterByAlg: alg not supported: \", alg);\r\n            return [];\r\n        }\r\n\r\n        Log.debug(\"ResponseValidator._filterByAlg: Looking for keys that match kty: \", kty);\r\n\r\n        keys = keys.filter(key => {\r\n            return key.kty === kty;\r\n        });\r\n\r\n        Log.debug(\"ResponseValidator._filterByAlg: Number of keys that match kty: \", kty, keys.length);\r\n\r\n        return keys;\r\n    }\r\n\r\n    _validateAccessToken(response) {\r\n        if (!response.profile) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: No profile loaded from id_token\");\r\n            return Promise.reject(new Error(\"No profile loaded from id_token\"));\r\n        }\r\n\r\n        if (!response.profile.at_hash) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: No at_hash in id_token\");\r\n            return Promise.reject(new Error(\"No at_hash in id_token\"));\r\n        }\r\n\r\n        if (!response.id_token) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: No id_token\");\r\n            return Promise.reject(new Error(\"No id_token\"));\r\n        }\r\n\r\n        let jwt = this._joseUtil.parseJwt(response.id_token);\r\n        if (!jwt || !jwt.header) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: Failed to parse id_token\", jwt);\r\n            return Promise.reject(new Error(\"Failed to parse id_token\"));\r\n        }\r\n\r\n        var hashAlg = jwt.header.alg;\r\n        if (!hashAlg || hashAlg.length !== 5) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: Unsupported alg:\", hashAlg);\r\n            return Promise.reject(new Error(\"Unsupported alg: \" + hashAlg));\r\n        }\r\n\r\n        var hashBits = hashAlg.substr(2, 3);\r\n        if (!hashBits) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: Unsupported alg:\", hashAlg, hashBits);\r\n            return Promise.reject(new Error(\"Unsupported alg: \" + hashAlg));\r\n        }\r\n\r\n        hashBits = parseInt(hashBits);\r\n        if (hashBits !== 256 && hashBits !== 384 && hashBits !== 512) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: Unsupported alg:\", hashAlg, hashBits);\r\n            return Promise.reject(new Error(\"Unsupported alg: \" + hashAlg));\r\n        }\r\n\r\n        let sha = \"sha\" + hashBits;\r\n        var hash = this._joseUtil.hashString(response.access_token, sha);\r\n        if (!hash) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: access_token hash failed:\", sha);\r\n            return Promise.reject(new Error(\"Failed to validate at_hash\"));\r\n        }\r\n\r\n        var left = hash.substr(0, hash.length / 2);\r\n        var left_b64u = this._joseUtil.hexToBase64Url(left);\r\n        if (left_b64u !== response.profile.at_hash) {\r\n            Log.error(\"ResponseValidator._validateAccessToken: Failed to validate at_hash\", left_b64u, response.profile.at_hash);\r\n            return Promise.reject(new Error(\"Failed to validate at_hash\"));\r\n        }\r\n\r\n        Log.debug(\"ResponseValidator._validateAccessToken: success\");\r\n\r\n        return Promise.resolve(response);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { CheckSessionIFrame } from './CheckSessionIFrame.js';\r\nimport { Global } from './Global.js';\r\n\r\nexport class SessionMonitor {\r\n\r\n    constructor(userManager, CheckSessionIFrameCtor = CheckSessionIFrame, timer = Global.timer) {\r\n        if (!userManager) {\r\n            Log.error(\"SessionMonitor.ctor: No user manager passed to SessionMonitor\");\r\n            throw new Error(\"userManager\");\r\n        }\r\n\r\n        this._userManager = userManager;\r\n        this._CheckSessionIFrameCtor = CheckSessionIFrameCtor;\r\n        this._timer = timer;\r\n\r\n        this._userManager.events.addUserLoaded(this._start.bind(this));\r\n        this._userManager.events.addUserUnloaded(this._stop.bind(this));\r\n\r\n        this._userManager.getUser().then(user => {\r\n            // doing this manually here since calling getUser \r\n            // doesn't trigger load event.\r\n            if (user) {\r\n                this._start(user);\r\n            }\r\n            else if (this._settings.monitorAnonymousSession) {\r\n                this._userManager.querySessionStatus().then(session => {\r\n                    let tmpUser = {\r\n                        session_state : session.session_state\r\n                    };\r\n                    if (session.sub && session.sid) {\r\n                        tmpUser.profile = {\r\n                            sub: session.sub,\r\n                            sid: session.sid\r\n                        };\r\n                    }\r\n                    this._start(tmpUser);\r\n                })\r\n                .catch(err => {\r\n                    // catch to suppress errors since we're in a ctor\r\n                    Log.error(\"SessionMonitor ctor: error from querySessionStatus:\", err.message);\r\n                });\r\n            }\r\n        }).catch(err => {\r\n            // catch to suppress errors since we're in a ctor\r\n            Log.error(\"SessionMonitor ctor: error from getUser:\", err.message);\r\n        });\r\n    }\r\n\r\n    get _settings() {\r\n        return this._userManager.settings;\r\n    }\r\n    get _metadataService() {\r\n        return this._userManager.metadataService;\r\n    }\r\n    get _client_id() {\r\n        return this._settings.client_id;\r\n    }\r\n    get _checkSessionInterval() {\r\n        return this._settings.checkSessionInterval;\r\n    }\r\n    get _stopCheckSessionOnError() {\r\n        return this._settings.stopCheckSessionOnError;\r\n    }\r\n\r\n    _start(user) {\r\n        let session_state = user.session_state;\r\n\r\n        if (session_state) {\r\n            if (user.profile) {\r\n                this._sub = user.profile.sub;\r\n                this._sid = user.profile.sid;\r\n                Log.debug(\"SessionMonitor._start: session_state:\", session_state, \", sub:\", this._sub);\r\n            }\r\n            else {\r\n                this._sub = undefined;\r\n                this._sid = undefined;\r\n                Log.debug(\"SessionMonitor._start: session_state:\", session_state, \", anonymous user\");\r\n            }\r\n\r\n            if (!this._checkSessionIFrame) {\r\n                this._metadataService.getCheckSessionIframe().then(url => {\r\n                    if (url) {\r\n                        Log.debug(\"SessionMonitor._start: Initializing check session iframe\")\r\n\r\n                        let client_id = this._client_id;\r\n                        let interval = this._checkSessionInterval;\r\n                        let stopOnError = this._stopCheckSessionOnError;\r\n\r\n                        this._checkSessionIFrame = new this._CheckSessionIFrameCtor(this._callback.bind(this), client_id, url, interval, stopOnError);\r\n                        this._checkSessionIFrame.load().then(() => {\r\n                            this._checkSessionIFrame.start(session_state);\r\n                        });\r\n                    }\r\n                    else {\r\n                        Log.warn(\"SessionMonitor._start: No check session iframe found in the metadata\");\r\n                    }\r\n                }).catch(err => {\r\n                    // catch to suppress errors since we're in non-promise callback\r\n                    Log.error(\"SessionMonitor._start: Error from getCheckSessionIframe:\", err.message);\r\n                });\r\n            }\r\n            else {\r\n                this._checkSessionIFrame.start(session_state);\r\n            }\r\n        }\r\n    }\r\n\r\n    _stop() {\r\n        this._sub = undefined;\r\n        this._sid = undefined;\r\n\r\n        if (this._checkSessionIFrame) {\r\n            Log.debug(\"SessionMonitor._stop\");\r\n            this._checkSessionIFrame.stop();\r\n        }\r\n\r\n        if (this._settings.monitorAnonymousSession) {\r\n            // using a timer to delay re-initialization to avoid race conditions during signout\r\n            let timerHandle = this._timer.setInterval(()=>{\r\n                this._timer.clearInterval(timerHandle);\r\n\r\n                this._userManager.querySessionStatus().then(session => {\r\n                    let tmpUser = {\r\n                        session_state : session.session_state\r\n                    };\r\n                    if (session.sub && session.sid) {\r\n                        tmpUser.profile = {\r\n                            sub: session.sub,\r\n                            sid: session.sid\r\n                        };\r\n                    }\r\n                    this._start(tmpUser);\r\n                })\r\n                .catch(err => {\r\n                    // catch to suppress errors since we're in a callback\r\n                    Log.error(\"SessionMonitor: error from querySessionStatus:\", err.message);\r\n                });\r\n\r\n            }, 1000);\r\n        }\r\n    }\r\n\r\n    _callback() {\r\n        this._userManager.querySessionStatus().then(session => {\r\n            var raiseEvent = true;\r\n\r\n            if (session) {\r\n                if (session.sub === this._sub) {\r\n                    raiseEvent = false;\r\n                    this._checkSessionIFrame.start(session.session_state);\r\n\r\n                    if (session.sid === this._sid) {\r\n                        Log.debug(\"SessionMonitor._callback: Same sub still logged in at OP, restarting check session iframe; session_state:\", session.session_state);\r\n                    }\r\n                    else {\r\n                        Log.debug(\"SessionMonitor._callback: Same sub still logged in at OP, session state has changed, restarting check session iframe; session_state:\", session.session_state);\r\n                        this._userManager.events._raiseUserSessionChanged();\r\n                    }\r\n                }\r\n                else {\r\n                    Log.debug(\"SessionMonitor._callback: Different subject signed into OP:\", session.sub);\r\n                }\r\n            }\r\n            else {\r\n                Log.debug(\"SessionMonitor._callback: Subject no longer signed into OP\");\r\n            }\r\n\r\n            if (raiseEvent) {\r\n                if (this._sub) {\r\n                    Log.debug(\"SessionMonitor._callback: SessionMonitor._callback; raising signed out event\");\r\n                    this._userManager.events._raiseUserSignedOut();\r\n                }\r\n                else {\r\n                    Log.debug(\"SessionMonitor._callback: SessionMonitor._callback; raising signed in event\");\r\n                    this._userManager.events._raiseUserSignedIn();\r\n                }\r\n            }\r\n        }).catch(err => {\r\n            if (this._sub) {\r\n                Log.debug(\"SessionMonitor._callback: Error calling queryCurrentSigninSession; raising signed out event\", err.message);\r\n                this._userManager.events._raiseUserSignedOut();\r\n            }\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { UrlUtility } from './UrlUtility.js';\r\nimport { SigninState } from './SigninState.js';\r\n\r\nexport class SigninRequest {\r\n    constructor({\r\n        // mandatory\r\n        url, client_id, redirect_uri, response_type, scope, authority,\r\n        // optional\r\n        data, prompt, display, max_age, ui_locales, id_token_hint, login_hint, acr_values, resource, response_mode,\r\n        request, request_uri, extraQueryParams, request_type, client_secret, extraTokenParams, skipUserInfo\r\n    }) {\r\n        if (!url) {\r\n            Log.error(\"SigninRequest.ctor: No url passed\");\r\n            throw new Error(\"url\");\r\n        }\r\n        if (!client_id) {\r\n            Log.error(\"SigninRequest.ctor: No client_id passed\");\r\n            throw new Error(\"client_id\");\r\n        }\r\n        if (!redirect_uri) {\r\n            Log.error(\"SigninRequest.ctor: No redirect_uri passed\");\r\n            throw new Error(\"redirect_uri\");\r\n        }\r\n        if (!response_type) {\r\n            Log.error(\"SigninRequest.ctor: No response_type passed\");\r\n            throw new Error(\"response_type\");\r\n        }\r\n        if (!scope) {\r\n            Log.error(\"SigninRequest.ctor: No scope passed\");\r\n            throw new Error(\"scope\");\r\n        }\r\n        if (!authority) {\r\n            Log.error(\"SigninRequest.ctor: No authority passed\");\r\n            throw new Error(\"authority\");\r\n        }\r\n\r\n        let oidc = SigninRequest.isOidc(response_type);\r\n        let code = SigninRequest.isCode(response_type);\r\n\r\n        if (!response_mode) {\r\n            response_mode = SigninRequest.isCode(response_type) ? \"query\" : null;\r\n        }\r\n\r\n        this.state = new SigninState({ nonce: oidc, \r\n            data, client_id, authority, redirect_uri, \r\n            code_verifier: code, \r\n            request_type, response_mode,\r\n            client_secret, scope, extraTokenParams, skipUserInfo });\r\n\r\n        url = UrlUtility.addQueryParam(url, \"client_id\", client_id);\r\n        url = UrlUtility.addQueryParam(url, \"redirect_uri\", redirect_uri);\r\n        url = UrlUtility.addQueryParam(url, \"response_type\", response_type);\r\n        url = UrlUtility.addQueryParam(url, \"scope\", scope);\r\n\r\n        url = UrlUtility.addQueryParam(url, \"state\", this.state.id);\r\n        if (oidc) {\r\n            url = UrlUtility.addQueryParam(url, \"nonce\", this.state.nonce);\r\n        }\r\n        if (code) {\r\n            url = UrlUtility.addQueryParam(url, \"code_challenge\", this.state.code_challenge);\r\n            url = UrlUtility.addQueryParam(url, \"code_challenge_method\", \"S256\");\r\n        }\r\n\r\n        var optional = { prompt, display, max_age, ui_locales, id_token_hint, login_hint, acr_values, resource, request, request_uri, response_mode };\r\n        for(let key in optional){\r\n            if (optional[key]) {\r\n                url = UrlUtility.addQueryParam(url, key, optional[key]);\r\n            }\r\n        }\r\n\r\n        for(let key in extraQueryParams){\r\n            url = UrlUtility.addQueryParam(url, key, extraQueryParams[key])\r\n        }\r\n\r\n        this.url = url;\r\n    }\r\n\r\n    static isOidc(response_type) {\r\n        var result = response_type.split(/\\s+/g).filter(function(item) {\r\n            return item === \"id_token\";\r\n        });\r\n        return !!(result[0]);\r\n    }\r\n\r\n    static isOAuth(response_type) {\r\n        var result = response_type.split(/\\s+/g).filter(function(item) {\r\n            return item === \"token\";\r\n        });\r\n        return !!(result[0]);\r\n    }\r\n    \r\n    static isCode(response_type) {\r\n        var result = response_type.split(/\\s+/g).filter(function(item) {\r\n            return item === \"code\";\r\n        });\r\n        return !!(result[0]);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { UrlUtility } from './UrlUtility.js';\r\n\r\nconst OidcScope = \"openid\";\r\n\r\nexport class SigninResponse {\r\n    constructor(url, delimiter = \"#\") {\r\n\r\n        var values = UrlUtility.parseUrlFragment(url, delimiter);\r\n\r\n        this.error = values.error;\r\n        this.error_description = values.error_description;\r\n        this.error_uri = values.error_uri;\r\n\r\n        this.code = values.code;\r\n        this.state = values.state;\r\n        this.id_token = values.id_token;\r\n        this.session_state = values.session_state;\r\n        this.access_token = values.access_token;\r\n        this.token_type = values.token_type;\r\n        this.scope = values.scope;\r\n        this.profile = undefined; // will be set from ResponseValidator\r\n\r\n        this.expires_in = values.expires_in;\r\n    }\r\n\r\n    get expires_in() {\r\n        if (this.expires_at) {\r\n            let now = parseInt(Date.now() / 1000);\r\n            return this.expires_at - now;\r\n        }\r\n        return undefined;\r\n    }\r\n    set expires_in(value){\r\n        let expires_in = parseInt(value);\r\n        if (typeof expires_in === 'number' && expires_in > 0) {\r\n            let now = parseInt(Date.now() / 1000);\r\n            this.expires_at = now + expires_in;\r\n        }\r\n    }\r\n\r\n    get expired() {\r\n        let expires_in = this.expires_in;\r\n        if (expires_in !== undefined) {\r\n            return expires_in <= 0;\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    get scopes() {\r\n        return (this.scope || \"\").split(\" \");\r\n    }\r\n\r\n    get isOpenIdConnect() {\r\n        return this.scopes.indexOf(OidcScope) >= 0 || !!this.id_token;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { State } from './State.js';\r\nimport { JoseUtil } from './JoseUtil.js';\r\nimport random from './random.js';\r\n\r\nexport class SigninState extends State {\r\n    constructor({nonce, authority, client_id, redirect_uri, code_verifier, response_mode, client_secret, scope, extraTokenParams, skipUserInfo} = {}) {\r\n        super(arguments[0]);\r\n\r\n        if (nonce === true) {\r\n            this._nonce = random();\r\n        }\r\n        else if (nonce) {\r\n            this._nonce = nonce;\r\n        }\r\n\r\n        if (code_verifier === true) {\r\n            // random() produces 32 length\r\n            this._code_verifier = random() + random() + random();\r\n        }\r\n        else if (code_verifier) {\r\n            this._code_verifier = code_verifier;\r\n        }\r\n        \r\n        if (this.code_verifier) {\r\n            let hash = JoseUtil.hashString(this.code_verifier, \"SHA256\");\r\n            this._code_challenge = JoseUtil.hexToBase64Url(hash);\r\n        }\r\n\r\n        this._redirect_uri = redirect_uri;\r\n        this._authority = authority;\r\n        this._client_id = client_id;\r\n        this._response_mode = response_mode;\r\n        this._client_secret = client_secret;\r\n        this._scope = scope;\r\n        this._extraTokenParams = extraTokenParams;\r\n        this._skipUserInfo = skipUserInfo;\r\n    }\r\n\r\n    get nonce() {\r\n        return this._nonce;\r\n    }\r\n    get authority() {\r\n        return this._authority;\r\n    }\r\n    get client_id() {\r\n        return this._client_id;\r\n    }\r\n    get redirect_uri() {\r\n        return this._redirect_uri;\r\n    }\r\n    get code_verifier() {\r\n        return this._code_verifier;\r\n    }\r\n    get code_challenge() {\r\n        return this._code_challenge;\r\n    }\r\n    get response_mode() {\r\n        return this._response_mode;\r\n    }\r\n    get client_secret() {\r\n        return this._client_secret;\r\n    }\r\n    get scope() {\r\n        return this._scope;\r\n    }\r\n    get extraTokenParams() {\r\n        return this._extraTokenParams;\r\n    }\r\n    get skipUserInfo() {\r\n        return this._skipUserInfo;\r\n    }\r\n    \r\n    toStorageString() {\r\n        Log.debug(\"SigninState.toStorageString\");\r\n        return JSON.stringify({\r\n            id: this.id,\r\n            data: this.data,\r\n            created: this.created,\r\n            request_type: this.request_type,\r\n            nonce: this.nonce,\r\n            code_verifier: this.code_verifier,\r\n            redirect_uri: this.redirect_uri,\r\n            authority: this.authority,\r\n            client_id: this.client_id,\r\n            response_mode: this.response_mode,\r\n            client_secret: this.client_secret,\r\n            scope: this.scope,\r\n            extraTokenParams : this.extraTokenParams,\r\n            skipUserInfo: this.skipUserInfo\r\n        });\r\n    }\r\n\r\n    static fromStorageString(storageString) {\r\n        Log.debug(\"SigninState.fromStorageString\");\r\n        var data = JSON.parse(storageString);\r\n        return new SigninState(data);\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { UrlUtility } from './UrlUtility.js';\r\nimport { State } from './State.js';\r\n\r\nexport class SignoutRequest {\r\n    constructor({url, id_token_hint, post_logout_redirect_uri, data, extraQueryParams, request_type}) {\r\n        if (!url) {\r\n            Log.error(\"SignoutRequest.ctor: No url passed\");\r\n            throw new Error(\"url\");\r\n        }\r\n\r\n        if (id_token_hint) {\r\n            url = UrlUtility.addQueryParam(url, \"id_token_hint\", id_token_hint);\r\n        }\r\n\r\n        if (post_logout_redirect_uri) {\r\n            url = UrlUtility.addQueryParam(url, \"post_logout_redirect_uri\", post_logout_redirect_uri);\r\n\r\n            if (data) {\r\n                this.state = new State({ data, request_type });\r\n\r\n                url = UrlUtility.addQueryParam(url, \"state\", this.state.id);\r\n            }\r\n        }\r\n\r\n        for(let key in extraQueryParams){\r\n            url = UrlUtility.addQueryParam(url, key, extraQueryParams[key])\r\n        }\r\n\r\n        this.url = url;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { UrlUtility } from './UrlUtility.js';\r\n\r\nexport class SignoutResponse {\r\n    constructor(url) {\r\n\r\n        var values = UrlUtility.parseUrlFragment(url, \"?\");\r\n\r\n        this.error = values.error;\r\n        this.error_description = values.error_description;\r\n        this.error_uri = values.error_uri;\r\n\r\n        this.state = values.state;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class SilentRenewService {\r\n\r\n    constructor(userManager) {\r\n        this._userManager = userManager;\r\n    }\r\n\r\n    start() {\r\n        if (!this._callback) {\r\n            this._callback = this._tokenExpiring.bind(this);\r\n            this._userManager.events.addAccessTokenExpiring(this._callback);\r\n\r\n            // this will trigger loading of the user so the expiring events can be initialized\r\n            this._userManager.getUser().then(user=>{\r\n                // deliberate nop\r\n            }).catch(err=>{\r\n                // catch to suppress errors since we're in a ctor\r\n                Log.error(\"SilentRenewService.start: Error from getUser:\", err.message);\r\n            });\r\n        }\r\n    }\r\n\r\n    stop() {\r\n        if (this._callback) {\r\n            this._userManager.events.removeAccessTokenExpiring(this._callback);\r\n            delete this._callback;\r\n        }\r\n    }\r\n\r\n    _tokenExpiring() {\r\n        this._userManager.signinSilent().then(user => {\r\n            Log.debug(\"SilentRenewService._tokenExpiring: Silent token renewal successful\");\r\n        }, err => {\r\n            Log.error(\"SilentRenewService._tokenExpiring: Error from signinSilent:\", err.message);\r\n            this._userManager.events._raiseSilentRenewError(err);\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport random from './random.js';\r\n\r\nexport class State {\r\n    constructor({id, data, created, request_type} = {}) {\r\n        this._id = id || random();\r\n        this._data = data;\r\n\r\n        if (typeof created === 'number' && created > 0) {\r\n            this._created = created;\r\n        }\r\n        else {\r\n            this._created = parseInt(Date.now() / 1000);\r\n        }\r\n        this._request_type =  request_type;\r\n    }\r\n\r\n    get id() {\r\n        return this._id;\r\n    }\r\n    get data() {\r\n        return this._data;\r\n    }\r\n    get created() {\r\n        return this._created;\r\n    }\r\n    get request_type() {\r\n        return this._request_type;\r\n    }\r\n\r\n    toStorageString() {\r\n        Log.debug(\"State.toStorageString\");\r\n        return JSON.stringify({\r\n            id: this.id,\r\n            data: this.data,\r\n            created: this.created,\r\n            request_type: this.request_type\r\n        });\r\n    }\r\n\r\n    static fromStorageString(storageString) {\r\n        Log.debug(\"State.fromStorageString\");\r\n        return new State(JSON.parse(storageString));\r\n    }\r\n\r\n    static clearStaleState(storage, age) {\r\n\r\n        var cutoff = Date.now() / 1000 - age;\r\n\r\n        return storage.getAllKeys().then(keys => {\r\n            Log.debug(\"State.clearStaleState: got keys\", keys);\r\n\r\n            var promises = [];\r\n            for (let i = 0; i < keys.length; i++) {\r\n                let key = keys[i];\r\n                var p = storage.get(key).then(item => {\r\n                    let remove = false;\r\n\r\n                    if (item) {\r\n                        try {\r\n                            var state = State.fromStorageString(item)\r\n\r\n                            Log.debug(\"State.clearStaleState: got item from key: \", key, state.created);\r\n\r\n                            if (state.created <= cutoff) {\r\n                                remove = true;\r\n                            }\r\n                        }\r\n                        catch (e) {\r\n                            Log.error(\"State.clearStaleState: Error parsing state for key\", key, e.message);\r\n                            remove = true;\r\n                        }\r\n                    }\r\n                    else {\r\n                        Log.debug(\"State.clearStaleState: no item in storage for key: \", key);\r\n                        remove = true;\r\n                    }\r\n\r\n                    if (remove) {\r\n                        Log.debug(\"State.clearStaleState: removed item for key: \", key);\r\n                        return storage.remove(key);\r\n                    }\r\n                });\r\n\r\n                promises.push(p);\r\n            }\r\n\r\n            Log.debug(\"State.clearStaleState: waiting on promise count:\", promises.length);\r\n            return Promise.all(promises);\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { Global } from './Global.js';\r\nimport { Event } from './Event.js';\r\n\r\nconst TimerDuration = 5; // seconds\r\n\r\nexport class Timer extends Event {\r\n\r\n    constructor(name, timer = Global.timer, nowFunc = undefined) {\r\n        super(name);\r\n        this._timer = timer;\r\n\r\n        if (nowFunc) {\r\n            this._nowFunc = nowFunc;\r\n        }\r\n        else {\r\n            this._nowFunc = () => Date.now() / 1000;\r\n        }\r\n    }\r\n\r\n    get now() {\r\n        return parseInt(this._nowFunc());\r\n    }\r\n\r\n    init(duration) {\r\n        if (duration <= 0) {\r\n            duration = 1;\r\n        }\r\n        duration = parseInt(duration);\r\n\r\n        var expiration = this.now + duration;\r\n        if (this.expiration === expiration && this._timerHandle) {\r\n            // no need to reinitialize to same expiration, so bail out\r\n            Log.debug(\"Timer.init timer \" + this._name + \" skipping initialization since already initialized for expiration:\", this.expiration);\r\n            return;\r\n        }\r\n\r\n        this.cancel();\r\n\r\n        Log.debug(\"Timer.init timer \" + this._name + \" for duration:\", duration);\r\n        this._expiration = expiration;\r\n\r\n        // we're using a fairly short timer and then checking the expiration in the\r\n        // callback to handle scenarios where the browser device sleeps, and then\r\n        // the timers end up getting delayed.\r\n        var timerDuration = TimerDuration;\r\n        if (duration < timerDuration) {\r\n            timerDuration = duration;\r\n        }\r\n        this._timerHandle = this._timer.setInterval(this._callback.bind(this), timerDuration * 1000);\r\n    }\r\n    \r\n    get expiration() {\r\n        return this._expiration;\r\n    }\r\n\r\n    cancel() {\r\n        if (this._timerHandle) {\r\n            Log.debug(\"Timer.cancel: \", this._name);\r\n            this._timer.clearInterval(this._timerHandle);\r\n            this._timerHandle = null;\r\n        }\r\n    }\r\n\r\n    _callback() {\r\n        var diff = this._expiration - this.now;\r\n        Log.debug(\"Timer.callback; \" + this._name + \" timer expires in:\", diff);\r\n\r\n        if (this._expiration <= this.now) {\r\n            this.cancel();\r\n            super.raise();\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { JsonService } from './JsonService.js';\r\nimport { MetadataService } from './MetadataService.js';\r\nimport { Log } from './Log.js';\r\n\r\nexport class TokenClient {\r\n    constructor(settings, JsonServiceCtor = JsonService, MetadataServiceCtor = MetadataService) {\r\n        if (!settings) {\r\n            Log.error(\"TokenClient.ctor: No settings passed\");\r\n            throw new Error(\"settings\");\r\n        }\r\n\r\n        this._settings = settings;\r\n        this._jsonService = new JsonServiceCtor();\r\n        this._metadataService = new MetadataServiceCtor(this._settings);\r\n    }\r\n\r\n    exchangeCode(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.grant_type = args.grant_type || \"authorization_code\";\r\n        args.client_id = args.client_id || this._settings.client_id;\r\n        args.redirect_uri = args.redirect_uri || this._settings.redirect_uri;\r\n\r\n        if (!args.code) {\r\n            Log.error(\"TokenClient.exchangeCode: No code passed\");\r\n            return Promise.reject(new Error(\"A code is required\"));\r\n        }\r\n        if (!args.redirect_uri) {\r\n            Log.error(\"TokenClient.exchangeCode: No redirect_uri passed\");\r\n            return Promise.reject(new Error(\"A redirect_uri is required\"));\r\n        }\r\n        if (!args.code_verifier) {\r\n            Log.error(\"TokenClient.exchangeCode: No code_verifier passed\");\r\n            return Promise.reject(new Error(\"A code_verifier is required\"));\r\n        }\r\n        if (!args.client_id) {\r\n            Log.error(\"TokenClient.exchangeCode: No client_id passed\");\r\n            return Promise.reject(new Error(\"A client_id is required\"));\r\n        }\r\n\r\n        return this._metadataService.getTokenEndpoint(false).then(url => {\r\n            Log.debug(\"TokenClient.exchangeCode: Received token endpoint\");\r\n\r\n            return this._jsonService.postForm(url, args).then(response => {\r\n                Log.debug(\"TokenClient.exchangeCode: response received\");\r\n                return response;\r\n            });\r\n        });\r\n    }\r\n\r\n    exchangeRefreshToken(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.grant_type = args.grant_type || \"refresh_token\";\r\n        args.client_id = args.client_id || this._settings.client_id;\r\n        args.client_secret = args.client_secret || this._settings.client_secret;\r\n\r\n        if (!args.refresh_token) {\r\n            Log.error(\"TokenClient.exchangeRefreshToken: No refresh_token passed\");\r\n            return Promise.reject(new Error(\"A refresh_token is required\"));\r\n        }\r\n        if (!args.client_id) {\r\n            Log.error(\"TokenClient.exchangeRefreshToken: No client_id passed\");\r\n            return Promise.reject(new Error(\"A client_id is required\"));\r\n        }\r\n\r\n        return this._metadataService.getTokenEndpoint(false).then(url => {\r\n            Log.debug(\"TokenClient.exchangeRefreshToken: Received token endpoint\");\r\n\r\n            return this._jsonService.postForm(url, args).then(response => {\r\n                Log.debug(\"TokenClient.exchangeRefreshToken: response received\");\r\n                return response;\r\n            });\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { MetadataService } from './MetadataService.js';\r\nimport { Global } from './Global.js';\r\n\r\nconst AccessTokenTypeHint = \"access_token\";\r\nconst RefreshTokenTypeHint = \"refresh_token\";\r\n\r\nexport class TokenRevocationClient {\r\n    constructor(settings, XMLHttpRequestCtor = Global.XMLHttpRequest, MetadataServiceCtor = MetadataService) {\r\n        if (!settings) {\r\n            Log.error(\"TokenRevocationClient.ctor: No settings provided\");\r\n            throw new Error(\"No settings provided.\");\r\n        }\r\n\r\n        this._settings = settings;\r\n        this._XMLHttpRequestCtor = XMLHttpRequestCtor;\r\n        this._metadataService = new MetadataServiceCtor(this._settings);\r\n    }\r\n\r\n    revoke(token, required, type = \"access_token\") {\r\n        if (!token) {\r\n            Log.error(\"TokenRevocationClient.revoke: No token provided\");\r\n            throw new Error(\"No token provided.\");\r\n        }\r\n\r\n        if (type !== AccessTokenTypeHint && type != RefreshTokenTypeHint) {\r\n            Log.error(\"TokenRevocationClient.revoke: Invalid token type\");\r\n            throw new Error(\"Invalid token type.\");\r\n        }\r\n\r\n        return this._metadataService.getRevocationEndpoint().then(url => {\r\n            if (!url) {\r\n                if (required) {\r\n                    Log.error(\"TokenRevocationClient.revoke: Revocation not supported\");\r\n                    throw new Error(\"Revocation not supported\");\r\n                }\r\n\r\n                // not required, so don't error and just return\r\n                return;\r\n            }\r\n\r\n            Log.debug(\"TokenRevocationClient.revoke: Revoking \" + type);\r\n            var client_id = this._settings.client_id;\r\n            var client_secret = this._settings.client_secret;\r\n            return this._revoke(url, client_id, client_secret, token, type);\r\n        });\r\n    }\r\n\r\n    _revoke(url, client_id, client_secret, token, type) {\r\n\r\n        return new Promise((resolve, reject) => {\r\n\r\n            var xhr = new this._XMLHttpRequestCtor();\r\n            xhr.open(\"POST\", url);\r\n\r\n            xhr.onload = () => {\r\n                Log.debug(\"TokenRevocationClient.revoke: HTTP response received, status\", xhr.status);\r\n\r\n                if (xhr.status === 200) {\r\n                    resolve();\r\n                }\r\n                else {\r\n                    reject(Error(xhr.statusText + \" (\" + xhr.status + \")\"));\r\n                }\r\n            };\r\n            xhr.onerror = () => { \r\n                Log.debug(\"TokenRevocationClient.revoke: Network Error.\")\r\n                reject(\"Network Error\");\r\n            };\r\n\r\n            var body = \"client_id=\" + encodeURIComponent(client_id);\r\n            if (client_secret) {\r\n                body += \"&client_secret=\" + encodeURIComponent(client_secret);\r\n            }\r\n            body += \"&token_type_hint=\" + encodeURIComponent(type);\r\n            body += \"&token=\" + encodeURIComponent(token);\r\n\r\n            xhr.setRequestHeader(\"Content-Type\", \"application/x-www-form-urlencoded\");\r\n            xhr.send(body);\r\n        });\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { Global } from './Global.js';\r\n\r\nexport class UrlUtility {\r\n    static addQueryParam(url, name, value) {\r\n        if (url.indexOf('?') < 0) {\r\n            url += \"?\";\r\n        }\r\n\r\n        if (url[url.length - 1] !== \"?\") {\r\n            url += \"&\";\r\n        }\r\n\r\n        url += encodeURIComponent(name);\r\n        url += \"=\";\r\n        url += encodeURIComponent(value);\r\n\r\n        return url;\r\n    }\r\n\r\n    static parseUrlFragment(value, delimiter = \"#\", global = Global) {\r\n        if (typeof value !== 'string'){\r\n            value = global.location.href;\r\n        }\r\n\r\n        var idx = value.lastIndexOf(delimiter);\r\n        if (idx >= 0) {\r\n            value = value.substr(idx + 1);\r\n        }\r\n\r\n        if (delimiter === \"?\") {\r\n            // if we're doing query, then strip off hash fragment before we parse\r\n            idx = value.indexOf('#');\r\n            if (idx >= 0) {\r\n                value = value.substr(0, idx);\r\n            }\r\n        }\r\n\r\n        var params = {},\r\n            regex = /([^&=]+)=([^&]*)/g,\r\n            m;\r\n\r\n        var counter = 0;\r\n        while (m = regex.exec(value)) {\r\n            params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);\r\n            if (counter++ > 50) {\r\n                Log.error(\"UrlUtility.parseUrlFragment: response exceeded expected number of parameters\", value);\r\n                return {\r\n                    error: \"Response exceeded expected number of parameters\"\r\n                };\r\n            }\r\n        }\r\n\r\n        for (var prop in params) {\r\n            return params;\r\n        }\r\n\r\n        return {};\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\n\r\nexport class User {\r\n    constructor({id_token, session_state, access_token, refresh_token, token_type, scope, profile, expires_at, state}) {\r\n        this.id_token = id_token;\r\n        this.session_state = session_state;\r\n        this.access_token = access_token;\r\n        this.refresh_token = refresh_token;\r\n        this.token_type = token_type;\r\n        this.scope = scope;\r\n        this.profile = profile;\r\n        this.expires_at = expires_at;\r\n        this.state = state;\r\n    }\r\n\r\n    get expires_in() {\r\n        if (this.expires_at) {\r\n            let now = parseInt(Date.now() / 1000);\r\n            return this.expires_at - now;\r\n        }\r\n        return undefined;\r\n    }\r\n    set expires_in(value) {\r\n        let expires_in = parseInt(value);\r\n        if (typeof expires_in === 'number' && expires_in > 0) {\r\n            let now = parseInt(Date.now() / 1000);\r\n            this.expires_at = now + expires_in;\r\n        }\r\n    }\r\n\r\n    get expired() {\r\n        let expires_in = this.expires_in;\r\n        if (expires_in !== undefined) {\r\n            return expires_in <= 0;\r\n        }\r\n        return undefined;\r\n    }\r\n\r\n    get scopes() {\r\n        return (this.scope || \"\").split(\" \");\r\n    }\r\n\r\n    toStorageString() {\r\n        Log.debug(\"User.toStorageString\");\r\n        return JSON.stringify({\r\n            id_token: this.id_token,\r\n            session_state: this.session_state,\r\n            access_token: this.access_token,\r\n            refresh_token: this.refresh_token,\r\n            token_type: this.token_type,\r\n            scope: this.scope,\r\n            profile: this.profile,\r\n            expires_at: this.expires_at\r\n        });\r\n    }\r\n\r\n    static fromStorageString(storageString) {\r\n        Log.debug(\"User.fromStorageString\");\r\n        return new User(JSON.parse(storageString));\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { JsonService } from './JsonService.js';\r\nimport { MetadataService } from './MetadataService.js';\r\nimport { Log } from './Log.js';\r\nimport { JoseUtil } from './JoseUtil.js';\r\n\r\nexport class UserInfoService {\r\n    constructor(\r\n        settings, \r\n        JsonServiceCtor = JsonService, \r\n        MetadataServiceCtor = MetadataService, \r\n        joseUtil = JoseUtil\r\n    ) {\r\n        if (!settings) {\r\n            Log.error(\"UserInfoService.ctor: No settings passed\");\r\n            throw new Error(\"settings\");\r\n        }\r\n\r\n        this._settings = settings;\r\n        this._jsonService = new JsonServiceCtor(undefined, undefined, this._getClaimsFromJwt.bind(this));\r\n        this._metadataService = new MetadataServiceCtor(this._settings);\r\n        this._joseUtil = joseUtil;\r\n    }\r\n\r\n    getClaims(token) {\r\n        if (!token) {\r\n            Log.error(\"UserInfoService.getClaims: No token passed\");\r\n            return Promise.reject(new Error(\"A token is required\"));\r\n        }\r\n\r\n        return this._metadataService.getUserInfoEndpoint().then(url => {\r\n            Log.debug(\"UserInfoService.getClaims: received userinfo url\", url);\r\n\r\n            return this._jsonService.getJson(url, token).then(claims => {\r\n                Log.debug(\"UserInfoService.getClaims: claims received\", claims);\r\n                return claims;\r\n            });\r\n        });\r\n    }\r\n\r\n    _getClaimsFromJwt(req) {\r\n        try {\r\n            let jwt = this._joseUtil.parseJwt(req.responseText);\r\n            if (!jwt || !jwt.header || !jwt.payload) {\r\n                Log.error(\"UserInfoService._getClaimsFromJwt: Failed to parse JWT\", jwt);\r\n                return Promise.reject(new Error(\"Failed to parse id_token\"));\r\n            }\r\n\r\n            var kid = jwt.header.kid;\r\n\r\n            let issuerPromise;\r\n            switch (this._settings.userInfoJwtIssuer) {\r\n                case 'OP':\r\n                    issuerPromise = this._metadataService.getIssuer();\r\n                    break;\r\n                case 'ANY':\r\n                    issuerPromise = Promise.resolve(jwt.payload.iss);\r\n                    break;\r\n                default:\r\n                    issuerPromise = Promise.resolve(this._settings.userInfoJwtIssuer);\r\n                    break;\r\n            }\r\n\r\n            return issuerPromise.then(issuer => {\r\n                Log.debug(\"UserInfoService._getClaimsFromJwt: Received issuer:\" + issuer);\r\n\r\n                return this._metadataService.getSigningKeys().then(keys => {\r\n                    if (!keys) {\r\n                        Log.error(\"UserInfoService._getClaimsFromJwt: No signing keys from metadata\");\r\n                        return Promise.reject(new Error(\"No signing keys from metadata\"));\r\n                    }\r\n\r\n                    Log.debug(\"UserInfoService._getClaimsFromJwt: Received signing keys\");\r\n                    let key;\r\n                    if (!kid) {\r\n                        keys = this._filterByAlg(keys, jwt.header.alg);\r\n\r\n                        if (keys.length > 1) {\r\n                            Log.error(\"UserInfoService._getClaimsFromJwt: No kid found in id_token and more than one key found in metadata\");\r\n                            return Promise.reject(new Error(\"No kid found in id_token and more than one key found in metadata\"));\r\n                        }\r\n                        else {\r\n                            // kid is mandatory only when there are multiple keys in the referenced JWK Set document\r\n                            // see http://openid.net/specs/openid-connect-core-1_0.html#Signing\r\n                            key = keys[0];\r\n                        }\r\n                    }\r\n                    else {\r\n                        key = keys.filter(key => {\r\n                            return key.kid === kid;\r\n                        })[0];\r\n                    }\r\n\r\n                    if (!key) {\r\n                        Log.error(\"UserInfoService._getClaimsFromJwt: No key matching kid or alg found in signing keys\");\r\n                        return Promise.reject(new Error(\"No key matching kid or alg found in signing keys\"));\r\n                    }\r\n\r\n                    let audience = this._settings.client_id;\r\n\r\n                    let clockSkewInSeconds = this._settings.clockSkew;\r\n                    Log.debug(\"UserInfoService._getClaimsFromJwt: Validaing JWT; using clock skew (in seconds) of: \", clockSkewInSeconds);\r\n\r\n                    return this._joseUtil.validateJwt(req.responseText, key, issuer, audience, clockSkewInSeconds, undefined, true).then(() => {\r\n                        Log.debug(\"UserInfoService._getClaimsFromJwt: JWT validation successful\");\r\n                        return jwt.payload;\r\n                    });\r\n                });\r\n            });\r\n            return;\r\n        }\r\n        catch (e) {\r\n            Log.error(\"UserInfoService._getClaimsFromJwt: Error parsing JWT response\", e.message);\r\n            reject(e);\r\n            return;\r\n        }\r\n    }\r\n\r\n    _filterByAlg(keys, alg) {\r\n        var kty = null;\r\n        if (alg.startsWith(\"RS\")) {\r\n            kty = \"RSA\";\r\n        }\r\n        else if (alg.startsWith(\"PS\")) {\r\n            kty = \"PS\";\r\n        }\r\n        else if (alg.startsWith(\"ES\")) {\r\n            kty = \"EC\";\r\n        }\r\n        else {\r\n            Log.debug(\"UserInfoService._filterByAlg: alg not supported: \", alg);\r\n            return [];\r\n        }\r\n\r\n        Log.debug(\"UserInfoService._filterByAlg: Looking for keys that match kty: \", kty);\r\n\r\n        keys = keys.filter(key => {\r\n            return key.kty === kty;\r\n        });\r\n\r\n        Log.debug(\"UserInfoService._filterByAlg: Number of keys that match kty: \", kty, keys.length);\r\n\r\n        return keys;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { OidcClient } from './OidcClient.js';\r\nimport { UserManagerSettings } from './UserManagerSettings.js';\r\nimport { User } from './User.js';\r\nimport { UserManagerEvents } from './UserManagerEvents.js';\r\nimport { SilentRenewService } from './SilentRenewService.js';\r\nimport { SessionMonitor } from './SessionMonitor.js';\r\nimport { TokenRevocationClient } from './TokenRevocationClient.js';\r\nimport { TokenClient } from './TokenClient.js';\r\nimport { JoseUtil } from './JoseUtil.js';\r\n\r\n\r\nexport class UserManager extends OidcClient {\r\n    constructor(settings = {},\r\n        SilentRenewServiceCtor = SilentRenewService,\r\n        SessionMonitorCtor = SessionMonitor,\r\n        TokenRevocationClientCtor = TokenRevocationClient,\r\n        TokenClientCtor = TokenClient,\r\n        joseUtil = JoseUtil\r\n    ) {\r\n\r\n        if (!(settings instanceof UserManagerSettings)) {\r\n            settings = new UserManagerSettings(settings);\r\n        }\r\n        super(settings);\r\n\r\n        this._events = new UserManagerEvents(settings);\r\n        this._silentRenewService = new SilentRenewServiceCtor(this);\r\n\r\n        // order is important for the following properties; these services depend upon the events.\r\n        if (this.settings.automaticSilentRenew) {\r\n            Log.debug(\"UserManager.ctor: automaticSilentRenew is configured, setting up silent renew\");\r\n            this.startSilentRenew();\r\n        }\r\n\r\n        if (this.settings.monitorSession) {\r\n            Log.debug(\"UserManager.ctor: monitorSession is configured, setting up session monitor\");\r\n            this._sessionMonitor = new SessionMonitorCtor(this);\r\n        }\r\n\r\n        this._tokenRevocationClient = new TokenRevocationClientCtor(this._settings);\r\n        this._tokenClient = new TokenClientCtor(this._settings);\r\n        this._joseUtil = joseUtil;\r\n    }\r\n\r\n    get _redirectNavigator() {\r\n        return this.settings.redirectNavigator;\r\n    }\r\n    get _popupNavigator() {\r\n        return this.settings.popupNavigator;\r\n    }\r\n    get _iframeNavigator() {\r\n        return this.settings.iframeNavigator;\r\n    }\r\n    get _userStore() {\r\n        return this.settings.userStore;\r\n    }\r\n\r\n    get events() {\r\n        return this._events;\r\n    }\r\n\r\n    getUser() {\r\n        return this._loadUser().then(user => {\r\n            if (user) {\r\n                Log.info(\"UserManager.getUser: user loaded\");\r\n\r\n                this._events.load(user, false);\r\n\r\n                return user;\r\n            }\r\n            else {\r\n                Log.info(\"UserManager.getUser: user not found in storage\");\r\n                return null;\r\n            }\r\n        });\r\n    }\r\n\r\n    removeUser() {\r\n        return this.storeUser(null).then(() => {\r\n            Log.info(\"UserManager.removeUser: user removed from storage\");\r\n            this._events.unload();\r\n        });\r\n    }\r\n\r\n    signinRedirect(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"si:r\";\r\n        let navParams = {\r\n            useReplaceToNavigate : args.useReplaceToNavigate\r\n        };\r\n        return this._signinStart(args, this._redirectNavigator, navParams).then(()=>{\r\n            Log.info(\"UserManager.signinRedirect: successful\");\r\n        });\r\n    }\r\n    signinRedirectCallback(url) {\r\n        return this._signinEnd(url || this._redirectNavigator.url).then(user => {\r\n            if (user.profile && user.profile.sub) {\r\n                Log.info(\"UserManager.signinRedirectCallback: successful, signed in sub: \", user.profile.sub);\r\n            }\r\n            else {\r\n                Log.info(\"UserManager.signinRedirectCallback: no sub\");\r\n            }\r\n\r\n            return user;\r\n        });\r\n    }\r\n\r\n    signinPopup(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"si:p\";\r\n        let url = args.redirect_uri || this.settings.popup_redirect_uri || this.settings.redirect_uri;\r\n        if (!url) {\r\n            Log.error(\"UserManager.signinPopup: No popup_redirect_uri or redirect_uri configured\");\r\n            return Promise.reject(new Error(\"No popup_redirect_uri or redirect_uri configured\"));\r\n        }\r\n\r\n        args.redirect_uri = url;\r\n        args.display = \"popup\";\r\n\r\n        return this._signin(args, this._popupNavigator, {\r\n            startUrl: url,\r\n            popupWindowFeatures: args.popupWindowFeatures || this.settings.popupWindowFeatures,\r\n            popupWindowTarget: args.popupWindowTarget || this.settings.popupWindowTarget\r\n        }).then(user => {\r\n            if (user) {\r\n                if (user.profile && user.profile.sub) {\r\n                    Log.info(\"UserManager.signinPopup: signinPopup successful, signed in sub: \", user.profile.sub);\r\n                }\r\n                else {\r\n                    Log.info(\"UserManager.signinPopup: no sub\");\r\n                }\r\n            }\r\n\r\n            return user;\r\n        });\r\n    }\r\n    signinPopupCallback(url) {\r\n        return this._signinCallback(url, this._popupNavigator).then(user => {\r\n            if (user) {\r\n                if (user.profile && user.profile.sub) {\r\n                    Log.info(\"UserManager.signinPopupCallback: successful, signed in sub: \", user.profile.sub);\r\n                }\r\n                else {\r\n                    Log.info(\"UserManager.signinPopupCallback: no sub\");\r\n                }\r\n            }\r\n\r\n            return user;\r\n        }).catch(err=>{\r\n            Log.error(\"UserManager.signinPopupCallback error: \" + err && err.message);\r\n        });\r\n    }\r\n\r\n    signinSilent(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"si:s\";\r\n        // first determine if we have a refresh token, or need to use iframe\r\n        return this._loadUser().then(user => {\r\n            if (user && user.refresh_token) {\r\n                args.refresh_token = user.refresh_token;\r\n                return this._useRefreshToken(args);\r\n            }\r\n            else {\r\n                args.id_token_hint = args.id_token_hint || (this.settings.includeIdTokenInSilentRenew && user && user.id_token);\r\n                if (user && this._settings.validateSubOnSilentRenew) {\r\n                    Log.debug(\"UserManager.signinSilent, subject prior to silent renew: \", user.profile.sub);\r\n                    args.current_sub = user.profile.sub;\r\n                }\r\n                return this._signinSilentIframe(args);\r\n            }\r\n        });\r\n    }\r\n\r\n    _useRefreshToken(args = {}) {\r\n        return this._tokenClient.exchangeRefreshToken(args).then(result => {\r\n            if (!result) {\r\n                Log.error(\"UserManager._useRefreshToken: No response returned from token endpoint\");\r\n                return Promise.reject(\"No response returned from token endpoint\");\r\n            }\r\n            if (!result.access_token) {\r\n                Log.error(\"UserManager._useRefreshToken: No access token returned from token endpoint\");\r\n                return Promise.reject(\"No access token returned from token endpoint\");\r\n            }\r\n\r\n            return this._loadUser().then(user => {\r\n                if (user) {\r\n                    let idTokenValidation = Promise.resolve();\r\n                    if (result.id_token) {\r\n                        idTokenValidation = this._validateIdTokenFromTokenRefreshToken(user.profile, result.id_token);\r\n                    }\r\n\r\n                    return idTokenValidation.then(() => {\r\n                        Log.debug(\"UserManager._useRefreshToken: refresh token response success\");\r\n                        user.id_token = result.id_token;\r\n                        user.access_token = result.access_token;\r\n                        user.refresh_token = result.refresh_token || user.refresh_token;\r\n                        user.expires_in = result.expires_in;\r\n\r\n                        return this.storeUser(user).then(()=>{\r\n                            this._events.load(user);\r\n                            return user;\r\n                        });\r\n                    });\r\n                }\r\n                else {\r\n                    return null;\r\n                }\r\n            });\r\n        });\r\n    }\r\n\r\n    _validateIdTokenFromTokenRefreshToken(profile, id_token) {\r\n        return this._metadataService.getIssuer().then(issuer => {\r\n            return this._joseUtil.validateJwtAttributes(id_token, issuer, this._settings.client_id, this._settings.clockSkew).then(payload => {\r\n                if (!payload) {\r\n                    Log.error(\"UserManager._validateIdTokenFromTokenRefreshToken: Failed to validate id_token\");\r\n                    return Promise.reject(new Error(\"Failed to validate id_token\"));\r\n                }\r\n                if (payload.sub !== profile.sub) {\r\n                    Log.error(\"UserManager._validateIdTokenFromTokenRefreshToken: sub in id_token does not match current sub\");\r\n                    return Promise.reject(new Error(\"sub in id_token does not match current sub\"));\r\n                }\r\n                if (payload.auth_time && payload.auth_time !== profile.auth_time) {\r\n                    Log.error(\"UserManager._validateIdTokenFromTokenRefreshToken: auth_time in id_token does not match original auth_time\");\r\n                    return Promise.reject(new Error(\"auth_time in id_token does not match original auth_time\"));\r\n                }\r\n                if (payload.azp && payload.azp !== profile.azp) {\r\n                    Log.error(\"UserManager._validateIdTokenFromTokenRefreshToken: azp in id_token does not match original azp\");\r\n                    return Promise.reject(new Error(\"azp in id_token does not match original azp\"));\r\n                }\r\n                if (!payload.azp && profile.azp) {\r\n                    Log.error(\"UserManager._validateIdTokenFromTokenRefreshToken: azp not in id_token, but present in original id_token\");\r\n                    return Promise.reject(new Error(\"azp not in id_token, but present in original id_token\"));\r\n                }\r\n            });\r\n        });\r\n    }\r\n    \r\n    _signinSilentIframe(args = {}) {\r\n        let url = args.redirect_uri || this.settings.silent_redirect_uri || this.settings.redirect_uri;\r\n        if (!url) {\r\n            Log.error(\"UserManager.signinSilent: No silent_redirect_uri configured\");\r\n            return Promise.reject(new Error(\"No silent_redirect_uri configured\"));\r\n        }\r\n\r\n        args.redirect_uri = url;\r\n        args.prompt = args.prompt || \"none\";\r\n\r\n        return this._signin(args, this._iframeNavigator, {\r\n            startUrl: url,\r\n            silentRequestTimeout: args.silentRequestTimeout || this.settings.silentRequestTimeout\r\n        }).then(user => {\r\n            if (user) {\r\n                if (user.profile && user.profile.sub) {\r\n                    Log.info(\"UserManager.signinSilent: successful, signed in sub: \", user.profile.sub);\r\n                }\r\n                else {\r\n                    Log.info(\"UserManager.signinSilent: no sub\");\r\n                }\r\n            }\r\n\r\n            return user;\r\n        });\r\n    }\r\n\r\n    signinSilentCallback(url) {\r\n        return this._signinCallback(url, this._iframeNavigator).then(user => {\r\n            if (user) {\r\n                if (user.profile && user.profile.sub) {\r\n                    Log.info(\"UserManager.signinSilentCallback: successful, signed in sub: \", user.profile.sub);\r\n                }\r\n                else {\r\n                    Log.info(\"UserManager.signinSilentCallback: no sub\");\r\n                }\r\n            }\r\n\r\n            return user;\r\n        });\r\n    }\r\n\r\n    signinCallback(url) {\r\n        return this.readSigninResponseState(url).then(({state, response}) => {\r\n            if (state.request_type === \"si:r\") {\r\n                return this.signinRedirectCallback(url);\r\n            }\r\n            if (state.request_type === \"si:p\") {\r\n                return this.signinPopupCallback(url);\r\n            }\r\n            if (state.request_type === \"si:s\") {\r\n                return this.signinSilentCallback(url);\r\n            }\r\n            return Promise.reject(new Error(\"invalid response_type in state\"));\r\n        });\r\n    }\r\n\r\n    signoutCallback(url, keepOpen) {\r\n        return this.readSignoutResponseState(url).then(({state, response}) => {\r\n            if (state) {\r\n                if (state.request_type === \"so:r\") {\r\n                    return this.signoutRedirectCallback(url);\r\n                }\r\n                if (state.request_type === \"so:p\") {\r\n                    return this.signoutPopupCallback(url, keepOpen);\r\n                }\r\n                return Promise.reject(new Error(\"invalid response_type in state\"));\r\n            }\r\n            return response;\r\n        });\r\n    }\r\n\r\n    querySessionStatus(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"si:s\"; // this acts like a signin silent\r\n        let url = args.redirect_uri || this.settings.silent_redirect_uri || this.settings.redirect_uri;\r\n        if (!url) {\r\n            Log.error(\"UserManager.querySessionStatus: No silent_redirect_uri configured\");\r\n            return Promise.reject(new Error(\"No silent_redirect_uri configured\"));\r\n        }\r\n\r\n        args.redirect_uri = url;\r\n        args.prompt = \"none\";\r\n        args.response_type = args.response_type || this.settings.query_status_response_type;\r\n        args.scope = args.scope || \"openid\";\r\n        args.skipUserInfo = true;\r\n\r\n        return this._signinStart(args, this._iframeNavigator, {\r\n            startUrl: url,\r\n            silentRequestTimeout: args.silentRequestTimeout || this.settings.silentRequestTimeout\r\n        }).then(navResponse => {\r\n            return this.processSigninResponse(navResponse.url).then(signinResponse => {\r\n                Log.debug(\"UserManager.querySessionStatus: got signin response\");\r\n\r\n                if (signinResponse.session_state && signinResponse.profile.sub) {\r\n                    Log.info(\"UserManager.querySessionStatus: querySessionStatus success for sub: \",  signinResponse.profile.sub);\r\n                    return {\r\n                        session_state: signinResponse.session_state,\r\n                        sub: signinResponse.profile.sub,\r\n                        sid: signinResponse.profile.sid\r\n                    };\r\n                }\r\n                else {\r\n                    Log.info(\"querySessionStatus successful, user not authenticated\");\r\n                }\r\n            })\r\n            .catch(err => {\r\n                if (err.session_state && this.settings.monitorAnonymousSession) {\r\n                    if (err.message == \"login_required\" || \r\n                        err.message == \"consent_required\" || \r\n                        err.message == \"interaction_required\" || \r\n                        err.message == \"account_selection_required\"\r\n                    ) {\r\n                        Log.info(\"UserManager.querySessionStatus: querySessionStatus success for anonymous user\");\r\n                        return {\r\n                            session_state: err.session_state\r\n                        };\r\n                    }\r\n                }\r\n\r\n                throw err;\r\n            });\r\n        });\r\n    }\r\n\r\n    _signin(args, navigator, navigatorParams = {}) {\r\n        return this._signinStart(args, navigator, navigatorParams).then(navResponse => {\r\n            return this._signinEnd(navResponse.url, args);\r\n        });\r\n    }\r\n    _signinStart(args, navigator, navigatorParams = {}) {\r\n\r\n        return navigator.prepare(navigatorParams).then(handle => {\r\n            Log.debug(\"UserManager._signinStart: got navigator window handle\");\r\n\r\n            return this.createSigninRequest(args).then(signinRequest => {\r\n                Log.debug(\"UserManager._signinStart: got signin request\");\r\n\r\n                navigatorParams.url = signinRequest.url;\r\n                navigatorParams.id = signinRequest.state.id;\r\n\r\n                return handle.navigate(navigatorParams);\r\n            }).catch(err => {\r\n                if (handle.close) {\r\n                    Log.debug(\"UserManager._signinStart: Error after preparing navigator, closing navigator window\");\r\n                    handle.close();\r\n                }\r\n                throw err;\r\n            });\r\n        });\r\n    }\r\n    _signinEnd(url, args = {}) {\r\n        return this.processSigninResponse(url).then(signinResponse => {\r\n            Log.debug(\"UserManager._signinEnd: got signin response\");\r\n\r\n            let user = new User(signinResponse);\r\n\r\n            if (args.current_sub) {\r\n                if (args.current_sub !== user.profile.sub) {\r\n                    Log.debug(\"UserManager._signinEnd: current user does not match user returned from signin. sub from signin: \", user.profile.sub);\r\n                    return Promise.reject(new Error(\"login_required\"));\r\n                }\r\n                else {\r\n                    Log.debug(\"UserManager._signinEnd: current user matches user returned from signin\");\r\n                }\r\n            }\r\n\r\n            return this.storeUser(user).then(() => {\r\n                Log.debug(\"UserManager._signinEnd: user stored\");\r\n\r\n                this._events.load(user);\r\n\r\n                return user;\r\n            });\r\n        });\r\n    }\r\n    _signinCallback(url, navigator) {\r\n        Log.debug(\"UserManager._signinCallback\");\r\n        return navigator.callback(url);\r\n    }\r\n\r\n    signoutRedirect(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"so:r\";\r\n        let postLogoutRedirectUri = args.post_logout_redirect_uri || this.settings.post_logout_redirect_uri;\r\n        if (postLogoutRedirectUri){\r\n            args.post_logout_redirect_uri = postLogoutRedirectUri;\r\n        }\r\n        let navParams = {\r\n            useReplaceToNavigate : args.useReplaceToNavigate\r\n        };\r\n        return this._signoutStart(args, this._redirectNavigator, navParams).then(()=>{\r\n            Log.info(\"UserManager.signoutRedirect: successful\");\r\n        });\r\n    }\r\n    signoutRedirectCallback(url) {\r\n        return this._signoutEnd(url || this._redirectNavigator.url).then(response=>{\r\n            Log.info(\"UserManager.signoutRedirectCallback: successful\");\r\n            return response;\r\n        });\r\n    }\r\n\r\n    signoutPopup(args = {}) {\r\n        args = Object.assign({}, args);\r\n\r\n        args.request_type = \"so:p\";\r\n        let url = args.post_logout_redirect_uri || this.settings.popup_post_logout_redirect_uri || this.settings.post_logout_redirect_uri;\r\n        args.post_logout_redirect_uri = url;\r\n        args.display = \"popup\";\r\n        if (args.post_logout_redirect_uri){\r\n            // we're putting a dummy entry in here because we\r\n            // need a unique id from the state for notification\r\n            // to the parent window, which is necessary if we\r\n            // plan to return back to the client after signout\r\n            // and so we can close the popup after signout\r\n            args.state = args.state || {};\r\n        }\r\n\r\n        return this._signout(args, this._popupNavigator, {\r\n            startUrl: url,\r\n            popupWindowFeatures: args.popupWindowFeatures || this.settings.popupWindowFeatures,\r\n            popupWindowTarget: args.popupWindowTarget || this.settings.popupWindowTarget\r\n        }).then(() => {\r\n            Log.info(\"UserManager.signoutPopup: successful\");\r\n        });\r\n    }\r\n    signoutPopupCallback(url, keepOpen) {\r\n        if (typeof(keepOpen) === 'undefined' && typeof(url) === 'boolean') {\r\n            keepOpen = url;\r\n            url = null;\r\n        }\r\n\r\n        let delimiter = '?';\r\n        return this._popupNavigator.callback(url, keepOpen, delimiter).then(() => {\r\n            Log.info(\"UserManager.signoutPopupCallback: successful\");\r\n        });\r\n    }\r\n\r\n    _signout(args, navigator, navigatorParams = {}) {\r\n        return this._signoutStart(args, navigator, navigatorParams).then(navResponse => {\r\n            return this._signoutEnd(navResponse.url);\r\n        });\r\n    }\r\n    _signoutStart(args = {}, navigator, navigatorParams = {}) {\r\n        return navigator.prepare(navigatorParams).then(handle => {\r\n            Log.debug(\"UserManager._signoutStart: got navigator window handle\");\r\n\r\n            return this._loadUser().then(user => {\r\n                Log.debug(\"UserManager._signoutStart: loaded current user from storage\");\r\n\r\n                var revokePromise = this._settings.revokeAccessTokenOnSignout ? this._revokeInternal(user) : Promise.resolve();\r\n                return revokePromise.then(() => {\r\n\r\n                    var id_token = args.id_token_hint || user && user.id_token;\r\n                    if (id_token) {\r\n                        Log.debug(\"UserManager._signoutStart: Setting id_token into signout request\");\r\n                        args.id_token_hint = id_token;\r\n                    }\r\n\r\n                    return this.removeUser().then(() => {\r\n                        Log.debug(\"UserManager._signoutStart: user removed, creating signout request\");\r\n\r\n                        return this.createSignoutRequest(args).then(signoutRequest => {\r\n                            Log.debug(\"UserManager._signoutStart: got signout request\");\r\n\r\n                            navigatorParams.url = signoutRequest.url;\r\n                            if (signoutRequest.state) {\r\n                                navigatorParams.id = signoutRequest.state.id;\r\n                            }\r\n                            return handle.navigate(navigatorParams);\r\n                        });\r\n                    });\r\n                });\r\n            }).catch(err => {\r\n                if (handle.close) {\r\n                    Log.debug(\"UserManager._signoutStart: Error after preparing navigator, closing navigator window\");\r\n                    handle.close();\r\n                }\r\n                throw err;\r\n            });\r\n        });\r\n    }\r\n    _signoutEnd(url) {\r\n        return this.processSignoutResponse(url).then(signoutResponse => {\r\n            Log.debug(\"UserManager._signoutEnd: got signout response\");\r\n\r\n            return signoutResponse;\r\n        });\r\n    }\r\n\r\n    revokeAccessToken() {\r\n        return this._loadUser().then(user => {\r\n            return this._revokeInternal(user, true).then(success => {\r\n                if (success) {\r\n                    Log.debug(\"UserManager.revokeAccessToken: removing token properties from user and re-storing\");\r\n\r\n                    user.access_token = null;\r\n                    user.refresh_token = null;\r\n                    user.expires_at = null;\r\n                    user.token_type = null;\r\n\r\n                    return this.storeUser(user).then(() => {\r\n                        Log.debug(\"UserManager.revokeAccessToken: user stored\");\r\n                        this._events.load(user);\r\n                    });\r\n                }\r\n            });\r\n        }).then(()=>{\r\n            Log.info(\"UserManager.revokeAccessToken: access token revoked successfully\");\r\n        });\r\n    }\r\n\r\n    _revokeInternal(user, required) {\r\n        if (user) {\r\n            var access_token = user.access_token;\r\n            var refresh_token = user.refresh_token;\r\n\r\n            return this._revokeAccessTokenInternal(access_token, required)\r\n                .then(atSuccess => {\r\n                    return this._revokeRefreshTokenInternal(refresh_token, required)\r\n                        .then(rtSuccess => {\r\n                            if (!atSuccess && !rtSuccess) {\r\n                                Log.debug(\"UserManager.revokeAccessToken: no need to revoke due to no token(s), or JWT format\");\r\n                            }\r\n                            \r\n                            return atSuccess || rtSuccess;\r\n                        });\r\n                });\r\n        }\r\n\r\n        return Promise.resolve(false);\r\n    }\r\n\r\n    _revokeAccessTokenInternal(access_token, required) {\r\n        // check for JWT vs. reference token\r\n        if (!access_token || access_token.indexOf('.') >= 0) {\r\n            return Promise.resolve(false);\r\n        }\r\n\r\n        return this._tokenRevocationClient.revoke(access_token, required).then(() => true);\r\n    }\r\n\r\n    _revokeRefreshTokenInternal(refresh_token, required) {\r\n        if (!refresh_token) {\r\n            return Promise.resolve(false);\r\n        }\r\n\r\n        return this._tokenRevocationClient.revoke(refresh_token, required, \"refresh_token\").then(() => true);\r\n    }\r\n\r\n    startSilentRenew() {\r\n        this._silentRenewService.start();\r\n    }\r\n\r\n    stopSilentRenew() {\r\n        this._silentRenewService.stop();\r\n    }\r\n\r\n    get _userStoreKey() {\r\n        return `user:${this.settings.authority}:${this.settings.client_id}`;\r\n    }\r\n\r\n    _loadUser() {\r\n        return this._userStore.get(this._userStoreKey).then(storageString => {\r\n            if (storageString) {\r\n                Log.debug(\"UserManager._loadUser: user storageString loaded\");\r\n                return User.fromStorageString(storageString);\r\n            }\r\n\r\n            Log.debug(\"UserManager._loadUser: no user storageString\");\r\n            return null;\r\n        });\r\n    }\r\n\r\n    storeUser(user) {\r\n        if (user) {\r\n            Log.debug(\"UserManager.storeUser: storing user\");\r\n\r\n            var storageString = user.toStorageString();\r\n            return this._userStore.set(this._userStoreKey, storageString);\r\n        }\r\n        else {\r\n            Log.debug(\"storeUser.storeUser: removing user\");\r\n            return this._userStore.remove(this._userStoreKey);\r\n        }\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { AccessTokenEvents } from './AccessTokenEvents.js';\r\nimport { Event } from './Event.js';\r\n\r\nexport class UserManagerEvents extends AccessTokenEvents {\r\n\r\n    constructor(settings) {\r\n        super(settings);\r\n        this._userLoaded = new Event(\"User loaded\");\r\n        this._userUnloaded = new Event(\"User unloaded\");\r\n        this._silentRenewError = new Event(\"Silent renew error\");\r\n        this._userSignedIn = new Event(\"User signed in\");\r\n        this._userSignedOut = new Event(\"User signed out\");\r\n        this._userSessionChanged = new Event(\"User session changed\");\r\n    }\r\n\r\n    load(user, raiseEvent=true) {\r\n        Log.debug(\"UserManagerEvents.load\");\r\n        super.load(user);\r\n        if (raiseEvent) {\r\n            this._userLoaded.raise(user);\r\n        }\r\n    }\r\n    unload() {\r\n        Log.debug(\"UserManagerEvents.unload\");\r\n        super.unload();\r\n        this._userUnloaded.raise();\r\n    }\r\n\r\n    addUserLoaded(cb) {\r\n        this._userLoaded.addHandler(cb);\r\n    }\r\n    removeUserLoaded(cb) {\r\n        this._userLoaded.removeHandler(cb);\r\n    }\r\n\r\n    addUserUnloaded(cb) {\r\n        this._userUnloaded.addHandler(cb);\r\n    }\r\n    removeUserUnloaded(cb) {\r\n        this._userUnloaded.removeHandler(cb);\r\n    }\r\n\r\n    addSilentRenewError(cb) {\r\n        this._silentRenewError.addHandler(cb);\r\n    }\r\n    removeSilentRenewError(cb) {\r\n        this._silentRenewError.removeHandler(cb);\r\n    }\r\n    _raiseSilentRenewError(e) {\r\n        Log.debug(\"UserManagerEvents._raiseSilentRenewError\", e.message);\r\n        this._silentRenewError.raise(e);\r\n    }\r\n\r\n    addUserSignedIn(cb) {\r\n        this._userSignedIn.addHandler(cb);\r\n    }\r\n    removeUserSignedIn(cb) {\r\n        this._userSignedIn.removeHandler(cb);\r\n    }\r\n    _raiseUserSignedIn() {\r\n        Log.debug(\"UserManagerEvents._raiseUserSignedIn\");\r\n        this._userSignedIn.raise();\r\n    }\r\n\r\n    addUserSignedOut(cb) {\r\n        this._userSignedOut.addHandler(cb);\r\n    }\r\n    removeUserSignedOut(cb) {\r\n        this._userSignedOut.removeHandler(cb);\r\n    }\r\n    _raiseUserSignedOut() {\r\n        Log.debug(\"UserManagerEvents._raiseUserSignedOut\");\r\n        this._userSignedOut.raise();\r\n    }\r\n\r\n    addUserSessionChanged(cb) {\r\n        this._userSessionChanged.addHandler(cb);\r\n    }\r\n    removeUserSessionChanged(cb) {\r\n        this._userSessionChanged.removeHandler(cb);\r\n    }\r\n    _raiseUserSessionChanged() {\r\n        Log.debug(\"UserManagerEvents._raiseUserSessionChanged\");\r\n        this._userSessionChanged.raise();\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { OidcClientSettings } from './OidcClientSettings.js';\r\nimport { RedirectNavigator } from './RedirectNavigator.js';\r\nimport { PopupNavigator } from './PopupNavigator.js';\r\nimport { IFrameNavigator } from './IFrameNavigator.js';\r\nimport { WebStorageStateStore } from './WebStorageStateStore.js';\r\nimport { Global } from './Global.js';\r\nimport { SigninRequest } from './SigninRequest.js';\r\n\r\nconst DefaultAccessTokenExpiringNotificationTime = 60;\r\nconst DefaultCheckSessionInterval = 2000;\r\n\r\nexport class UserManagerSettings extends OidcClientSettings {\r\n    constructor({\r\n        popup_redirect_uri,\r\n        popup_post_logout_redirect_uri,\r\n        popupWindowFeatures,\r\n        popupWindowTarget,\r\n        silent_redirect_uri,\r\n        silentRequestTimeout,\r\n        automaticSilentRenew = false,\r\n        validateSubOnSilentRenew = false,\r\n        includeIdTokenInSilentRenew = true,\r\n        monitorSession = true,\r\n        monitorAnonymousSession = false,\r\n        checkSessionInterval = DefaultCheckSessionInterval,\r\n        stopCheckSessionOnError = true,\r\n        query_status_response_type,\r\n        revokeAccessTokenOnSignout = false,\r\n        accessTokenExpiringNotificationTime = DefaultAccessTokenExpiringNotificationTime,\r\n        redirectNavigator = new RedirectNavigator(),\r\n        popupNavigator = new PopupNavigator(),\r\n        iframeNavigator = new IFrameNavigator(),\r\n        userStore = new WebStorageStateStore({ store: Global.sessionStorage })\r\n    } = {}) {\r\n        super(arguments[0]);\r\n\r\n        this._popup_redirect_uri = popup_redirect_uri;\r\n        this._popup_post_logout_redirect_uri = popup_post_logout_redirect_uri;\r\n        this._popupWindowFeatures = popupWindowFeatures;\r\n        this._popupWindowTarget = popupWindowTarget;\r\n\r\n        this._silent_redirect_uri = silent_redirect_uri;\r\n        this._silentRequestTimeout = silentRequestTimeout;\r\n        this._automaticSilentRenew = automaticSilentRenew;\r\n        this._validateSubOnSilentRenew = validateSubOnSilentRenew;\r\n        this._includeIdTokenInSilentRenew = includeIdTokenInSilentRenew;\r\n        this._accessTokenExpiringNotificationTime = accessTokenExpiringNotificationTime;\r\n\r\n        this._monitorSession = monitorSession;\r\n        this._monitorAnonymousSession = monitorAnonymousSession;\r\n        this._checkSessionInterval = checkSessionInterval;\r\n        this._stopCheckSessionOnError = stopCheckSessionOnError;\r\n        if (query_status_response_type) {\r\n            this._query_status_response_type = query_status_response_type;\r\n        } \r\n        else if (arguments[0] && arguments[0].response_type) {\r\n            this._query_status_response_type = SigninRequest.isOidc(arguments[0].response_type) ? \"id_token\" : \"code\";\r\n        }\r\n        else {\r\n            this._query_status_response_type = \"id_token\";\r\n        }\r\n        this._revokeAccessTokenOnSignout = revokeAccessTokenOnSignout;\r\n\r\n        this._redirectNavigator = redirectNavigator;\r\n        this._popupNavigator = popupNavigator;\r\n        this._iframeNavigator = iframeNavigator;\r\n\r\n        this._userStore = userStore;\r\n    }\r\n\r\n    get popup_redirect_uri() {\r\n        return this._popup_redirect_uri;\r\n    }\r\n    get popup_post_logout_redirect_uri() {\r\n        return this._popup_post_logout_redirect_uri;\r\n    }\r\n    get popupWindowFeatures() {\r\n        return this._popupWindowFeatures;\r\n    }\r\n    get popupWindowTarget() {\r\n        return this._popupWindowTarget;\r\n    }\r\n\r\n    get silent_redirect_uri() {\r\n        return this._silent_redirect_uri;\r\n    }\r\n     get silentRequestTimeout() {\r\n        return this._silentRequestTimeout;\r\n    }\r\n    get automaticSilentRenew() {\r\n        return this._automaticSilentRenew;\r\n    }\r\n    get validateSubOnSilentRenew() {\r\n        return this._validateSubOnSilentRenew;\r\n    }\r\n    get includeIdTokenInSilentRenew() {\r\n        return this._includeIdTokenInSilentRenew;\r\n    }\r\n    get accessTokenExpiringNotificationTime() {\r\n        return this._accessTokenExpiringNotificationTime;\r\n    }\r\n\r\n    get monitorSession() {\r\n        return this._monitorSession;\r\n    }\r\n    get monitorAnonymousSession() {\r\n        return this._monitorAnonymousSession;\r\n    }\r\n    get checkSessionInterval() {\r\n        return this._checkSessionInterval;\r\n    }\r\n    get stopCheckSessionOnError(){\r\n        return this._stopCheckSessionOnError;\r\n    }\r\n    get query_status_response_type(){\r\n        return this._query_status_response_type;\r\n    }\r\n    get revokeAccessTokenOnSignout() {\r\n        return this._revokeAccessTokenOnSignout;\r\n    }\r\n\r\n    get redirectNavigator() {\r\n        return this._redirectNavigator;\r\n    }\r\n    get popupNavigator() {\r\n        return this._popupNavigator;\r\n    }\r\n    get iframeNavigator() {\r\n        return this._iframeNavigator;\r\n    }\r\n\r\n    get userStore() {\r\n        return this._userStore;\r\n    }\r\n}\r\n","// Copyright (c) Brock Allen & Dominick Baier. All rights reserved.\r\n// Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information.\r\n\r\nimport { Log } from './Log.js';\r\nimport { Global } from './Global.js';\r\n\r\nexport class WebStorageStateStore {\r\n    constructor({prefix = \"oidc.\", store = Global.localStorage} = {}) {\r\n        this._store = store;\r\n        this._prefix = prefix;\r\n    }\r\n\r\n    set(key, value) {\r\n        Log.debug(\"WebStorageStateStore.set\", key);\r\n\r\n        key = this._prefix + key;\r\n\r\n        this._store.setItem(key, value);\r\n\r\n        return Promise.resolve();\r\n    }\r\n\r\n    get(key) {\r\n        Log.debug(\"WebStorageStateStore.get\", key);\r\n\r\n        key = this._prefix + key;\r\n\r\n        let item = this._store.getItem(key);\r\n\r\n        return Promise.resolve(item);\r\n    }\r\n\r\n    remove(key) {\r\n        Log.debug(\"WebStorageStateStore.remove\", key);\r\n\r\n        key = this._prefix + key;\r\n\r\n        let item = this._store.getItem(key);\r\n        this._store.removeItem(key);\r\n\r\n        return Promise.resolve(item);\r\n    }\r\n\r\n    getAllKeys() {\r\n        Log.debug(\"WebStorageStateStore.getAllKeys\");\r\n\r\n        var keys = [];\r\n\r\n        for (let index = 0; index < this._store.length; index++) {\r\n            let key = this._store.key(index);\r\n\r\n            if (key.indexOf(this._prefix) === 0) {\r\n                keys.push(key.substr(this._prefix.length));\r\n            }\r\n        }\r\n\r\n        return Promise.resolve(keys);\r\n    }\r\n}\r\n","import { jws, KEYUTIL as KeyUtil, X509, crypto, hextob64u, b64tohex } from '../../jsrsasign/dist/jsrsasign.js';\r\n\r\nconst AllowedSigningAlgs = ['RS256', 'RS384', 'RS512', 'PS256', 'PS384', 'PS512', 'ES256', 'ES384', 'ES512'];\r\n\r\nexport {\r\n    jws,\r\n    KeyUtil,\r\n    X509,\r\n    crypto,\r\n    hextob64u,\r\n    b64tohex,\r\n    AllowedSigningAlgs\r\n};\r\n","import uuid4 from 'uuid/v4';\r\n\r\n/**\r\n * Generates RFC4122 version 4 guid ()\r\n */\r\n\r\nexport default function random() {\r\n  return uuid4().replace(/-/g, '');\r\n}\r\n","const Version = \"1.10.1\"; export {Version};"],"sourceRoot":""}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/MvcClient.csproj
================================================


  
    
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using System.IdentityModel.Tokens.Jwt;

namespace MvcClient
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

            JwtSecurityTokenHandler.DefaultMapInboundClaims = false;

            services.AddAuthentication(options =>
            {
                options.DefaultScheme = "Cookies";
                options.DefaultChallengeScheme = "oidc";
            })
            .AddCookie("Cookies")
            .AddOpenIdConnect("oidc", options =>
            {
                options.Authority = "https://localhost:5001";

                options.ClientId = "mvc";
                options.ClientSecret = "secret";
                options.ResponseType = "code";
                
                options.Scope.Add("api1");

                options.SaveTokens = true;
            });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseStaticFiles();

            app.UseRouting();
            app.UseAuthentication();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute()
                    .RequireAuthorization();
            });
        }
    }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/4_JavaScriptClient/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/Quickstarts/5_EntityFramework/Quickstart.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BD8BA25C-A91D-419D-99B6-B575ADD6D061}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer", "src\IdentityServer\IdentityServer.csproj", "{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MvcClient", "src\MvcClient\MvcClient.csproj", "{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Api", "..\Shared\src\Api\Api.csproj", "{F555BE49-9B75-4379-96A5-A0490B18EDDB}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Client", "..\Shared\src\Client\Client.csproj", "{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x64.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.ActiveCfg = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Debug|x86.Build.0 = Debug|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|Any CPU.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x64.Build.0 = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.ActiveCfg = Release|Any CPU
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E}.Release|x86.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.Build.0 = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|x64.ActiveCfg = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|x64.Build.0 = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|x86.ActiveCfg = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Debug|x86.Build.0 = Debug|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|Any CPU.Build.0 = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|x64.ActiveCfg = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|x64.Build.0 = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|x86.ActiveCfg = Release|Any CPU
		{F555BE49-9B75-4379-96A5-A0490B18EDDB}.Release|x86.Build.0 = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|x64.ActiveCfg = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|x64.Build.0 = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|x86.ActiveCfg = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Debug|x86.Build.0 = Debug|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|Any CPU.Build.0 = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|x64.ActiveCfg = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|x64.Build.0 = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|x86.ActiveCfg = Release|Any CPU
		{EFC08DC4-FF0B-4B06-A784-4F85C4CCB41C}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{79D1F107-F3AF-4A93-BF5D-49EF6A46E50E} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {84D5AF06-1243-46F1-9D58-70ED572832C3}
	EndGlobalSection
EndGlobal


================================================
FILE: samples/Quickstarts/5_EntityFramework/Quickstart.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft
 Written by Alexander Higgins https://github.com/alexhiggins732/ 
 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code for this software can be found at https://github.com/alexhiggins732/IdentityServer8

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

*/


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Secret = IdentityServer8.Models.Secret;

public static class Config
{
    public static IEnumerable IdentityResources =>
        new List
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
        };


    public static IEnumerable ApiScopes =>
        new List
        {
            new ApiScope("api1", "My API")
        };

    public static IEnumerable Clients =>
        new List
        {
            // machine to machine client
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                // scopes that client has access to
                AllowedScopes = { "api1" }
            },
            
            // interactive ASP.NET Core MVC client
            new Client
            {
                ClientId = "mvc",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.Code,
                
                // where to redirect to after login
                RedirectUris = { "https://localhost:5002/signin-oidc" },

                // where to redirect to after logout
                PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                AllowedScopes = new List
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    "api1"
                }
            }
        };
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/ConfigurationDb/20200625203625_InitialIdentityServerConfigurationDbMigration.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServer.Data.Migrations.IdentityServer.ConfigurationDb
{
    [DbContext(typeof(ConfigurationDbContext))]
    [Migration("20200625203625_InitialIdentityServerConfigurationDbMigration")]
    partial class InitialIdentityServerConfigurationDbMigration
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.5")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AllowedAccessTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AbsoluteRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenType")
                        .HasColumnType("int");

                    b.Property("AllowAccessTokensViaBrowser")
                        .HasColumnType("bit");

                    b.Property("AllowOfflineAccess")
                        .HasColumnType("bit");

                    b.Property("AllowPlainTextPkce")
                        .HasColumnType("bit");

                    b.Property("AllowRememberConsent")
                        .HasColumnType("bit");

                    b.Property("AllowedIdentityTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("AlwaysIncludeUserClaimsInIdToken")
                        .HasColumnType("bit");

                    b.Property("AlwaysSendClientClaims")
                        .HasColumnType("bit");

                    b.Property("AuthorizationCodeLifetime")
                        .HasColumnType("int");

                    b.Property("BackChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("BackChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ClientClaimsPrefix")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ConsentLifetime")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DeviceCodeLifetime")
                        .HasColumnType("int");

                    b.Property("EnableLocalLogin")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("IdentityTokenLifetime")
                        .HasColumnType("int");

                    b.Property("IncludeJwtId")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("LogoUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("PairWiseSubjectSalt")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ProtocolType")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("RefreshTokenExpiration")
                        .HasColumnType("int");

                    b.Property("RefreshTokenUsage")
                        .HasColumnType("int");

                    b.Property("RequireClientSecret")
                        .HasColumnType("bit");

                    b.Property("RequireConsent")
                        .HasColumnType("bit");

                    b.Property("RequirePkce")
                        .HasColumnType("bit");

                    b.Property("RequireRequestObject")
                        .HasColumnType("bit");

                    b.Property("SlidingRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("UpdateAccessTokenClaimsOnRefresh")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.Property("UserCodeType")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("UserSsoLifetime")
                        .HasColumnType("int");

                    b.HasKey("Id");

                    b.HasIndex("ClientId")
                        .IsUnique();

                    b.ToTable("Clients");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Origin")
                        .IsRequired()
                        .HasColumnType("nvarchar(150)")
                        .HasMaxLength(150);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientCorsOrigins");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("GrantType")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientGrantTypes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Provider")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientIdPRestrictions");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("PostLogoutRedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientPostLogoutRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("RedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("IdentityResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Properties")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Scopes")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Secrets")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("UserClaims")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("Properties")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Claims")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedCorsOrigins")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedGrantTypes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("IdentityProviderRestrictions")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("PostLogoutRedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Properties")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("RedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedScopes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("ClientSecrets")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("Properties")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/ConfigurationDb/20200625203625_InitialIdentityServerConfigurationDbMigration.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServer.Data.Migrations.IdentityServer.ConfigurationDb
{
    public partial class InitialIdentityServerConfigurationDbMigration : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "ApiResources",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Enabled = table.Column(nullable: false),
                    Name = table.Column(maxLength: 200, nullable: false),
                    DisplayName = table.Column(maxLength: 200, nullable: true),
                    Description = table.Column(maxLength: 1000, nullable: true),
                    AllowedAccessTokenSigningAlgorithms = table.Column(maxLength: 100, nullable: true),
                    ShowInDiscoveryDocument = table.Column(nullable: false),
                    Created = table.Column(nullable: false),
                    Updated = table.Column(nullable: true),
                    LastAccessed = table.Column(nullable: true),
                    NonEditable = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiResources", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "ApiScopes",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Enabled = table.Column(nullable: false),
                    Name = table.Column(maxLength: 200, nullable: false),
                    DisplayName = table.Column(maxLength: 200, nullable: true),
                    Description = table.Column(maxLength: 1000, nullable: true),
                    Required = table.Column(nullable: false),
                    Emphasize = table.Column(nullable: false),
                    ShowInDiscoveryDocument = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiScopes", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "Clients",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Enabled = table.Column(nullable: false),
                    ClientId = table.Column(maxLength: 200, nullable: false),
                    ProtocolType = table.Column(maxLength: 200, nullable: false),
                    RequireClientSecret = table.Column(nullable: false),
                    ClientName = table.Column(maxLength: 200, nullable: true),
                    Description = table.Column(maxLength: 1000, nullable: true),
                    ClientUri = table.Column(maxLength: 2000, nullable: true),
                    LogoUri = table.Column(maxLength: 2000, nullable: true),
                    RequireConsent = table.Column(nullable: false),
                    AllowRememberConsent = table.Column(nullable: false),
                    AlwaysIncludeUserClaimsInIdToken = table.Column(nullable: false),
                    RequirePkce = table.Column(nullable: false),
                    AllowPlainTextPkce = table.Column(nullable: false),
                    RequireRequestObject = table.Column(nullable: false),
                    AllowAccessTokensViaBrowser = table.Column(nullable: false),
                    FrontChannelLogoutUri = table.Column(maxLength: 2000, nullable: true),
                    FrontChannelLogoutSessionRequired = table.Column(nullable: false),
                    BackChannelLogoutUri = table.Column(maxLength: 2000, nullable: true),
                    BackChannelLogoutSessionRequired = table.Column(nullable: false),
                    AllowOfflineAccess = table.Column(nullable: false),
                    IdentityTokenLifetime = table.Column(nullable: false),
                    AllowedIdentityTokenSigningAlgorithms = table.Column(maxLength: 100, nullable: true),
                    AccessTokenLifetime = table.Column(nullable: false),
                    AuthorizationCodeLifetime = table.Column(nullable: false),
                    ConsentLifetime = table.Column(nullable: true),
                    AbsoluteRefreshTokenLifetime = table.Column(nullable: false),
                    SlidingRefreshTokenLifetime = table.Column(nullable: false),
                    RefreshTokenUsage = table.Column(nullable: false),
                    UpdateAccessTokenClaimsOnRefresh = table.Column(nullable: false),
                    RefreshTokenExpiration = table.Column(nullable: false),
                    AccessTokenType = table.Column(nullable: false),
                    EnableLocalLogin = table.Column(nullable: false),
                    IncludeJwtId = table.Column(nullable: false),
                    AlwaysSendClientClaims = table.Column(nullable: false),
                    ClientClaimsPrefix = table.Column(maxLength: 200, nullable: true),
                    PairWiseSubjectSalt = table.Column(maxLength: 200, nullable: true),
                    Created = table.Column(nullable: false),
                    Updated = table.Column(nullable: true),
                    LastAccessed = table.Column(nullable: true),
                    UserSsoLifetime = table.Column(nullable: true),
                    UserCodeType = table.Column(maxLength: 100, nullable: true),
                    DeviceCodeLifetime = table.Column(nullable: false),
                    NonEditable = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_Clients", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "IdentityResources",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Enabled = table.Column(nullable: false),
                    Name = table.Column(maxLength: 200, nullable: false),
                    DisplayName = table.Column(maxLength: 200, nullable: true),
                    Description = table.Column(maxLength: 1000, nullable: true),
                    Required = table.Column(nullable: false),
                    Emphasize = table.Column(nullable: false),
                    ShowInDiscoveryDocument = table.Column(nullable: false),
                    Created = table.Column(nullable: false),
                    Updated = table.Column(nullable: true),
                    NonEditable = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityResources", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "ApiResourceClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Type = table.Column(maxLength: 200, nullable: false),
                    ApiResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiResourceClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiResourceClaims_ApiResources_ApiResourceId",
                        column: x => x.ApiResourceId,
                        principalTable: "ApiResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ApiResourceProperties",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Key = table.Column(maxLength: 250, nullable: false),
                    Value = table.Column(maxLength: 2000, nullable: false),
                    ApiResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiResourceProperties", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiResourceProperties_ApiResources_ApiResourceId",
                        column: x => x.ApiResourceId,
                        principalTable: "ApiResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ApiResourceScopes",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Scope = table.Column(maxLength: 200, nullable: false),
                    ApiResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiResourceScopes", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiResourceScopes_ApiResources_ApiResourceId",
                        column: x => x.ApiResourceId,
                        principalTable: "ApiResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ApiResourceSecrets",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Description = table.Column(maxLength: 1000, nullable: true),
                    Value = table.Column(maxLength: 4000, nullable: false),
                    Expiration = table.Column(nullable: true),
                    Type = table.Column(maxLength: 250, nullable: false),
                    Created = table.Column(nullable: false),
                    ApiResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiResourceSecrets", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiResourceSecrets_ApiResources_ApiResourceId",
                        column: x => x.ApiResourceId,
                        principalTable: "ApiResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ApiScopeClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Type = table.Column(maxLength: 200, nullable: false),
                    ScopeId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiScopeClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiScopeClaims_ApiScopes_ScopeId",
                        column: x => x.ScopeId,
                        principalTable: "ApiScopes",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ApiScopeProperties",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Key = table.Column(maxLength: 250, nullable: false),
                    Value = table.Column(maxLength: 2000, nullable: false),
                    ScopeId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ApiScopeProperties", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ApiScopeProperties_ApiScopes_ScopeId",
                        column: x => x.ScopeId,
                        principalTable: "ApiScopes",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Type = table.Column(maxLength: 250, nullable: false),
                    Value = table.Column(maxLength: 250, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientClaims_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientCorsOrigins",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Origin = table.Column(maxLength: 150, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientCorsOrigins", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientCorsOrigins_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientGrantTypes",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    GrantType = table.Column(maxLength: 250, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientGrantTypes", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientGrantTypes_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientIdPRestrictions",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Provider = table.Column(maxLength: 200, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientIdPRestrictions", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientIdPRestrictions_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientPostLogoutRedirectUris",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    PostLogoutRedirectUri = table.Column(maxLength: 2000, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientPostLogoutRedirectUris", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientPostLogoutRedirectUris_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientProperties",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Key = table.Column(maxLength: 250, nullable: false),
                    Value = table.Column(maxLength: 2000, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientProperties", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientProperties_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientRedirectUris",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    RedirectUri = table.Column(maxLength: 2000, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientRedirectUris", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientRedirectUris_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientScopes",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Scope = table.Column(maxLength: 200, nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientScopes", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientScopes_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "ClientSecrets",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Description = table.Column(maxLength: 2000, nullable: true),
                    Value = table.Column(maxLength: 4000, nullable: false),
                    Expiration = table.Column(nullable: true),
                    Type = table.Column(maxLength: 250, nullable: false),
                    Created = table.Column(nullable: false),
                    ClientId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_ClientSecrets", x => x.Id);
                    table.ForeignKey(
                        name: "FK_ClientSecrets_Clients_ClientId",
                        column: x => x.ClientId,
                        principalTable: "Clients",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "IdentityResourceClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Type = table.Column(maxLength: 200, nullable: false),
                    IdentityResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityResourceClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_IdentityResourceClaims_IdentityResources_IdentityResourceId",
                        column: x => x.IdentityResourceId,
                        principalTable: "IdentityResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "IdentityResourceProperties",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("SqlServer:Identity", "1, 1"),
                    Key = table.Column(maxLength: 250, nullable: false),
                    Value = table.Column(maxLength: 2000, nullable: false),
                    IdentityResourceId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_IdentityResourceProperties", x => x.Id);
                    table.ForeignKey(
                        name: "FK_IdentityResourceProperties_IdentityResources_IdentityResourceId",
                        column: x => x.IdentityResourceId,
                        principalTable: "IdentityResources",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateIndex(
                name: "IX_ApiResourceClaims_ApiResourceId",
                table: "ApiResourceClaims",
                column: "ApiResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiResourceProperties_ApiResourceId",
                table: "ApiResourceProperties",
                column: "ApiResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiResources_Name",
                table: "ApiResources",
                column: "Name",
                unique: true);

            migrationBuilder.CreateIndex(
                name: "IX_ApiResourceScopes_ApiResourceId",
                table: "ApiResourceScopes",
                column: "ApiResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiResourceSecrets_ApiResourceId",
                table: "ApiResourceSecrets",
                column: "ApiResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiScopeClaims_ScopeId",
                table: "ApiScopeClaims",
                column: "ScopeId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiScopeProperties_ScopeId",
                table: "ApiScopeProperties",
                column: "ScopeId");

            migrationBuilder.CreateIndex(
                name: "IX_ApiScopes_Name",
                table: "ApiScopes",
                column: "Name",
                unique: true);

            migrationBuilder.CreateIndex(
                name: "IX_ClientClaims_ClientId",
                table: "ClientClaims",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientCorsOrigins_ClientId",
                table: "ClientCorsOrigins",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientGrantTypes_ClientId",
                table: "ClientGrantTypes",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientIdPRestrictions_ClientId",
                table: "ClientIdPRestrictions",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientPostLogoutRedirectUris_ClientId",
                table: "ClientPostLogoutRedirectUris",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientProperties_ClientId",
                table: "ClientProperties",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientRedirectUris_ClientId",
                table: "ClientRedirectUris",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_Clients_ClientId",
                table: "Clients",
                column: "ClientId",
                unique: true);

            migrationBuilder.CreateIndex(
                name: "IX_ClientScopes_ClientId",
                table: "ClientScopes",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_ClientSecrets_ClientId",
                table: "ClientSecrets",
                column: "ClientId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityResourceClaims_IdentityResourceId",
                table: "IdentityResourceClaims",
                column: "IdentityResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityResourceProperties_IdentityResourceId",
                table: "IdentityResourceProperties",
                column: "IdentityResourceId");

            migrationBuilder.CreateIndex(
                name: "IX_IdentityResources_Name",
                table: "IdentityResources",
                column: "Name",
                unique: true);
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "ApiResourceClaims");

            migrationBuilder.DropTable(
                name: "ApiResourceProperties");

            migrationBuilder.DropTable(
                name: "ApiResourceScopes");

            migrationBuilder.DropTable(
                name: "ApiResourceSecrets");

            migrationBuilder.DropTable(
                name: "ApiScopeClaims");

            migrationBuilder.DropTable(
                name: "ApiScopeProperties");

            migrationBuilder.DropTable(
                name: "ClientClaims");

            migrationBuilder.DropTable(
                name: "ClientCorsOrigins");

            migrationBuilder.DropTable(
                name: "ClientGrantTypes");

            migrationBuilder.DropTable(
                name: "ClientIdPRestrictions");

            migrationBuilder.DropTable(
                name: "ClientPostLogoutRedirectUris");

            migrationBuilder.DropTable(
                name: "ClientProperties");

            migrationBuilder.DropTable(
                name: "ClientRedirectUris");

            migrationBuilder.DropTable(
                name: "ClientScopes");

            migrationBuilder.DropTable(
                name: "ClientSecrets");

            migrationBuilder.DropTable(
                name: "IdentityResourceClaims");

            migrationBuilder.DropTable(
                name: "IdentityResourceProperties");

            migrationBuilder.DropTable(
                name: "ApiResources");

            migrationBuilder.DropTable(
                name: "ApiScopes");

            migrationBuilder.DropTable(
                name: "Clients");

            migrationBuilder.DropTable(
                name: "IdentityResources");
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/ConfigurationDb/ConfigurationDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;

namespace IdentityServer.Data.Migrations.IdentityServer.ConfigurationDb
{
    [DbContext(typeof(ConfigurationDbContext))]
    partial class ConfigurationDbContextModelSnapshot : ModelSnapshot
    {
        protected override void BuildModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.5")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AllowedAccessTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AbsoluteRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenType")
                        .HasColumnType("int");

                    b.Property("AllowAccessTokensViaBrowser")
                        .HasColumnType("bit");

                    b.Property("AllowOfflineAccess")
                        .HasColumnType("bit");

                    b.Property("AllowPlainTextPkce")
                        .HasColumnType("bit");

                    b.Property("AllowRememberConsent")
                        .HasColumnType("bit");

                    b.Property("AllowedIdentityTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("AlwaysIncludeUserClaimsInIdToken")
                        .HasColumnType("bit");

                    b.Property("AlwaysSendClientClaims")
                        .HasColumnType("bit");

                    b.Property("AuthorizationCodeLifetime")
                        .HasColumnType("int");

                    b.Property("BackChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("BackChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ClientClaimsPrefix")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ConsentLifetime")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DeviceCodeLifetime")
                        .HasColumnType("int");

                    b.Property("EnableLocalLogin")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("IdentityTokenLifetime")
                        .HasColumnType("int");

                    b.Property("IncludeJwtId")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("LogoUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("PairWiseSubjectSalt")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ProtocolType")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("RefreshTokenExpiration")
                        .HasColumnType("int");

                    b.Property("RefreshTokenUsage")
                        .HasColumnType("int");

                    b.Property("RequireClientSecret")
                        .HasColumnType("bit");

                    b.Property("RequireConsent")
                        .HasColumnType("bit");

                    b.Property("RequirePkce")
                        .HasColumnType("bit");

                    b.Property("RequireRequestObject")
                        .HasColumnType("bit");

                    b.Property("SlidingRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("UpdateAccessTokenClaimsOnRefresh")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.Property("UserCodeType")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("UserSsoLifetime")
                        .HasColumnType("int");

                    b.HasKey("Id");

                    b.HasIndex("ClientId")
                        .IsUnique();

                    b.ToTable("Clients");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Origin")
                        .IsRequired()
                        .HasColumnType("nvarchar(150)")
                        .HasMaxLength(150);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientCorsOrigins");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("GrantType")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientGrantTypes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Provider")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientIdPRestrictions");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("PostLogoutRedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientPostLogoutRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("RedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("IdentityResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Properties")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Scopes")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Secrets")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("UserClaims")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("Properties")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Claims")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedCorsOrigins")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedGrantTypes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("IdentityProviderRestrictions")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("PostLogoutRedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Properties")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("RedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedScopes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("ClientSecrets")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("Properties")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/PersistedGrantDb/20200625203357_InitialIdentityServerPersistedGrantDbMigration.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;
using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServer.Data.Migrations.IdentityServer.PersistedGrantDb
{
    [DbContext(typeof(PersistedGrantDbContext))]
    [Migration("20200625203357_InitialIdentityServerPersistedGrantDbMigration")]
    partial class InitialIdentityServerPersistedGrantDbMigration
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.5")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.DeviceFlowCodes", b =>
                {
                    b.Property("UserCode")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("DeviceCode")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .IsRequired()
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("UserCode");

                    b.HasIndex("DeviceCode")
                        .IsUnique();

                    b.HasIndex("Expiration");

                    b.ToTable("DeviceCodes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.PersistedGrant", b =>
                {
                    b.Property("Key")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ConsumedTime")
                        .HasColumnType("datetime2");

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(50)")
                        .HasMaxLength(50);

                    b.HasKey("Key");

                    b.HasIndex("Expiration");

                    b.HasIndex("SubjectId", "ClientId", "Type");

                    b.HasIndex("SubjectId", "SessionId", "Type");

                    b.ToTable("PersistedGrants");
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/PersistedGrantDb/20200625203357_InitialIdentityServerPersistedGrantDbMigration.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServer.Data.Migrations.IdentityServer.PersistedGrantDb
{
    public partial class InitialIdentityServerPersistedGrantDbMigration : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "DeviceCodes",
                columns: table => new
                {
                    UserCode = table.Column(maxLength: 200, nullable: false),
                    DeviceCode = table.Column(maxLength: 200, nullable: false),
                    SubjectId = table.Column(maxLength: 200, nullable: true),
                    SessionId = table.Column(maxLength: 100, nullable: true),
                    ClientId = table.Column(maxLength: 200, nullable: false),
                    Description = table.Column(maxLength: 200, nullable: true),
                    CreationTime = table.Column(nullable: false),
                    Expiration = table.Column(nullable: false),
                    Data = table.Column(maxLength: 50000, nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_DeviceCodes", x => x.UserCode);
                });

            migrationBuilder.CreateTable(
                name: "PersistedGrants",
                columns: table => new
                {
                    Key = table.Column(maxLength: 200, nullable: false),
                    Type = table.Column(maxLength: 50, nullable: false),
                    SubjectId = table.Column(maxLength: 200, nullable: true),
                    SessionId = table.Column(maxLength: 100, nullable: true),
                    ClientId = table.Column(maxLength: 200, nullable: false),
                    Description = table.Column(maxLength: 200, nullable: true),
                    CreationTime = table.Column(nullable: false),
                    Expiration = table.Column(nullable: true),
                    ConsumedTime = table.Column(nullable: true),
                    Data = table.Column(maxLength: 50000, nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_PersistedGrants", x => x.Key);
                });

            migrationBuilder.CreateIndex(
                name: "IX_DeviceCodes_DeviceCode",
                table: "DeviceCodes",
                column: "DeviceCode",
                unique: true);

            migrationBuilder.CreateIndex(
                name: "IX_DeviceCodes_Expiration",
                table: "DeviceCodes",
                column: "Expiration");

            migrationBuilder.CreateIndex(
                name: "IX_PersistedGrants_Expiration",
                table: "PersistedGrants",
                column: "Expiration");

            migrationBuilder.CreateIndex(
                name: "IX_PersistedGrants_SubjectId_ClientId_Type",
                table: "PersistedGrants",
                columns: new[] { "SubjectId", "ClientId", "Type" });

            migrationBuilder.CreateIndex(
                name: "IX_PersistedGrants_SubjectId_SessionId_Type",
                table: "PersistedGrants",
                columns: new[] { "SubjectId", "SessionId", "Type" });
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "DeviceCodes");

            migrationBuilder.DropTable(
                name: "PersistedGrants");
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Data/Migrations/IdentityServer/PersistedGrantDb/PersistedGrantDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Metadata;

namespace IdentityServer.Data.Migrations.IdentityServer.PersistedGrantDb
{
    [DbContext(typeof(PersistedGrantDbContext))]
    partial class PersistedGrantDbContextModelSnapshot : ModelSnapshot
    {
        protected override void BuildModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.5")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.DeviceFlowCodes", b =>
                {
                    b.Property("UserCode")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("DeviceCode")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .IsRequired()
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("UserCode");

                    b.HasIndex("DeviceCode")
                        .IsUnique();

                    b.HasIndex("Expiration");

                    b.ToTable("DeviceCodes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.PersistedGrant", b =>
                {
                    b.Property("Key")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ConsumedTime")
                        .HasColumnType("datetime2");

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(50)")
                        .HasMaxLength(50);

                    b.HasKey("Key");

                    b.HasIndex("Expiration");

                    b.HasIndex("SubjectId", "ClientId", "Type");

                    b.HasIndex("SubjectId", "SessionId", "Type");

                    b.ToTable("PersistedGrants");
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.EntityFramework.DbContexts;
global using IdentityServer8.EntityFramework.Mappers;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Options;
global using Microsoft.IdentityModel.Tokens;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System;
global using System.ComponentModel.DataAnnotations;
global using System.Reflection;
global using System.Security.Claims;
global using System.Text;
global using System.Text.Json;
global using static IdentityModel.JwtClaimTypes;
global using IdentityServerClaimValueTypes = IdentityServer8.IdentityServerConstants.ClaimValueTypes;


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/IdentityServer.csproj
================================================

    
        
        
        

        
        
        
    



================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

ConfigureLogger();

try
{
    Log.Information("Starting host...");

    var builder = WebApplication.CreateBuilder(args);

    var services = builder.Services;

    services.AddControllersWithViews();

    var migrationsAssembly = typeof(Program).GetTypeInfo().Assembly.GetName().Name;
    const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer8.Quickstart.EntityFramework-4.0.0;trusted_connection=yes;";

    services.AddIdentityServer()
        .AddTestUsers(TestUsers.Users)
        .AddConfigurationStore(options =>
        {
            options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                sql => sql.MigrationsAssembly(migrationsAssembly));
        })
        .AddOperationalStore(options =>
        {
            options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                sql => sql.MigrationsAssembly(migrationsAssembly));
        })
        .AddDeveloperSigningCredential();

    services.AddAuthentication()
        .AddGoogle("Google", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

            options.ClientId = "";
            options.ClientSecret = "";
        })
        .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
            options.SignOutScheme = IdentityServerConstants.SignoutScheme;
            options.SaveTokens = true;

            options.Authority = "https://demo.identityserver8.io/";
            options.ClientId = "interactive.confidential";
            options.ClientSecret = "secret";
            options.ResponseType = "code";

            options.TokenValidationParameters = new()
            {
                NameClaimType = "name",
                RoleClaimType = "role"
            };
        });


    using (var app = builder.Build())
    {
        // this will do the initial DB population
        InitializeDatabase(app);

        if (app.Environment.IsDevelopment())
            app.UseDeveloperExceptionPage();

        app.UseStaticFiles()
            .UseRouting()
            .UseIdentityServer()
            .UseAuthorization();

        app.MapDefaultControllerRoute();

        await app.RunAsync();
    }

    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host terminated unexpectedly.");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}


void ConfigureLogger() => Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
    .Enrich.FromLogContext()
    // uncomment to write to Azure diagnostics stream
    //.WriteTo.File(
    //    @"D:\home\LogFiles\Application\identityserver.txt",
    //    fileSizeLimitBytes: 1_000_000,
    //    rollOnFileSizeLimit: true,
    //    shared: true,
    //    flushToDiskInterval: TimeSpan.FromSeconds(1))
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
    .CreateLogger();

 void InitializeDatabase(IApplicationBuilder app)
{
    using (var serviceScope = app.ApplicationServices.GetService().CreateScope())
    {
        serviceScope.ServiceProvider.GetRequiredService().Database.Migrate();

        var context = serviceScope.ServiceProvider.GetRequiredService();
        context.Database.Migrate();
        if (!context.Clients.Any())
        {
            foreach (var client in Config.Clients)
            {
                context.Clients.Add(client.ToEntity());
            }
            context.SaveChanges();
        }

        if (!context.IdentityResources.Any())
        {
            foreach (var resource in Config.IdentityResources)
            {
                context.IdentityResources.Add(resource.ToEntity());
            }
            context.SaveChanges();
        }

        if (!context.ApiScopes.Any())
        {
            foreach (var resource in Config.ApiScopes)
            {
                context.ApiScopes.Add(resource.ToEntity());
            }
            context.SaveChanges();
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI
{
    public class AccountOptions
    {
        public static bool AllowLocalLogin = true;
        public static bool AllowRememberLogin = true;
        public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

        public static bool ShowLogoutPrompt = true;
        public static bool AutomaticRedirectAfterSignOut = false;

        public static string InvalidCredentialsErrorMessage = "Invalid username or password";
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonSerializer.Deserialize(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{

    static readonly object UserAddress = new
    {
        street_address = "One Hacker Way",
        locality = "Heidelberg",
        postal_code = 69118,
        country = "Germany"
    };

    public static List Users => new List
    {
        new()
        {
            SubjectId = "818727",
            Username = "alice",
            Password = "alice",
            Claims =
            {
                new (Name, "Alice Smith"),
                new (GivenName, "Alice"),
                new (FamilyName, "Smith"),
                new (Email, "AliceSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://alice.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        },
        new()
        {
            SubjectId = "88421113",
            Username = "bob",
            Password = "bob",
            Claims =
            {
                new (Name, "Bob Smith"),
                new (GivenName, "Bob"),
                new (FamilyName, "Smith"),
                new (Email, "BobSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://bob.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        }
    };
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServerHost.Quickstart.UI;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.IdentityModel.Tokens;
using System.Linq;
using System.Reflection;

namespace IdentityServer
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddControllersWithViews();

            var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
            const string connectionString = @"Data Source=(LocalDb)\MSSQLLocalDB;database=IdentityServer8.Quickstart.EntityFramework-4.0.0;trusted_connection=yes;";
            
            var builder = services.AddIdentityServer()
                .AddTestUsers(TestUsers.Users)
                .AddConfigurationStore(options =>
                {
                    options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                        sql => sql.MigrationsAssembly(migrationsAssembly));
                })
                .AddOperationalStore(options =>
                {
                    options.ConfigureDbContext = b => b.UseSqlServer(connectionString,
                        sql => sql.MigrationsAssembly(migrationsAssembly));
                });

            builder.AddDeveloperSigningCredential();

            services.AddAuthentication()
                .AddGoogle("Google", options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

                    options.ClientId = "";
                    options.ClientSecret = "";
                })
                .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                    options.SignOutScheme = IdentityServerConstants.SignoutScheme;
                    options.SaveTokens = true;

                    options.Authority = "https://demo.identityserver8.io/";
                    options.ClientId = "interactive.confidential";
                    options.ClientSecret = "secret";
                    options.ResponseType = "code";

                    options.TokenValidationParameters = new TokenValidationParameters
                    {
                        NameClaimType = "name",
                        RoleClaimType = "role"
                    };
                });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            // this will do the initial DB population
            InitializeDatabase(app);

            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseStaticFiles();
            app.UseRouting();

            app.UseIdentityServer();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute();
            });
        }

        private void InitializeDatabase(IApplicationBuilder app)
        {
            using (var serviceScope = app.ApplicationServices.GetService().CreateScope())
            {
                serviceScope.ServiceProvider.GetRequiredService().Database.Migrate();

                var context = serviceScope.ServiceProvider.GetRequiredService();
                context.Database.Migrate();
                if (!context.Clients.Any())
                {
                    foreach (var client in Config.Clients)
                    {
                        context.Clients.Add(client.ToEntity());
                    }
                    context.SaveChanges();
                }

                if (!context.IdentityResources.Any())
                {
                    foreach (var resource in Config.IdentityResources)
                    {
                        context.IdentityResources.Add(resource.ToEntity());
                    }
                    context.SaveChanges();
                }

                if (!context.ApiScopes.Any())
                {
                    foreach (var resource in Config.ApiScopes)
                    {
                        context.ApiScopes.Add(resource.ToEntity());
                    }
                    context.SaveChanges();
                }
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/wwwroot/js/signin-redirect.js
================================================
// window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/IdentityServer/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/MvcClient.csproj
================================================


  
    
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/5_EntityFramework/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/Quickstart.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{BD8BA25C-A91D-419D-99B6-B575ADD6D061}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MvcClient", "src\MvcClient\MvcClient.csproj", "{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServerAspNetIdentity", "src\IdentityServerAspNetIdentity\IdentityServerAspNetIdentity.csproj", "{C49859B4-B34C-4594-A307-674719F71122}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Api", "..\Shared\src\Api\Api.csproj", "{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Client", "..\Shared\src\Client\Client.csproj", "{3BFAC242-776F-4B31-9658-D48F05BF355D}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x64.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.ActiveCfg = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Debug|x86.Build.0 = Debug|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|Any CPU.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x64.Build.0 = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.ActiveCfg = Release|Any CPU
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12}.Release|x86.Build.0 = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|x64.ActiveCfg = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|x64.Build.0 = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|x86.ActiveCfg = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Debug|x86.Build.0 = Debug|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|Any CPU.Build.0 = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|x64.ActiveCfg = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|x64.Build.0 = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|x86.ActiveCfg = Release|Any CPU
		{C49859B4-B34C-4594-A307-674719F71122}.Release|x86.Build.0 = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|x64.ActiveCfg = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|x64.Build.0 = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|x86.ActiveCfg = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Debug|x86.Build.0 = Debug|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|Any CPU.Build.0 = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|x64.ActiveCfg = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|x64.Build.0 = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|x86.ActiveCfg = Release|Any CPU
		{BC4283E1-A6F7-43BF-B0E4-8D91531DD0BE}.Release|x86.Build.0 = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|x64.ActiveCfg = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|x64.Build.0 = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|x86.ActiveCfg = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Debug|x86.Build.0 = Debug|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|Any CPU.Build.0 = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|x64.ActiveCfg = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|x64.Build.0 = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|x86.ActiveCfg = Release|Any CPU
		{3BFAC242-776F-4B31-9658-D48F05BF355D}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{BF5923FF-9E93-4C01-93C2-8CE7A3F62D12} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
		{C49859B4-B34C-4594-A307-674719F71122} = {BD8BA25C-A91D-419D-99B6-B575ADD6D061}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {84D5AF06-1243-46F1-9D58-70ED572832C3}
	EndGlobalSection
EndGlobal


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/Quickstart.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft
 Written by Alexander Higgins https://github.com/alexhiggins732/ 
 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code for this software can be found at https://github.com/alexhiggins732/IdentityServer8

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

*/


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public static class Config
{
    public static IEnumerable IdentityResources =>
        new List
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
        };


    public static IEnumerable ApiScopes =>
        new List
        {
            new ApiScope("api1", "My API")
        };

    public static IEnumerable Clients =>
        new List
        {
            // machine to machine client
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                // scopes that client has access to
                AllowedScopes = { "api1" }
            },
            
            // interactive ASP.NET Core MVC client
            new Client
            {
                ClientId = "mvc",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.Code,
                
                // where to redirect to after login
                RedirectUris = { "https://localhost:5002/signin-oidc" },

                // where to redirect to after logout
                PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                AllowedScopes = new List
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    "api1"
                }
            }
        };
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Data/ApplicationDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Identity.EntityFrameworkCore;

namespace IdentityServerAspNetIdentity.Data
{
    public class ApplicationDbContext : IdentityDbContext
    {
        public ApplicationDbContext(DbContextOptions options)
            : base(options)
        {
        }

        protected override void OnModelCreating(ModelBuilder builder)
        {
            base.OnModelCreating(builder);
            // Customize the ASP.NET Identity model and override the defaults if needed.
            // For example, you can rename the ASP.NET Identity table names and more.
            // Add your customizations after calling base.OnModelCreating(builder);
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Data/Migrations/20180109192453_CreateIdentitySchema.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServerAspNetIdentity.Data.Migrations
{
    [DbContext(typeof(ApplicationDbContext))]
    [Migration("20180109192453_CreateIdentitySchema")]
    partial class CreateIdentitySchema
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");

            modelBuilder.Entity("IdentityServerAspNetIdentity.Models.ApplicationUser", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("AccessFailedCount");

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken();

                    b.Property("Email")
                        .HasMaxLength(256);

                    b.Property("EmailConfirmed");

                    b.Property("LockoutEnabled");

                    b.Property("LockoutEnd");

                    b.Property("NormalizedEmail")
                        .HasMaxLength(256);

                    b.Property("NormalizedUserName")
                        .HasMaxLength(256);

                    b.Property("PasswordHash");

                    b.Property("PhoneNumber");

                    b.Property("PhoneNumberConfirmed");

                    b.Property("SecurityStamp");

                    b.Property("TwoFactorEnabled");

                    b.Property("UserName")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedEmail")
                        .HasName("EmailIndex");

                    b.HasIndex("NormalizedUserName")
                        .IsUnique()
                        .HasName("UserNameIndex");

                    b.ToTable("AspNetUsers");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken();

                    b.Property("Name")
                        .HasMaxLength(256);

                    b.Property("NormalizedName")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedName")
                        .IsUnique()
                        .HasName("RoleNameIndex");

                    b.ToTable("AspNetRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ClaimType");

                    b.Property("ClaimValue");

                    b.Property("RoleId")
                        .IsRequired();

                    b.HasKey("Id");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetRoleClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ClaimType");

                    b.Property("ClaimValue");

                    b.Property("UserId")
                        .IsRequired();

                    b.HasKey("Id");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.Property("LoginProvider");

                    b.Property("ProviderKey");

                    b.Property("ProviderDisplayName");

                    b.Property("UserId")
                        .IsRequired();

                    b.HasKey("LoginProvider", "ProviderKey");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserLogins");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.Property("UserId");

                    b.Property("RoleId");

                    b.HasKey("UserId", "RoleId");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetUserRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.Property("UserId");

                    b.Property("LoginProvider");

                    b.Property("Name");

                    b.Property("Value");

                    b.HasKey("UserId", "LoginProvider", "Name");

                    b.ToTable("AspNetUserTokens");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade);

                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Data/Migrations/20180109192453_CreateIdentitySchema.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore.Migrations;

namespace IdentityServerAspNetIdentity.Data.Migrations
{
    public partial class CreateIdentitySchema : Migration
    {
        protected override void Up(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.CreateTable(
                name: "AspNetRoles",
                columns: table => new
                {
                    Id = table.Column(nullable: false),
                    ConcurrencyStamp = table.Column(nullable: true),
                    Name = table.Column(maxLength: 256, nullable: true),
                    NormalizedName = table.Column(maxLength: 256, nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetRoles", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "AspNetUsers",
                columns: table => new
                {
                    Id = table.Column(nullable: false),
                    AccessFailedCount = table.Column(nullable: false),
                    ConcurrencyStamp = table.Column(nullable: true),
                    Email = table.Column(maxLength: 256, nullable: true),
                    EmailConfirmed = table.Column(nullable: false),
                    LockoutEnabled = table.Column(nullable: false),
                    LockoutEnd = table.Column(nullable: true),
                    NormalizedEmail = table.Column(maxLength: 256, nullable: true),
                    NormalizedUserName = table.Column(maxLength: 256, nullable: true),
                    PasswordHash = table.Column(nullable: true),
                    PhoneNumber = table.Column(nullable: true),
                    PhoneNumberConfirmed = table.Column(nullable: false),
                    SecurityStamp = table.Column(nullable: true),
                    TwoFactorEnabled = table.Column(nullable: false),
                    UserName = table.Column(maxLength: 256, nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetUsers", x => x.Id);
                });

            migrationBuilder.CreateTable(
                name: "AspNetRoleClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("Sqlite:Autoincrement", true),
                    ClaimType = table.Column(nullable: true),
                    ClaimValue = table.Column(nullable: true),
                    RoleId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
                        column: x => x.RoleId,
                        principalTable: "AspNetRoles",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "AspNetUserClaims",
                columns: table => new
                {
                    Id = table.Column(nullable: false)
                        .Annotation("Sqlite:Autoincrement", true),
                    ClaimType = table.Column(nullable: true),
                    ClaimValue = table.Column(nullable: true),
                    UserId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
                    table.ForeignKey(
                        name: "FK_AspNetUserClaims_AspNetUsers_UserId",
                        column: x => x.UserId,
                        principalTable: "AspNetUsers",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "AspNetUserLogins",
                columns: table => new
                {
                    LoginProvider = table.Column(nullable: false),
                    ProviderKey = table.Column(nullable: false),
                    ProviderDisplayName = table.Column(nullable: true),
                    UserId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
                    table.ForeignKey(
                        name: "FK_AspNetUserLogins_AspNetUsers_UserId",
                        column: x => x.UserId,
                        principalTable: "AspNetUsers",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "AspNetUserRoles",
                columns: table => new
                {
                    UserId = table.Column(nullable: false),
                    RoleId = table.Column(nullable: false)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
                    table.ForeignKey(
                        name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
                        column: x => x.RoleId,
                        principalTable: "AspNetRoles",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                    table.ForeignKey(
                        name: "FK_AspNetUserRoles_AspNetUsers_UserId",
                        column: x => x.UserId,
                        principalTable: "AspNetUsers",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateTable(
                name: "AspNetUserTokens",
                columns: table => new
                {
                    UserId = table.Column(nullable: false),
                    LoginProvider = table.Column(nullable: false),
                    Name = table.Column(nullable: false),
                    Value = table.Column(nullable: true)
                },
                constraints: table =>
                {
                    table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
                    table.ForeignKey(
                        name: "FK_AspNetUserTokens_AspNetUsers_UserId",
                        column: x => x.UserId,
                        principalTable: "AspNetUsers",
                        principalColumn: "Id",
                        onDelete: ReferentialAction.Cascade);
                });

            migrationBuilder.CreateIndex(
                name: "IX_AspNetRoleClaims_RoleId",
                table: "AspNetRoleClaims",
                column: "RoleId");

            migrationBuilder.CreateIndex(
                name: "RoleNameIndex",
                table: "AspNetRoles",
                column: "NormalizedName",
                unique: true);

            migrationBuilder.CreateIndex(
                name: "IX_AspNetUserClaims_UserId",
                table: "AspNetUserClaims",
                column: "UserId");

            migrationBuilder.CreateIndex(
                name: "IX_AspNetUserLogins_UserId",
                table: "AspNetUserLogins",
                column: "UserId");

            migrationBuilder.CreateIndex(
                name: "IX_AspNetUserRoles_RoleId",
                table: "AspNetUserRoles",
                column: "RoleId");

            migrationBuilder.CreateIndex(
                name: "EmailIndex",
                table: "AspNetUsers",
                column: "NormalizedEmail");

            migrationBuilder.CreateIndex(
                name: "UserNameIndex",
                table: "AspNetUsers",
                column: "NormalizedUserName",
                unique: true);
        }

        protected override void Down(MigrationBuilder migrationBuilder)
        {
            migrationBuilder.DropTable(
                name: "AspNetRoleClaims");

            migrationBuilder.DropTable(
                name: "AspNetUserClaims");

            migrationBuilder.DropTable(
                name: "AspNetUserLogins");

            migrationBuilder.DropTable(
                name: "AspNetUserRoles");

            migrationBuilder.DropTable(
                name: "AspNetUserTokens");

            migrationBuilder.DropTable(
                name: "AspNetRoles");

            migrationBuilder.DropTable(
                name: "AspNetUsers");
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Data/Migrations/ApplicationDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 
using Microsoft.EntityFrameworkCore.Infrastructure;

namespace IdentityServerAspNetIdentity.Data.Migrations
{
    [DbContext(typeof(ApplicationDbContext))]
    partial class ApplicationDbContextModelSnapshot : ModelSnapshot
    {
        protected override void BuildModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "2.0.1-rtm-125");

            modelBuilder.Entity("IdentityServerAspNetIdentity.Models.ApplicationUser", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("AccessFailedCount");

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken();

                    b.Property("Email")
                        .HasMaxLength(256);

                    b.Property("EmailConfirmed");

                    b.Property("LockoutEnabled");

                    b.Property("LockoutEnd");

                    b.Property("NormalizedEmail")
                        .HasMaxLength(256);

                    b.Property("NormalizedUserName")
                        .HasMaxLength(256);

                    b.Property("PasswordHash");

                    b.Property("PhoneNumber");

                    b.Property("PhoneNumberConfirmed");

                    b.Property("SecurityStamp");

                    b.Property("TwoFactorEnabled");

                    b.Property("UserName")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedEmail")
                        .HasName("EmailIndex");

                    b.HasIndex("NormalizedUserName")
                        .IsUnique()
                        .HasName("UserNameIndex");

                    b.ToTable("AspNetUsers");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken();

                    b.Property("Name")
                        .HasMaxLength(256);

                    b.Property("NormalizedName")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedName")
                        .IsUnique()
                        .HasName("RoleNameIndex");

                    b.ToTable("AspNetRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ClaimType");

                    b.Property("ClaimValue");

                    b.Property("RoleId")
                        .IsRequired();

                    b.HasKey("Id");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetRoleClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd();

                    b.Property("ClaimType");

                    b.Property("ClaimValue");

                    b.Property("UserId")
                        .IsRequired();

                    b.HasKey("Id");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.Property("LoginProvider");

                    b.Property("ProviderKey");

                    b.Property("ProviderDisplayName");

                    b.Property("UserId")
                        .IsRequired();

                    b.HasKey("LoginProvider", "ProviderKey");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserLogins");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.Property("UserId");

                    b.Property("RoleId");

                    b.HasKey("UserId", "RoleId");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetUserRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.Property("UserId");

                    b.Property("LoginProvider");

                    b.Property("Name");

                    b.Property("Value");

                    b.HasKey("UserId", "LoginProvider", "Name");

                    b.ToTable("AspNetUserTokens");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole")
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade);

                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.HasOne("IdentityServerAspNetIdentity.Models.ApplicationUser")
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade);
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerAspNetIdentity;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Options;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.IdentityModel.Tokens;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System;
global using System.ComponentModel.DataAnnotations;
global using System.Linq;
global using System.Security.Claims;
global using System.Text;
global using System.Text.Json;
global using static IdentityModel.JwtClaimTypes;
global using IdentityServerClaimValueTypes = IdentityServer8.IdentityServerConstants.ClaimValueTypes;
global using IdentityServerAspNetIdentity.Data;
global using IdentityServerAspNetIdentity.Models;
global using Microsoft.AspNetCore.Identity;
global using Microsoft.EntityFrameworkCore;
global using Secret = IdentityServer8.Models.Secret;

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/IdentityServerAspNetIdentity.csproj
================================================


  
    
    
    
    
     
    
    


    
    
    
      all
      runtime; build; native; contentfiles; analyzers; buildtransitive
    

    
    
  


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Models/ApplicationUser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Identity;

namespace IdentityServerAspNetIdentity.Models
{
    // Add profile data for application users by adding properties to the ApplicationUser class
    public class ApplicationUser : IdentityUser
    {
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

ConfigureLogger();

try
{
    var builder = WebApplication.CreateBuilder(args.Where(x => x != "/seed").ToArray());

    var services = builder.Services;

    services.AddControllersWithViews();

    services.AddDbContext(options =>
        options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection")));

    services.AddIdentity()
        .AddEntityFrameworkStores()
        .AddDefaultTokenProviders();

    services.AddIdentityServer(options =>
         {
             options.Events.RaiseErrorEvents = true;
             options.Events.RaiseInformationEvents = true;
             options.Events.RaiseFailureEvents = true;
             options.Events.RaiseSuccessEvents = true;

             // see https://IdentityServer8.readthedocs.io/en/latest/topics/resources.html
             options.EmitStaticAudienceClaim = true;
         })
         .AddInMemoryIdentityResources(Config.IdentityResources)
         .AddInMemoryApiScopes(Config.ApiScopes)
         .AddInMemoryClients(Config.Clients)
         .AddAspNetIdentity()
         // not recommended for production - you need to store your key material somewhere secure
         .AddDeveloperSigningCredential();


    services.AddAuthentication()
        .AddGoogle(options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

            // register your IdentityServer with Google at https://console.developers.google.com
            // enable the Google+ API
            // set the redirect URI to https://localhost:5001/signin-google
            options.ClientId = "copy client ID from Google here";
            options.ClientSecret = "copy client secret from Google here";
        });


    using (var app = builder.Build())
    {


        if (args.Contains("/seed"))
        {
            Log.Information("Seeding database...");
            var config = app.Services.GetRequiredService();
            var connectionString = config.GetConnectionString("DefaultConnection");
            SeedData.EnsureSeedData(connectionString);
            Log.Information("Done seeding database.");
            return 0;
        }

        if (app.Environment.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseMigrationsEndPoint();
            app.UseDatabaseErrorPage();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }


        app.UseStaticFiles();

        app.UseRouting();
        app.UseIdentityServer();
        app.UseAuthorization();
        app.MapDefaultControllerRoute();


        Log.Information("Starting host...");

        await app.RunAsync();
    }
    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host terminated unexpectedly.");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}

void ConfigureLogger() => Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
    .Enrich.FromLogContext()
    // uncomment to write to Azure diagnostics stream
    //.WriteTo.File(
    //    @"D:\home\LogFiles\Application\identityserver.txt",
    //    fileSizeLimitBytes: 1_000_000,
    //    rollOnFileSizeLimit: true,
    //    shared: true,
    //    flushToDiskInterval: TimeSpan.FromSeconds(1))
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
    .CreateLogger();


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI
{
    public class AccountOptions
    {
        public static bool AllowLocalLogin = true;
        public static bool AllowRememberLogin = true;
        public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

        public static bool ShowLogoutPrompt = true;
        public static bool AutomaticRedirectAfterSignOut = false;

        public static string InvalidCredentialsErrorMessage = "Invalid username or password";
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonSerializer.Deserialize(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{

    static readonly object UserAddress = new
    {
        street_address = "One Hacker Way",
        locality = "Heidelberg",
        postal_code = 69118,
        country = "Germany"
    };

    public static List Users => new List
    {
        new()
        {
            SubjectId = "818727",
            Username = "alice",
            Password = "alice",
            Claims =
            {
                new (Name, "Alice Smith"),
                new (GivenName, "Alice"),
                new (FamilyName, "Smith"),
                new (Email, "AliceSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://alice.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        },
        new()
        {
            SubjectId = "88421113",
            Username = "bob",
            Password = "bob",
            Claims =
            {
                new (Name, "Bob Smith"),
                new (GivenName, "Bob"),
                new (FamilyName, "Smith"),
                new (Email, "BobSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://bob.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        }
    };
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/SeedData.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerAspNetIdentity
{
    public class SeedData
    {
        public static void EnsureSeedData(string connectionString)
        {
            var services = new ServiceCollection();
            services.AddLogging();
            services.AddDbContext(options =>
               options.UseSqlite(connectionString));

            services.AddIdentity()
                .AddEntityFrameworkStores()
                .AddDefaultTokenProviders();

            using (var serviceProvider = services.BuildServiceProvider())
            {
                using (var scope = serviceProvider.GetRequiredService().CreateScope())
                {
                    var context = scope.ServiceProvider.GetService();
                    context.Database.Migrate();

                    var userMgr = scope.ServiceProvider.GetRequiredService>();
                    var alice = userMgr.FindByNameAsync("alice").Result;
                    if (alice == null)
                    {
                        alice = new ApplicationUser
                        {
                            UserName = "alice",
                            Email = "AliceSmith@email.com",
                            EmailConfirmed = true,
                        };
                        var result = userMgr.CreateAsync(alice, "Pass123$").Result;
                        if (!result.Succeeded)
                        {
                            throw new Exception(result.Errors.First().Description);
                        }

                        result = userMgr.AddClaimsAsync(alice, new Claim[]{
                            new Claim(JwtClaimTypes.Name, "Alice Smith"),
                            new Claim(JwtClaimTypes.GivenName, "Alice"),
                            new Claim(JwtClaimTypes.FamilyName, "Smith"),
                            new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                        }).Result;
                        if (!result.Succeeded)
                        {
                            throw new Exception(result.Errors.First().Description);
                        }
                        Log.Debug("alice created");
                    }
                    else
                    {
                        Log.Debug("alice already exists");
                    }

                    var bob = userMgr.FindByNameAsync("bob").Result;
                    if (bob == null)
                    {
                        bob = new ApplicationUser
                        {
                            UserName = "bob",
                            Email = "BobSmith@email.com",
                            EmailConfirmed = true
                        };
                        var result = userMgr.CreateAsync(bob, "Pass123$").Result;
                        if (!result.Succeeded)
                        {
                            throw new Exception(result.Errors.First().Description);
                        }

                        result = userMgr.AddClaimsAsync(bob, new Claim[]{
                            new Claim(JwtClaimTypes.Name, "Bob Smith"),
                            new Claim(JwtClaimTypes.GivenName, "Bob"),
                            new Claim(JwtClaimTypes.FamilyName, "Smith"),
                            new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                            new Claim("location", "somewhere")
                        }).Result;
                        if (!result.Succeeded)
                        {
                            throw new Exception(result.Errors.First().Description);
                        }
                        Log.Debug("bob created");
                    }
                    else
                    {
                        Log.Debug("bob already exists");
                    }
                }
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/appsettings.json
================================================
{
  "ConnectionStrings": {
    "DefaultConnection": "Data Source=AspIdUsers.db;"
  }
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/updateUI.ps1
================================================
iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/IdentityServer/IdentityServer8.Quickstart.UI.AspNetIdentity/main/getmain.ps1'))	
# SIG # Begin signature block
# MIIfnQYJKoZIhvcNAQcCoIIfjjCCH4oCAQExDzANBglghkgBZQMEAgEFADB5Bgor
# BgEEAYI3AgEEoGswaTA0BgorBgEEAYI3AgEeMCYCAwEAAAQQH8w7YFlLCE63JNLG
# KX7zUQIBAAIBAAIBAAIBAAIBADAxMA0GCWCGSAFlAwQCAQUABCAmjChzA8Tk4hB4
# nAolI/h9hR7E40n+o1koeC4dCBgwCqCCDgcwggPFMIICraADAgECAhACrFwmagtA
# m48LefKuRiV3MA0GCSqGSIb3DQEBBQUAMGwxCzAJBgNVBAYTAlVTMRUwEwYDVQQK
# EwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20xKzApBgNV
# BAMTIkRpZ2lDZXJ0IEhpZ2ggQXNzdXJhbmNlIEVWIFJvb3QgQ0EwHhcNMDYxMTEw
# MDAwMDAwWhcNMzExMTEwMDAwMDAwWjBsMQswCQYDVQQGEwJVUzEVMBMGA1UEChMM
# RGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSswKQYDVQQD
# EyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5jZSBFViBSb290IENBMIIBIjANBgkqhkiG
# 9w0BAQEFAAOCAQ8AMIIBCgKCAQEAxszlc+b71LvlLS0ypt/lgT/JzSVJtnEqw9WU
# NGeiChywX2mmQLHEt7KP0JikqUFZOtPclNY823Q4pErMTSWC90qlUxI47vNJbXGR
# fmO2q6Zfw6SE+E9iUb74xezbOJLjBuUIkQzEKEFV+8taiRV+ceg1v01yCT2+OjhQ
# W3cxG42zxyRFmqesbQAUWgS3uhPrUQqYQUEiTmVhh4FBUKZ5XIneGUpX1S7mXRxT
# LH6YzRoGFqRoc9A0BBNcoXHTWnxV215k4TeHMFYE5RG0KYAS8Xk5iKICEXwnZreI
# t3jyygqoOKsKZMK/Zl2VhMGhJR6HXRpQCyASzEG7bgtROLhLywIDAQABo2MwYTAO
# BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUsT7DaQP4
# v0cB1JgmGggC72NkK8MwHwYDVR0jBBgwFoAUsT7DaQP4v0cB1JgmGggC72NkK8Mw
# DQYJKoZIhvcNAQEFBQADggEBABwaBpfc15yfPIhmBghXIdshR/gqZ6q/GDJ2QBBX
# wYrzetkRZY41+p78RbWe2UwxS7iR6EMsjrN4ztvjU3lx1uUhlAHaVYeaJGT2imbM
# 3pw3zag0sWmbI8ieeCIrcEPjVUcxYRnvWMWFL04w9qAxFiPI5+JlFjPLvxoboD34
# yl6LMYtgCIktDAZcUrfE+QqY0RVfnxK+fDZjOL1EpH/kJisKxJdpDemM4sAQV7jI
# dhKRVfJIadi8KgJbD0TUIDHb9LpwJl2QYJ68SxcJL7TLHkNoyQcnwdJc9+ohuWgS
# nDycv578gFybY83sR6olJ2egN/MAgn1U16n46S4To3foH0owggSRMIIDeaADAgEC
# AhAHsEGNpR4UjDMbvN63E4MjMA0GCSqGSIb3DQEBCwUAMGwxCzAJBgNVBAYTAlVT
# MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
# b20xKzApBgNVBAMTIkRpZ2lDZXJ0IEhpZ2ggQXNzdXJhbmNlIEVWIFJvb3QgQ0Ew
# HhcNMTgwNDI3MTI0MTU5WhcNMjgwNDI3MTI0MTU5WjBaMQswCQYDVQQGEwJVUzEY
# MBYGA1UEChMPLk5FVCBGb3VuZGF0aW9uMTEwLwYDVQQDEyguTkVUIEZvdW5kYXRp
# b24gUHJvamVjdHMgQ29kZSBTaWduaW5nIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC
# AQ8AMIIBCgKCAQEAwQqv4aI0CI20XeYqTTZmyoxsSQgcCBGQnXnufbuDLhAB6GoT
# NB7HuEhNSS8ftV+6yq8GztBzYAJ0lALdBjWypMfL451/84AO5ZiZB3V7MB2uxgWo
# cV1ekDduU9bm1Q48jmR4SVkLItC+oQO/FIA2SBudVZUvYKeCJS5Ri9ibV7La4oo7
# BJChFiP8uR+v3OU33dgm5BBhWmth4oTyq22zCfP3NO6gBWEIPFR5S+KcefUTYmn2
# o7IvhvxzJsMCrNH1bxhwOyMl+DQcdWiVPuJBKDOO/hAKIxBG4i6ryQYBaKdhDgaA
# NSCik0UgZasz8Qgl8n0A73+dISPumD8L/4mdywIDAQABo4IBPzCCATswHQYDVR0O
# BBYEFMtck66Im/5Db1ZQUgJtePys4bFaMB8GA1UdIwQYMBaAFLE+w2kD+L9HAdSY
# JhoIAu9jZCvDMA4GA1UdDwEB/wQEAwIBhjATBgNVHSUEDDAKBggrBgEFBQcDAzAS
# BgNVHRMBAf8ECDAGAQH/AgEAMDQGCCsGAQUFBwEBBCgwJjAkBggrBgEFBQcwAYYY
# aHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEsGA1UdHwREMEIwQKA+oDyGOmh0dHA6
# Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9EaWdpQ2VydEhpZ2hBc3N1cmFuY2VFVlJvb3RD
# QS5jcmwwPQYDVR0gBDYwNDAyBgRVHSAAMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8v
# d3d3LmRpZ2ljZXJ0LmNvbS9DUFMwDQYJKoZIhvcNAQELBQADggEBALNGxKTz6gq6
# clMF01GjC3RmJ/ZAoK1V7rwkqOkY3JDl++v1F4KrFWEzS8MbZsI/p4W31Eketazo
# Nxy23RT0zDsvJrwEC3R+/MRdkB7aTecsYmMeMHgtUrl3xEO3FubnQ0kKEU/HBCTd
# hR14GsQEccQQE6grFVlglrew+FzehWUu3SUQEp9t+iWpX/KfviDWx0H1azilMX15
# lzJUxK7kCzmflrk5jCOCjKqhOdGJoQqstmwP+07qXO18bcCzEC908P+TYkh0z9gV
# rlj7tyW9K9zPVPJZsLRaBp/QjMcH65o9Y1hD1uWtFQYmbEYkT1K9tuXHtQYx1Rpf
# /dC8Nbl4iukwggWlMIIEjaADAgECAhAL5Ofkz0TFYBmonpg7pehYMA0GCSqGSIb3
# DQEBCwUAMFoxCzAJBgNVBAYTAlVTMRgwFgYDVQQKEw8uTkVUIEZvdW5kYXRpb24x
# MTAvBgNVBAMTKC5ORVQgRm91bmRhdGlvbiBQcm9qZWN0cyBDb2RlIFNpZ25pbmcg
# Q0EwHhcNMTgwNjExMDAwMDAwWhcNMjEwNjE1MTIwMDAwWjCBoDEUMBIGA1UEBRML
# NjAzIDM4OSAwNjgxCzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpXYXNoaW5ndG9uMRAw
# DgYDVQQHEwdSZWRtb25kMSkwJwYDVQQKEyBJZGVudGl0eVNlcnZlciAoLk5FVCBG
# b3VuZGF0aW9uKTEpMCcGA1UEAxMgSWRlbnRpdHlTZXJ2ZXIgKC5ORVQgRm91bmRh
# dGlvbikwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCwEhFpSIYi3hrr
# v/X9BtZkzufk7puhmTCVmQAPNm2R1eZZyMPhfxm5Sh/w/42CzlCG9LFgooha69z3
# uoMMOKJEEQKZ6ByIV+r81o4lrHtSFbe4VlXavjQVFaVVjPSG6vWGykfHVCAeVpjx
# fVk/HH6tEX506lBiHgOrQGogoQrwdVnObc3c6RiVSIuvFeCoHvk2GgiqyzFER7iO
# R1055npVSAAAdxBvPA6KREcLb/qHukYCJZX4mY/SajBXwxupSnhRDbYhb+qHpFIL
# x7s/azxg7tVRpVh49oJimHA2uZ/jzh/KgUsUe9MFzT7KPduBK/pfX/fXED9Pt1NN
# 48VfPSuzAgMBAAGjggIeMIICGjAfBgNVHSMEGDAWgBTLXJOuiJv+Q29WUFICbXj8
# rOGxWjAdBgNVHQ4EFgQU3CQnBPLvFkovKU/is0/LgQF/49swNAYDVR0RBC0wK6Ap
# BggrBgEFBQcIA6AdMBsMGVVTLVdBU0hJTkdUT04tNjAzIDM4OSAwNjgwDgYDVR0P
# AQH/BAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMDMIGZBgNVHR8EgZEwgY4wRaBD
# oEGGP2h0dHA6Ly9jcmwzLmRpZ2ljZXJ0LmNvbS9ORVRGb3VuZGF0aW9uUHJvamVj
# dHNDb2RlU2lnbmluZ0NBLmNybDBFoEOgQYY/aHR0cDovL2NybDQuZGlnaWNlcnQu
# Y29tL05FVEZvdW5kYXRpb25Qcm9qZWN0c0NvZGVTaWduaW5nQ0EuY3JsMEwGA1Ud
# IARFMEMwNwYJYIZIAYb9bAMBMCowKAYIKwYBBQUHAgEWHGh0dHBzOi8vd3d3LmRp
# Z2ljZXJ0LmNvbS9DUFMwCAYGZ4EMAQQBMIGEBggrBgEFBQcBAQR4MHYwJAYIKwYB
# BQUHMAGGGGh0dHA6Ly9vY3NwLmRpZ2ljZXJ0LmNvbTBOBggrBgEFBQcwAoZCaHR0
# cDovL2NhY2VydHMuZGlnaWNlcnQuY29tL05FVEZvdW5kYXRpb25Qcm9qZWN0c0Nv
# ZGVTaWduaW5nQ0EuY3J0MAwGA1UdEwEB/wQCMAAwDQYJKoZIhvcNAQELBQADggEB
# AH0FqXX4p5RlC27jX6tcTEf2HT4mAiqosnYU/napWgQE2U9m73IZO+2MuiQWkUQi
# 2PLjbQQcOwfMwkt0SDaSAlfC1zhjZkZb2NcpJRg0cUAjcDzqh6hTzXRVJPD/UrW2
# a5qBhYnSQDSWbYnVwfAQFFvnQcR5i/xnoOxq7+3LIvHoJafpsxcAFS57Vdsuw91u
# keB6uasOfvdd06Mpl9BLWZHpyEdnPIKMv6ALibTdw9lNzCQ+EmdT5Fwky8wHE8BH
# hhAdjSuGiyd+AzR3IuL96Q41h34c7pL827atOHwkkjUx+QTVkXbYoal6wwBKhi6I
# QJEhT0s/yyFFM7BrLhQpRSsxghDsMIIQ6AIBATBuMFoxCzAJBgNVBAYTAlVTMRgw
# FgYDVQQKEw8uTkVUIEZvdW5kYXRpb24xMTAvBgNVBAMTKC5ORVQgRm91bmRhdGlv
# biBQcm9qZWN0cyBDb2RlIFNpZ25pbmcgQ0ECEAvk5+TPRMVgGaiemDul6FgwDQYJ
# YIZIAWUDBAIBBQCggYQwGAYKKwYBBAGCNwIBDDEKMAigAoAAoQKAADAZBgkqhkiG
# 9w0BCQMxDAYKKwYBBAGCNwIBBDAcBgorBgEEAYI3AgELMQ4wDAYKKwYBBAGCNwIB
# FTAvBgkqhkiG9w0BCQQxIgQg3M8y2Uovs3GZZGILEzOaZ5eGje/9PkpzoByKnbYv
# zTYwDQYJKoZIhvcNAQEBBQAEggEAnU9xhSBP/Rv/Cgvmzp0LcG8pjxPlbjvPef7V
# xvkeQzTvMHYg0LiveMH1y94PyfBdxqUAGRuCblBOmlECw24w8Hdv8dY2LQMhqJu8
# Qt08UVYtiJQBHwclFmnK8ER8g/Wc5LPsuvzoYzTvvr/FS2wSCaMV7p2WHIwjJxXR
# sLaccoU2fuPbmE1WVPsjy3ttzkmfyhbl3Mc2QXiLNTQJ+gSNBg2s2eSzf7eDcM2Z
# kysuAEdu4kKhSsHOhkkpBHffplg9pYrehbUq8QJ+T/9e0vHPbbP5xIPaRqvBEMWy
# ydh0LWvK6GnJ+/yPHjddtrjpY4ncTlK5ii+wyzyZc9k4rryOKaGCDsgwgg7EBgor
# BgEEAYI3AwMBMYIOtDCCDrAGCSqGSIb3DQEHAqCCDqEwgg6dAgEDMQ8wDQYJYIZI
# AWUDBAIBBQAwdwYLKoZIhvcNAQkQAQSgaARmMGQCAQEGCWCGSAGG/WwHATAxMA0G
# CWCGSAFlAwQCAQUABCDIQfwOJSjewgHOlovqbOQetKuLbiiSjibgzLTQTnzqLAIQ
# BSEyueNQrxAikpAH0FblzhgPMjAyMDA2MjUxNDI4NTNaoIILuzCCBoIwggVqoAMC
# AQICEATNP4VornbGG7D+cWDMp20wDQYJKoZIhvcNAQELBQAwcjELMAkGA1UEBhMC
# VVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3LmRpZ2ljZXJ0
# LmNvbTExMC8GA1UEAxMoRGlnaUNlcnQgU0hBMiBBc3N1cmVkIElEIFRpbWVzdGFt
# cGluZyBDQTAeFw0xOTEwMDEwMDAwMDBaFw0zMDEwMTcwMDAwMDBaMEwxCzAJBgNV
# BAYTAlVTMRcwFQYDVQQKEw5EaWdpQ2VydCwgSW5jLjEkMCIGA1UEAxMbVElNRVNU
# QU1QLVNIQTI1Ni0yMDE5LTEwLTE1MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB
# CgKCAQEA6WQ1nPqpmGVkG+QX3LgpNsxnCViFTTDgyf/lOzwRKFCvBzHiXQkYwvaJ
# jGkIBCPgdy2dFeW46KFqjv/UrtJ6Fu/4QbUdOXXBzy+nrEV+lG2sAwGZPGI+fnr9
# RZcxtPq32UI+p1Wb31pPWAKoMmkiE76Lgi3GmKtrm7TJ8mURDHQNsvAIlnTE6LJI
# oqEUpfj64YlwRDuN7/uk9MO5vRQs6wwoJyWAqxBLFhJgC2kijE7NxtWyZVkh4Hws
# Eo1wDo+KyuDT17M5d1DQQiwues6cZ3o4d1RA/0+VBCDU68jOhxQI/h2A3dDnK3jq
# vx9wxu5CFlM2RZtTGUlinXoCm5UUowIDAQABo4IDODCCAzQwDgYDVR0PAQH/BAQD
# AgeAMAwGA1UdEwEB/wQCMAAwFgYDVR0lAQH/BAwwCgYIKwYBBQUHAwgwggG/BgNV
# HSAEggG2MIIBsjCCAaEGCWCGSAGG/WwHATCCAZIwKAYIKwYBBQUHAgEWHGh0dHBz
# Oi8vd3d3LmRpZ2ljZXJ0LmNvbS9DUFMwggFkBggrBgEFBQcCAjCCAVYeggFSAEEA
# bgB5ACAAdQBzAGUAIABvAGYAIAB0AGgAaQBzACAAQwBlAHIAdABpAGYAaQBjAGEA
# dABlACAAYwBvAG4AcwB0AGkAdAB1AHQAZQBzACAAYQBjAGMAZQBwAHQAYQBuAGMA
# ZQAgAG8AZgAgAHQAaABlACAARABpAGcAaQBDAGUAcgB0ACAAQwBQAC8AQwBQAFMA
# IABhAG4AZAAgAHQAaABlACAAUgBlAGwAeQBpAG4AZwAgAFAAYQByAHQAeQAgAEEA
# ZwByAGUAZQBtAGUAbgB0ACAAdwBoAGkAYwBoACAAbABpAG0AaQB0ACAAbABpAGEA
# YgBpAGwAaQB0AHkAIABhAG4AZAAgAGEAcgBlACAAaQBuAGMAbwByAHAAbwByAGEA
# dABlAGQAIABoAGUAcgBlAGkAbgAgAGIAeQAgAHIAZQBmAGUAcgBlAG4AYwBlAC4w
# CwYJYIZIAYb9bAMVMB8GA1UdIwQYMBaAFPS24SAd/imu0uRhpbKiJbLIFzVuMB0G
# A1UdDgQWBBRWUw/BxgenTdfYbldygFBM5OyewTBxBgNVHR8EajBoMDKgMKAuhixo
# dHRwOi8vY3JsMy5kaWdpY2VydC5jb20vc2hhMi1hc3N1cmVkLXRzLmNybDAyoDCg
# LoYsaHR0cDovL2NybDQuZGlnaWNlcnQuY29tL3NoYTItYXNzdXJlZC10cy5jcmww
# gYUGCCsGAQUFBwEBBHkwdzAkBggrBgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNl
# cnQuY29tME8GCCsGAQUFBzAChkNodHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20v
# RGlnaUNlcnRTSEEyQXNzdXJlZElEVGltZXN0YW1waW5nQ0EuY3J0MA0GCSqGSIb3
# DQEBCwUAA4IBAQAug6FEBUoE47kyUvrZgfAau/gJjSO5PdiSoeZGHEovbno8Y243
# F6Mav1gjskOclINOOQmwLOjH4eLM7ct5a87eIwFH7ZVUgeCAexKxrwKGqTpzav74
# n8GN0SGM5CmCw4oLYAACnR9HxJ+0CmhTf1oQpvgi5vhTkjFf2IKDLW0TQq6DwRBO
# pCT0R5zeDyJyd1x/T+k5mCtXkkTX726T2UPHBDNjUTdWnkcEEcOjWFQh2OKOVtdJ
# P1f8Cp8jXnv0lI3dnRq733oqptJFplUMj/ZMivKWz4lG3DGykZCjXzMwYFX1/Gsw
# rKHt5EdOM55naii1TcLtW5eC+MupCGxTCbT3MIIFMTCCBBmgAwIBAgIQCqEl1tYy
# G35B5AXaNpfCFTANBgkqhkiG9w0BAQsFADBlMQswCQYDVQQGEwJVUzEVMBMGA1UE
# ChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSQwIgYD
# VQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwHhcNMTYwMTA3MTIwMDAw
# WhcNMzEwMTA3MTIwMDAwWjByMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNl
# cnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMTEwLwYDVQQDEyhEaWdp
# Q2VydCBTSEEyIEFzc3VyZWQgSUQgVGltZXN0YW1waW5nIENBMIIBIjANBgkqhkiG
# 9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvdAy7kvNj3/dqbqCmcU5VChXtiNKxA4HRTNR
# EH3Q+X1NaH7ntqD0jbOI5Je/YyGQmL8TvFfTw+F+CNZqFAA49y4eO+7MpvYyWf5f
# ZT/gm+vjRkcGGlV+Cyd+wKL1oODeIj8O/36V+/OjuiI+GKwR5PCZA207hXwJ0+5d
# yJoLVOOoCXFr4M8iEA91z3FyTgqt30A6XLdR4aF5FMZNJCMwXbzsPGBqrC8HzP3w
# 6kfZiFBe/WZuVmEnKYmEUeaC50ZQ/ZQqLKfkdT66mA+Ef58xFNat1fJky3seBdCE
# GXIX8RcG7z3N1k3vBkL9olMqT4UdxB08r8/arBD13ays6Vb/kwIDAQABo4IBzjCC
# AcowHQYDVR0OBBYEFPS24SAd/imu0uRhpbKiJbLIFzVuMB8GA1UdIwQYMBaAFEXr
# oq/0ksuCMS1Ri6enIZ3zbcgPMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/
# BAQDAgGGMBMGA1UdJQQMMAoGCCsGAQUFBwMIMHkGCCsGAQUFBwEBBG0wazAkBggr
# BgEFBQcwAYYYaHR0cDovL29jc3AuZGlnaWNlcnQuY29tMEMGCCsGAQUFBzAChjdo
# dHRwOi8vY2FjZXJ0cy5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURSb290
# Q0EuY3J0MIGBBgNVHR8EejB4MDqgOKA2hjRodHRwOi8vY3JsNC5kaWdpY2VydC5j
# b20vRGlnaUNlcnRBc3N1cmVkSURSb290Q0EuY3JsMDqgOKA2hjRodHRwOi8vY3Js
# My5kaWdpY2VydC5jb20vRGlnaUNlcnRBc3N1cmVkSURSb290Q0EuY3JsMFAGA1Ud
# IARJMEcwOAYKYIZIAYb9bAACBDAqMCgGCCsGAQUFBwIBFhxodHRwczovL3d3dy5k
# aWdpY2VydC5jb20vQ1BTMAsGCWCGSAGG/WwHATANBgkqhkiG9w0BAQsFAAOCAQEA
# cZUS6VGHVmnN793afKpjerN4zwY3QITvS4S/ys8DAv3Fp8MOIEIsr3fzKx8MIVoq
# twU0HWqumfgnoma/Capg33akOpMP+LLR2HwZYuhegiUexLoceywh4tZbLBQ1QwRo
# stt1AuByx5jWPGTlH0gQGF+JOGFNYkYkh2OMkVIsrymJ5Xgf1gsUpYDXEkdws3XV
# k4WTfraSZ/tTYYmo9WuWwPRYaQ18yAGxuSh1t5ljhSKMYcp5lH5Z/IwP42+1ASa2
# bKXuh1Eh5Fhgm7oMLSttosR+u8QlK0cCCHxJrhO24XxCQijGGFbPQTS2Zl22dHv1
# VjMiLyI2skuiSpXY9aaOUjGCAk0wggJJAgEBMIGGMHIxCzAJBgNVBAYTAlVTMRUw
# EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x
# MTAvBgNVBAMTKERpZ2lDZXJ0IFNIQTIgQXNzdXJlZCBJRCBUaW1lc3RhbXBpbmcg
# Q0ECEATNP4VornbGG7D+cWDMp20wDQYJYIZIAWUDBAIBBQCggZgwGgYJKoZIhvcN
# AQkDMQ0GCyqGSIb3DQEJEAEEMBwGCSqGSIb3DQEJBTEPFw0yMDA2MjUxNDI4NTNa
# MCsGCyqGSIb3DQEJEAIMMRwwGjAYMBYEFAMlvVBe2pYwLcIvT6AeTCi+KDTFMC8G
# CSqGSIb3DQEJBDEiBCAvoc+rYs7skpQOtoc7TrhDopI+gY0L5n1xBAzyBSyC8TAN
# BgkqhkiG9w0BAQEFAASCAQCRIBcC0oeOOjuPQ2x9QeqG+lmZXas8Y2P9oaXzmbFS
# 6okl0cflVVL3m9EvPJ3ofob8aQ9PRmyJRIaDP24R8GGS9m8ZTLZJvg8wPOtoE/3t
# mLfPaY1KFSqtKWF8sLSHkWJzF50FvboB00E4f1mRDBCAZPNfyKSBYiW7b60Blcnz
# mf721nSHxPPbGtoU4ObXcR4qHyWbrlIMcihIkkwf8HEU3MqqsLSnpGoKeNvS/quz
# N2mp2eJl9YezOn+yzSkDKSQKg5x+2ZI/2UCstJaq73ahuRSpcdw3Lu6FgWs7n8Wc
# N6gU/Mpvb3GqgwZWpbSoa9PusWSNLjOyrWAwjhdeBCvV
# SIG # End signature block


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/wwwroot/js/signin-redirect.js
================================================
// window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/IdentityServerAspNetIdentity/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/MvcClient.csproj
================================================


  
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/6_AspNetIdentity/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/Quickstarts/Directory.Build.props
================================================

  
	 
  


================================================
FILE: samples/Quickstarts/Quickstart.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft
 Written by Alexander Higgins https://github.com/alexhiggins732/ 
 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code for this software can be found at https://github.com/alexhiggins732/IdentityServer8

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.

*/


================================================
FILE: samples/Quickstarts/Shared/src/Api/Api.csproj
================================================



================================================
FILE: samples/Quickstarts/Shared/src/Api/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Mvc;

Console.Title = "API";

var builder = WebApplication.CreateBuilder(args);

var services = builder.Services;

// accepts any access token issued by identity server
// adds an authorization policy for scope 'api1'
services
    .AddAuthorization(options =>
    {
        options.AddPolicy("ApiScope", policy =>
        {
            policy
                .RequireAuthenticatedUser()
                .RequireClaim("scope", "api1");
        });
    })
    .AddCors(options =>
    {
        // this defines a CORS policy called "default"
        options.AddPolicy("default", policy =>
        {
            policy.WithOrigins("https://localhost:5003")
                .AllowAnyHeader()
                .AllowAnyMethod();
        });
    })
    .AddControllers();

// accepts any access token issued by identity server
services
    .AddAuthentication("Bearer")
    .AddJwtBearer("Bearer", options =>
    {
        options.Authority = "https://localhost:5001";
        options.TokenValidationParameters =
            new() { ValidateAudience = false };
    });



using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();

    app
        .UseRouting()
        .UseAuthentication()
        .UseAuthorization()
        .UseCors("default");

    app.MapGet("/identity", (HttpContext context) =>
            new JsonResult(context?.User?.Claims.Select(c => new { c.Type, c.Value }))
        ).RequireAuthorization("ApiScope");

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/Shared/src/Api/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:6001"
    }
  }
}

================================================
FILE: samples/Quickstarts/Shared/src/Client/Client.csproj
================================================


  
    Exe
  

  
    
  




================================================
FILE: samples/Quickstarts/Shared/src/Client/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityModel.Client;
using System.Diagnostics;
using System.Text.Json;

// discover endpoints from metadata
using HttpClient client = new();

var disco = await client.GetDiscoveryDocumentAsync("https://localhost:5001");
if (disco.IsError)
    Exit(disco.Error);

// request token
var tokenResponse = await client.RequestClientCredentialsTokenAsync(
    new()
{
    Address = disco.TokenEndpoint,
    ClientId = "client",
    ClientSecret = "secret",

    Scope = "api1"
});

if (tokenResponse.IsError)
    Exit(tokenResponse.Error);

Console.WriteLine(tokenResponse.Json);
Console.WriteLine("\n\n");

// call api
client.SetBearerToken(tokenResponse.AccessToken);

var response = await client.GetAsync("https://localhost:6001/identity");
if (!response.IsSuccessStatusCode)
    Console.WriteLine(response.StatusCode);
else
{
    var responseJson = await response.Content.ReadAsStringAsync();
    var obj = JsonSerializer.Deserialize(responseJson);
    Console.WriteLine(obj);
}

Exit("Done!", 0);

void Exit(string message, int exitCode = 1)
{
    Console.WriteLine(message);
    if (Debugger.IsAttached)
        Debugger.Break();
    Environment.Exit(exitCode);
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public static class Config
{
    public static IEnumerable IdentityResources =>
        new List
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
        };


    public static IEnumerable ApiScopes =>
        new List
        {
            new ApiScope("api1", "My API")
        };

    public static IEnumerable Clients =>
        new List
        {
            // machine to machine client
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                // scopes that client has access to
                AllowedScopes = { "api1" }
            },
            
            // interactive ASP.NET Core MVC client
            new Client
            {
                ClientId = "mvc",
                ClientSecrets = { new Secret("secret".Sha256()) },

                AllowedGrantTypes = GrantTypes.Code,
                
                // where to redirect to after login
                RedirectUris = { "https://localhost:5002/signin-oidc" },

                // where to redirect to after logout
                PostLogoutRedirectUris = { "https://localhost:5002/signout-callback-oidc" },

                AllowedScopes = new List
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    "api1"
                }
            }
        };
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Options;
global using Microsoft.IdentityModel.Tokens;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System;
global using System.ComponentModel.DataAnnotations;
global using System.Security.Claims;
global using System.Text;
global using System.Text.Json;
global using static IdentityModel.JwtClaimTypes;
global using IdentityServerClaimValueTypes = IdentityServer8.IdentityServerConstants.ClaimValueTypes;
global using ILogger = Microsoft.Extensions.Logging.ILogger;


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/IdentityServer.csproj
================================================

  
    
    
      
    
  



================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

ConfigureLogger();

try
{
    Log.Information("Starting host...");

    var builder = WebApplication.CreateBuilder(args);

    var services = builder.Services;

    services.AddControllersWithViews();

    services
        .AddIdentityServer()
        .AddInMemoryIdentityResources(Config.IdentityResources)
        .AddInMemoryApiScopes(Config.ApiScopes)
        .AddInMemoryClients(Config.Clients)
        .AddTestUsers(TestUsers.Users)
        .AddDeveloperSigningCredential();

    services.AddAuthentication()
        .AddGoogle("Google", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;

            options.ClientId = "";
            options.ClientSecret = "";
        })
        .AddOpenIdConnect("oidc", "Demo IdentityServer", options =>
        {
            options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
            options.SignOutScheme = IdentityServerConstants.SignoutScheme;
            options.SaveTokens = true;

            options.Authority = "https://demo.identityserver8.io/";
            options.ClientId = "interactive.confidential";
            options.ClientSecret = "secret";
            options.ResponseType = "code";

            options.TokenValidationParameters = new()
            {
                NameClaimType = "name",
                RoleClaimType = "role"
            };
        });


    using (var app = builder.Build())
    {
        if (app.Environment.IsDevelopment())
            app.UseDeveloperExceptionPage();

        app.UseStaticFiles()
            .UseRouting()
            .UseIdentityServer()
            .UseAuthorization();

        app.MapDefaultControllerRoute();

        await app.RunAsync();
    }

    return 0;
}
catch (Exception ex)
{
    Log.Fatal(ex, "Host terminated unexpectedly.");
    return 1;
}
finally
{
    Log.CloseAndFlush();
}


void ConfigureLogger() => Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Debug()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
    .MinimumLevel.Override("System", LogEventLevel.Warning)
    .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
    .Enrich.FromLogContext()
    // uncomment to write to Azure diagnostics stream
    //.WriteTo.File(
    //    @"D:\home\LogFiles\Application\identityserver.txt",
    //    fileSizeLimitBytes: 1_000_000,
    //    rollOnFileSizeLimit: true,
    //    shared: true,
    //    flushToDiskInterval: TimeSpan.FromSeconds(1))
    .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
    .CreateLogger();


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Properties/launchSettings.json
================================================
{
  "profiles": {
    "SelfHost": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI
{
    public class AccountOptions
    {
        public static bool AllowLocalLogin = true;
        public static bool AllowRememberLogin = true;
        public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

        public static bool ShowLogoutPrompt = true;
        public static bool AutomaticRedirectAfterSignOut = false;

        public static string InvalidCredentialsErrorMessage = "Invalid username or password";
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonSerializer.Deserialize(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{

    static readonly object UserAddress = new
    {
        street_address = "One Hacker Way",
        locality = "Heidelberg",
        postal_code = 69118,
        country = "Germany"
    };

    public static List Users => new List
    {
        new()
        {
            SubjectId = "818727",
            Username = "alice",
            Password = "alice",
            Claims =
            {
                new (Name, "Alice Smith"),
                new (GivenName, "Alice"),
                new (FamilyName, "Smith"),
                new (Email, "AliceSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://alice.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        },
        new()
        {
            SubjectId = "88421113",
            Username = "bob",
            Password = "bob",
            Claims =
            {
                new (Name, "Bob Smith"),
                new (GivenName, "Bob"),
                new (FamilyName, "Smith"),
                new (Email, "BobSmith@email.com"),
                new (EmailVerified, "true", ClaimValueTypes.Boolean),
                new (WebSite, "http://bob.com"),
                new (Address, JsonSerializer.Serialize(UserAddress), IdentityServerClaimValueTypes.Json)
            }
        }
    };
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    






================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: samples/Quickstarts/Shared/src/IdentityServer/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Controllers/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class HomeController : Controller
{
    private readonly ILogger _logger;

    public HomeController(ILogger logger)
    {
        _logger = logger;
    }

    public IActionResult Index()
    {
        return View();
    }

    public async Task CallApi()
    {
        var accessToken = await HttpContext.GetTokenAsync("access_token");

        var client = new HttpClient();
        client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        var content = await client.GetStringAsync("https://localhost:6001/identity");

        var obj = JsonSerializer.Deserialize(content);
        ViewBag.Json = obj.ToString();
        return View("json");
    }

    public IActionResult Logout()
    {
        return SignOut("Cookies", "oidc");
    }

    [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
    public IActionResult Error()
    {
        return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
    }
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Mvc;
global using System.Diagnostics;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net.Http.Headers;
global using System.Text.Json;


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Models/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

public class ErrorViewModel
{
    public string RequestId { get; set; }

    public bool ShowRequestId => !string.IsNullOrEmpty(RequestId);
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/MvcClient.csproj
================================================


  
    
    
  

  
    
      true
      PreserveNewest
    
  



================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

JwtSecurityTokenHandler.DefaultMapInboundClaims = false;


var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services
    .AddAuthentication(options =>
    {
        options.DefaultScheme = "Cookies";
        options.DefaultChallengeScheme = "oidc";
    })
    .AddCookie("Cookies")
    .AddOpenIdConnect("oidc", options =>
    {
        options.Authority = "https://localhost:5001";

        options.ClientId = "mvc";
        options.ClientSecret = "secret";
        options.ResponseType = "code";

        options.Scope.Add("api1");

        options.SaveTokens = true;
    });


using (var app = builder.Build())
{
    if (app.Environment.IsDevelopment())
        app.UseDeveloperExceptionPage();
    else
        app.UseExceptionHandler("/Home/Error");

    app.UseStaticFiles();
    app.UseRouting();
    app.UseAuthentication();
    app.UseAuthorization();
    app.MapDefaultControllerRoute().RequireAuthorization();

    await app.RunAsync();
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Properties/launchSettings.json
================================================
{
  "profiles": {
    "MvcClient": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5002"
    }
  }
}

================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Home/Index.cshtml
================================================
@using Microsoft.AspNetCore.Authentication


    Claims
    


    
    @foreach (var claim in User.Claims)
    {
        
    @claim.Type
    
        
    @claim.Value
    
    }

    


    Properties
    


    
    @foreach (var prop in (await Context.AuthenticateAsync()).Properties.Items)
    {
        
    @prop.Key
    
        
    @prop.Value
    
    }

    

================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Home/Privacy.cshtml
================================================
@{
    ViewData["Title"] = "Privacy Policy";
}

    @ViewData["Title"]
    


    Use this page to detail your site's privacy policy.
    


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel
@{
    ViewData["Title"] = "Error";
}


    Error.
    

    An error occurred while processing your request.
    

@if (Model.ShowRequestId)
{
    
    
        Request ID: @Model.RequestId
    
    
}


    Development Mode
    

    
    Swapping to Development environment will display more 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.

    


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Shared/_Layout.cshtml
================================================



    
    
    @ViewData["Title"] - MvcClient
    
    


    
    
        
    
    
    
    
        
    
            @RenderBody()
        
    
    
    

    
    
    
    @RenderSection("Scripts", required: false)




================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Shared/_ValidationScriptsPartial.cshtml
================================================




================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/Shared/json.cshtml
================================================

    @ViewBag.Json
    

================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/_ViewImports.cshtml
================================================
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/appsettings.Development.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Information"
    }
  }
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/appsettings.json
================================================
{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*"
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/wwwroot/css/site.css
================================================
/* Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
for details on configuring this project to bundle and minify static web assets. */

a.navbar-brand {
  white-space: normal;
  text-align: center;
  word-break: break-all;
}

/* Provide sufficient contrast against white background */
a {
  color: #0366d6;
}

.btn-primary {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

.nav-pills .nav-link.active, .nav-pills .show > .nav-link {
  color: #fff;
  background-color: #1b6ec2;
  border-color: #1861ac;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  font-size: 14px;
}
@media (min-width: 768px) {
  html {
    font-size: 16px;
  }
}

.border-top {
  border-top: 1px solid #e5e5e5;
}
.border-bottom {
  border-bottom: 1px solid #e5e5e5;
}

.box-shadow {
  box-shadow: 0 .25rem .75rem rgba(0, 0, 0, .05);
}

button.accept-policy {
  font-size: 1rem;
  line-height: inherit;
}

/* Sticky footer styles
-------------------------------------------------- */
html {
  position: relative;
  min-height: 100%;
}

body {
  /* Margin bottom by footer height */
  margin-bottom: 60px;
}
.footer {
  position: absolute;
  bottom: 0;
  width: 100%;
  white-space: nowrap;
  line-height: 60px; /* Vertically center the text there */
}


================================================
FILE: samples/Quickstarts/Shared/src/MvcClient/wwwroot/js/site.js
================================================
// Please see documentation at https://docs.microsoft.com/aspnet/core/client-side/bundling-and-minification
// for details on configuring this project to bundle and minify static web assets.

// Write your JavaScript code.


================================================
FILE: samples/SamplesGlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityModel.Client;
global using Serilog;
global using System.Diagnostics;
global using System.Text;
global using System.Text.Json;


global using IdentityModel.OidcClient;
global using IdentityModel.OidcClient.Browser;
global using IdentityModel.AspNetCore.AccessTokenValidation;


global using Microsoft.AspNetCore.Builder;
global using Microsoft.AspNetCore.DataProtection;
global using Microsoft.AspNetCore.Hosting;
global using Microsoft.AspNetCore.Http;
global using Microsoft.Extensions.DependencyInjection;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;

global using System.Net;
global using System.Net.Sockets;
global using System.Runtime.InteropServices;
global using System.Security.Cryptography.X509Certificates;


global using ILogger = Microsoft.Extensions.Logging.ILogger;

global using Microsoft.IdentityModel.Tokens;
global using System.IdentityModel.Tokens.Jwt;
global using System.Security.Claims;
global using System.Runtime.Versioning;

================================================
FILE: src/AspNetIdentity/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/AspNetIdentity/IdentityServer8.AspNetIdentity.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.26228.9
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{932FA9D0-7FB4-4047-8FFD-B74907B5FA15}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.AspNetIdentity", "src\IdentityServer8.AspNetIdentity.csproj", "{A2CDBE15-5898-4A04-94DC-133EE03A78B3}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "host\Host.csproj", "{B7FBA07C-A462-4869-AF94-5E36DFC3742D}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "migrations", "migrations", "{4BC142B6-4922-4203-82A2-F28CB6AC5004}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "migrations\SqlServer\SqlServer.csproj", "{DD44B9E9-C32E-4F89-92C9-25444A709BBB}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Release|Any CPU.Build.0 = Release|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Release|Any CPU.Build.0 = Release|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3} = {932FA9D0-7FB4-4047-8FFD-B74907B5FA15}
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D} = {932FA9D0-7FB4-4047-8FFD-B74907B5FA15}
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB} = {4BC142B6-4922-4203-82A2-F28CB6AC5004}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {03AF716A-120B-409D-B384-B65E7FDEFEEF}
	EndGlobalSection
EndGlobal


================================================
FILE: src/AspNetIdentity/README.md
================================================
# IdentityServer8.AspNetIdentity

ASP.NET Core Identity integration support for IdentityServer8.

You can find a detailed walk-through for ASP.NET Core Identity integration [here](https://IdentityServer8.readthedocs.io/en/latest/quickstarts/6_aspnet_identity.html).

## Issues

For issues, use the [consolidated IdentityServer8 issue tracker](https://github.com/alexhiggins732/IdentityServer8/issues).


================================================
FILE: src/AspNetIdentity/build.cmd
================================================
@echo off
dotnet run --project build -- %*

================================================
FILE: src/AspNetIdentity/build.ps1
================================================
$ErrorActionPreference = "Stop";
dotnet run --project build -- $args

================================================
FILE: src/AspNetIdentity/build.sh
================================================
#!/usr/bin/env bash
set -euo pipefail
dotnet run --project build -- "$@"

================================================
FILE: src/AspNetIdentity/host/Configuration/Clients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class Clients
{
    public static IEnumerable Get()
    {
        var clients = new List();
        
        clients.AddRange(ClientsConsole.Get());
        clients.AddRange(ClientsWeb.Get());

        return clients;
    }
}


================================================
FILE: src/AspNetIdentity/host/Configuration/ClientsConsole.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class ClientsConsole
{
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////////////////////////
            // Console-based Client
            ///////////////////////////////////////////////////////////////


            ///////////////////////////////////////////
            // Console Client Credentials Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1", IdentityServerConstants.LocalApi.ScopeName}
            },
            
            ///////////////////////////////////////////
            // Console Structured Scope Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "parameterized.client",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "transaction" }
            },

            ///////////////////////////////////////////
            // X509 mTLS Client
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mtls",
                ClientSecrets =
                {
                    // new Secret(@"CN=mtls.test, OU=ROO\ballen@roo, O=mkcert development certificate", "mtls.test")
                    // {
                    //     Type = SecretTypes.X509CertificateName
                    // },
                    new Secret("5D9E9B6B333CD42C99D1DE6175CC0F3EF99DDF68", "mtls.test")
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateThumbprint
                    },
                },
                
                AccessTokenType = AccessTokenType.Jwt,
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Client Credentials Flow with client JWT assertion
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.jwt",
                ClientSecrets =
                {
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value =
                            "MIIEgTCCAumgAwIBAgIQDMMu7l/umJhfEbzJMpcttzANBgkqhkiG9w0BAQsFADCBkzEeMBwGA1UEChMVbWtjZXJ0IGRldmVsb3BtZW50IENBMTQwMgYDVQQLDCtkb21pbmlja0Bkb21icDE2LmZyaXR6LmJveCAoRG9taW5pY2sgQmFpZXIpMTswOQYDVQQDDDJta2NlcnQgZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTAeFw0xOTA2MDEwMDAwMDBaFw0zMDAxMDMxMjM0MDdaMHAxJzAlBgNVBAoTHm1rY2VydCBkZXZlbG9wbWVudCBjZXJ0aWZpY2F0ZTE0MDIGA1UECwwrZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTEPMA0GA1UEAxMGY2xpZW50MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvNtpipaS8k1zA6w0Aoy8U4l+8zM4jHhhblExf3PULrMR6RauxniTki8p+P8CsZT4V8A4qo+JwsgpLIHrVQrbt9DEhHfBKzxwHqt+GoHt7byTfTtp8A/5nLhYc/5CW4HiR194gVx5+HAlvt+BriMTb1czvTf+H20dj41yUPsN7nMdyRLF+uXapQYMLYnq2BJIDq83mqGwojHk7d+N6GwoO95jlyas7KSoj8/FvfbaqkRNx0446hqPOzFHKc8er8K5VrLp6tVjh8ZJyY0F0dKgx6yWITsL54ctbj/cCyfuGjWEMbS2XXgc+x/xQMnmpfhK1qQAUn9jg5EzF9n6mQomOwIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEMUlw41YsKZQVls3pEG6CrJk4O8wEQYDVR0RBAowCIIGY2xpZW50MA0GCSqGSIb3DQEBCwUAA4IBgQC0TjNY4Q3Wmw7ggamDImV6HUng3WbYGLYbbL2e3myBrjIxGd1Bi8ZyOu8qeUMIRAbZt2YsSX5S8kx0biaVg2zC+aO5eHhEWMwKB66huInXFjI4wtxZ22r+33fg1R0cLuEUePhftOWrbL0MS4YXVyn9HUMWO4WptG9PJdxNw1UbEB8nw3FkVOdAC9RGqiqalSK+E2UT/kUbTIQ1gPSdQ3nh52mre0H/T9+IRqiozJtNK/CQg4NuEV7rUXHnp7Fmigp6RIJ4TCozglspL341y0rV8M7npU1FYZC2UKNr4ed+GOO1n/sF3LbXDlPXwne99CVVn85wjDaevoR7Md0y2KwE9EggLYcViXNehx4YVv/BjfgqxW8NxiKAxP6kPOZE0XdBrZj2rmcDcGOXCzzYpcduKhFyTOpA0K5RNGC3j1KOUjPVlOtLvjASP7udBEYNfH3mgqXAgqNDOEKi2jG9LITv2IyGUsXhTAsKNJ6A6qiDBzDrvPAYDvsfabPq6tRTwjA="
                    },
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value =
                            "{'e':'AQAB','kid':'ZzAjSnraU3bkWGnnAqLapYGpTyNfLbjbzgAPbbW2GEA','kty':'RSA','n':'wWwQFtSzeRjjerpEM5Rmqz_DsNaZ9S1Bw6UbZkDLowuuTCjBWUax0vBMMxdy6XjEEK4Oq9lKMvx9JzjmeJf1knoqSNrox3Ka0rnxXpNAz6sATvme8p9mTXyp0cX4lF4U2J54xa2_S9NF5QWvpXvBeC4GAJx7QaSw4zrUkrc6XyaAiFnLhQEwKJCwUw4NOqIuYvYp_IXhw-5Ti_icDlZS-282PcccnBeOcX7vc21pozibIdmZJKqXNsL1Ibx5Nkx1F1jLnekJAmdaACDjYRLL_6n3W4wUp19UvzB1lGtXcJKLLkqB6YDiZNu16OSiSprfmrRXvYmvD8m6Fnl5aetgKw'}"
                    }
                },
                
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Custom Grant Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.custom",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = {"custom", "custom.nosubject"},
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    "custom.profile",
                    "resource1.scope1", "resource2.scope1"
                }
            },

            ///////////////////////////////////////////
            // Console Public Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.public",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },

            ///////////////////////////////////////////
            // Console with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "console.pkce",
                ClientName = "Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = {"http://127.0.0.1"},
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },
            ///////////////////////////////////////////
            // WinConsole with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "winconsole",
                ClientName = "Windows Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = {"sample-windows-client://callback"},
                RequireConsent = false,
                AllowOfflineAccess = true,
                AllowedIdentityTokenSigningAlgorithms = {"ES256"},
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },


            ///////////////////////////////////////////
            // Introspection Client Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.reference",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" },
                AccessTokenType = AccessTokenType.Reference
            },
            
            ///////////////////////////////////////////
            // Device Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "device",
                ClientName = "Device Flow Client",

                AllowedGrantTypes = GrantTypes.DeviceFlow,
                RequireClientSecret = false,

                AllowOfflineAccess = true,

                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            }
        };
    }
}


================================================
FILE: src/AspNetIdentity/host/Configuration/ClientsWeb.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class ClientsWeb
{
    static string[] allowedScopes = 
    {
        IdentityServerConstants.StandardScopes.OpenId,
        IdentityServerConstants.StandardScopes.Profile,
        IdentityServerConstants.StandardScopes.Email,
        "resource1.scope1", 
        "resource2.scope1",
        "transaction"
    };
    
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////
            // JS OIDC Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "js_oidc",
                ClientName = "JavaScript OIDC Client",
                ClientUri = "http://identityserver8.io",
                
                AllowedGrantTypes = GrantTypes.Code,
                RequireClientSecret = false,
                
                RedirectUris = 
                {
                    "https://localhost:44300/index.html",
                    "https://localhost:44300/callback.html",
                    "https://localhost:44300/silent.html",
                    "https://localhost:44300/popup.html"
                },

                PostLogoutRedirectUris = { "https://localhost:44300/index.html" },
                AllowedCorsOrigins = { "https://localhost:44300" },

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Automatic Token Management Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.tokenmanagement",
                
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,

                AccessTokenLifetime = 75,

                RedirectUris = { "https://localhost:44301/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44301/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44301/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Code Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.code",
                ClientName = "MVC Code Flow",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                RequireConsent = true,
                AllowedGrantTypes = GrantTypes.Code,

                RedirectUris = { "https://localhost:44302/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44302/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44302/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Hybrid Flow Sample (Back Channel logout)
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.hybrid.backchannel",
                ClientName = "MVC Hybrid (with BackChannel logout)",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Hybrid,
                RequirePkce = false,

                RedirectUris = { "https://localhost:44303/signin-oidc" },
                BackChannelLogoutUri = "https://localhost:44303/logout",
                PostLogoutRedirectUris = { "https://localhost:44303/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            }
        };
    }
}


================================================
FILE: src/AspNetIdentity/host/Configuration/Resources.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public class Resources
{
    // identity resources represent identity data about a user that can be requested via the scope parameter (OpenID Connect)
    public static readonly IEnumerable IdentityResources =
        new[]
        {
            // some standard scopes from the OIDC spec
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email(),

            // custom identity resource with some consolidated claims
            new IdentityResource("custom.profile", new[] { JwtClaimTypes.Name, JwtClaimTypes.Email, "location" })
        };

    // API scopes represent values that describe scope of access and can be requested by the scope parameter (OAuth)
    public static readonly IEnumerable ApiScopes =
        new[]
        {
            // local API scope
            new ApiScope(LocalApi.ScopeName),

            // resource specific scopes
            new ApiScope("resource1.scope1"),
            new ApiScope("resource2.scope1"), 
            
            // a scope without resource association
            new ApiScope("scope3"),
            
            // a scope shared by multiple resources
            new ApiScope("shared.scope"),

            // a parameterized scope
            new ApiScope("transaction", "Transaction")
            {
                Description = "Some Transaction"
            }
        };

    // API resources are more formal representation of a resource with processing rules and their scopes (if any)
    public static readonly IEnumerable ApiResources = 
        new[]
        {
            new ApiResource("resource1", "Resource 1")
            {
                ApiSecrets = { new Secret("secret".Sha256()) },

                Scopes = { "resource1.scope1", "shared.scope" }
            },
            
            // expanded version if more control is needed
            new ApiResource("resource2", "Resource 2")
            {
                ApiSecrets =
                {
                    new Secret("secret".Sha256())
                },

                // additional claims to put into access token
                UserClaims =
                {
                    JwtClaimTypes.Name,
                    JwtClaimTypes.Email
                },

                Scopes = { "resource2.scope1", "shared.scope" }
            }
        };
}


================================================
FILE: src/AspNetIdentity/host/Data/ApplicationDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Data;

public class ApplicationDbContext : IdentityDbContext
{
    public ApplicationDbContext(DbContextOptions options)
        : base(options)
    {
    }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        base.OnModelCreating(builder);
        // Customize the ASP.NET Identity model and override the defaults if needed.
        // For example, you can rename the ASP.NET Identity table names and more.
        // Add your customizations after calling base.OnModelCreating(builder);
    }
}


================================================
FILE: src/AspNetIdentity/host/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Configuration;
global using IdentityServerHost.Data;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Identity;
global using Microsoft.AspNetCore.Identity.EntityFrameworkCore;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.Extensions.Options;
global using Newtonsoft.Json;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System.ComponentModel;
global using System.ComponentModel.DataAnnotations;
global using System.Diagnostics;
global using System.Security.Claims;
global using System.Text;
global using static IdentityServer8.IdentityServerConstants;
global using ILogger = Microsoft.Extensions.Logging.ILogger;
global using ClaimValueTypes = System.Security.Claims.ClaimValueTypes;


================================================
FILE: src/AspNetIdentity/host/Host.csproj
================================================


  
    
    
    
    
  

  
    
    
    
    
    
  



================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/ExternalLoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class ExternalLoginViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/ForgotPasswordViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class ForgotPasswordViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class LoginViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [Display(Name = "Remember me?")]
    public bool RememberMe { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/LoginWith2faViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class LoginWith2faViewModel
{
    [Required]
    [StringLength(7, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
    [DataType(DataType.Text)]
    [Display(Name = "Authenticator code")]
    public string TwoFactorCode { get; set; }

    [Display(Name = "Remember this machine")]
    public bool RememberMachine { get; set; }

    public bool RememberMe { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/LoginWithRecoveryCodeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class LoginWithRecoveryCodeViewModel
{
        [Required]
        [DataType(DataType.Text)]
        [Display(Name = "Recovery Code")]
        public string RecoveryCode { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/RegisterViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class RegisterViewModel
{
    [Required]
    [EmailAddress]
    [Display(Name = "Email")]
    public string Email { get; set; }

    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
    [DataType(DataType.Password)]
    [Display(Name = "Password")]
    public string Password { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm password")]
    [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
    public string ConfirmPassword { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/AccountViewModels/ResetPasswordViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.AccountViewModels;

public class ResetPasswordViewModel
{
    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
    [DataType(DataType.Password)]
    public string Password { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm password")]
    [Compare("Password", ErrorMessage = "The password and confirmation password do not match.")]
    public string ConfirmPassword { get; set; }

    public string Code { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ApplicationUser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

// Add profile data for application users by adding properties to the ApplicationUser class
public class ApplicationUser : IdentityUser
{
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/ChangePasswordViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class ChangePasswordViewModel
{
    [Required]
    [DataType(DataType.Password)]
    [Display(Name = "Current password")]
    public string OldPassword { get; set; }

    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
    [DataType(DataType.Password)]
    [Display(Name = "New password")]
    public string NewPassword { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm new password")]
    [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
    public string ConfirmPassword { get; set; }

    public string StatusMessage { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/EnableAuthenticatorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class EnableAuthenticatorViewModel
{
        [Required]
        [StringLength(7, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
        [DataType(DataType.Text)]
        [Display(Name = "Verification Code")]
        public string Code { get; set; }

        [ReadOnly(true)]
        public string SharedKey { get; set; }

        public string AuthenticatorUri { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/ExternalLoginsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class ExternalLoginsViewModel
{
    public IList CurrentLogins { get; set; }

    public IList OtherLogins { get; set; }

    public bool ShowRemoveButton { get; set; }

    public string StatusMessage { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/GenerateRecoveryCodesViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class GenerateRecoveryCodesViewModel
{
    public string[] RecoveryCodes { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/IndexViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class IndexViewModel
{
    public string Username { get; set; }

    public bool IsEmailConfirmed { get; set; }

    [Required]
    [EmailAddress]
    public string Email { get; set; }

    [Phone]
    [Display(Name = "Phone number")]
    public string PhoneNumber { get; set; }

    public string StatusMessage { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/RemoveLoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class RemoveLoginViewModel
{
    public string LoginProvider { get; set; }
    public string ProviderKey { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/SetPasswordViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class SetPasswordViewModel
{
    [Required]
    [StringLength(100, ErrorMessage = "The {0} must be at least {2} and at max {1} characters long.", MinimumLength = 6)]
    [DataType(DataType.Password)]
    [Display(Name = "New password")]
    public string NewPassword { get; set; }

    [DataType(DataType.Password)]
    [Display(Name = "Confirm new password")]
    [Compare("NewPassword", ErrorMessage = "The new password and confirmation password do not match.")]
    public string ConfirmPassword { get; set; }

    public string StatusMessage { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Models/ManageViewModels/TwoFactorAuthenticationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models.ManageViewModels;

public class TwoFactorAuthenticationViewModel
{
    public bool HasAuthenticator { get; set; }

    public int RecoveryCodesLeft { get; set; }

    public bool Is2faEnabled { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost;

public class Program
{
    public static int Main(string[] args)
    {
        Console.Title = "IdentityServer8.AspNetIdentity";
        Activity.DefaultIdFormat = ActivityIdFormat.W3C;

        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
            .MinimumLevel.Override("System", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
            .Enrich.FromLogContext()
            //.WriteTo.File(@"IdentityServer8_log.txt")
            // uncomment to write to Azure diagnostics stream
            //.WriteTo.File(
            //    @"D:\home\LogFiles\Application\identityserver.txt",
            //    fileSizeLimitBytes: 1_000_000,
            //    rollOnFileSizeLimit: true,
            //    shared: true,
            //    flushToDiskInterval: TimeSpan.FromSeconds(1))
            .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
            .CreateLogger();

        try
        {
            Log.Information("Starting host...");
            CreateHostBuilder(args).Build().Run();
            return 0;
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Host terminated unexpectedly.");
            return 1;
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseSerilog()
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup();
            });
}


================================================
FILE: src/AspNetIdentity/host/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": true,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:5000",
      "sslPort": 44334
    }
  },
  "profiles": {
    "Host": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly UserManager _userManager;
    private readonly SignInManager _signInManager;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        UserManager userManager,
        SignInManager signInManager,
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events)
    {
        _userManager = userManager;
        _signInManager = signInManager;
        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        // check if we are in the context of an authorization request
        if (ModelState.IsValid)
        {
            var result = await _signInManager.PasswordSignInAsync(model.Username, model.Password, model.RememberLogin, lockoutOnFailure: true);
            if (result.Succeeded)
            {
                var user = await _userManager.FindByNameAsync(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.UserName, user.Id, user.UserName, clientId: context?.Client.ClientId));

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return this.LoadingPage("Redirect", model.ReturnUrl);
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return Redirect("~/");
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return Redirect("~/");
        }

    }


    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await _signInManager.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class AccountOptions
{
    public static bool AllowLocalLogin = true;
    public static bool AllowRememberLogin = true;
    public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

    public static bool ShowLogoutPrompt = true;
    public static bool AutomaticRedirectAfterSignOut = false;

    public static string InvalidCredentialsErrorMessage = "Invalid username or password";
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly UserManager _userManager;
    private readonly SignInManager _signInManager;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ExternalController(
        UserManager userManager,
        SignInManager signInManager,
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger)
    {
        _userManager = userManager;
        _signInManager = signInManager;
        _interaction = interaction;
        _clientStore = clientStore;
        _events = events;
        _logger = logger;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = await FindUserFromExternalProviderAsync(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = await AutoProvisionUserAsync(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        // we must issue the cookie maually, and can't use the SignInManager because
        // it doesn't expose an API to issue additional claims from the login workflow
        var principal = await _signInManager.CreateUserPrincipalAsync(user);
        additionalLocalClaims.AddRange(principal.Claims);
        var name = principal.FindFirst(JwtClaimTypes.Name)?.Value ?? user.Id;
        
        var isuser = new IdentityServerUser(user.Id)
        {
            DisplayName = name,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.Id, name, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private async Task<(ApplicationUser user, string provider, string providerUserId, IEnumerable claims)>
        FindUserFromExternalProviderAsync(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = await _userManager.FindByLoginAsync(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private async Task AutoProvisionUserAsync(string provider, string providerUserId, IEnumerable claims)
    {
        // create a list of claims that we want to transfer into our store
        var filtered = new List();

        // user's display name
        var name = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Name)?.Value ??
            claims.FirstOrDefault(x => x.Type == ClaimTypes.Name)?.Value;
        if (name != null)
        {
            filtered.Add(new Claim(JwtClaimTypes.Name, name));
        }
        else
        {
            var first = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value ??
                claims.FirstOrDefault(x => x.Type == ClaimTypes.GivenName)?.Value;
            var last = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value ??
                claims.FirstOrDefault(x => x.Type == ClaimTypes.Surname)?.Value;
            if (first != null && last != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
            }
            else if (first != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, first));
            }
            else if (last != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, last));
            }
        }

        // email
        var email = claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Email)?.Value ??
           claims.FirstOrDefault(x => x.Type == ClaimTypes.Email)?.Value;
        if (email != null)
        {
            filtered.Add(new Claim(JwtClaimTypes.Email, email));
        }

        var user = new ApplicationUser
        {
            UserName = Guid.NewGuid().ToString(),
        };
        var identityResult = await _userManager.CreateAsync(user);
        if (!identityResult.Succeeded) throw new Exception(identityResult.Errors.First().Description);

        if (filtered.Any())
        {
            identityResult = await _userManager.AddClaimsAsync(user, filtered);
            if (!identityResult.Succeeded) throw new Exception(identityResult.Errors.First().Description);
        }

        identityResult = await _userManager.AddLoginAsync(user, new UserLoginInfo(provider, providerUserId, provider));
        if (!identityResult.Succeeded) throw new Exception(identityResult.Errors.First().Description);

        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();

        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", Ioc.Sanitizer.Log.Sanitize(returnUrl));
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonConvert.DeserializeObject(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: src/AspNetIdentity/host/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{
    public static List Users = new List
    {
        new TestUser{SubjectId = "818727", Username = "alice", Password = "alice", 
            Claims = 
            {
                new Claim(JwtClaimTypes.Name, "Alice Smith"),
                new Claim(JwtClaimTypes.GivenName, "Alice"),
                new Claim(JwtClaimTypes.FamilyName, "Smith"),
                new Claim(JwtClaimTypes.Email, "AliceSmith@email.com"),
                new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServer8.IdentityServerConstants.ClaimValueTypes.Json)
            }
        },
        new TestUser{SubjectId = "88421113", Username = "bob", Password = "bob", 
            Claims = 
            {
                new Claim(JwtClaimTypes.Name, "Bob Smith"),
                new Claim(JwtClaimTypes.GivenName, "Bob"),
                new Claim(JwtClaimTypes.FamilyName, "Smith"),
                new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServer8.IdentityServerConstants.ClaimValueTypes.Json),
                new Claim("location", "somewhere")
            }
        }
    };
}


================================================
FILE: src/AspNetIdentity/host/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost
{
    public class Startup
    {
        public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
        }

        public IConfiguration Configuration { get; }

        public void ConfigureServices(IServiceCollection services)
        {
            services.AddDbContext(options =>
                options.UseSqlServer(Configuration.GetConnectionString("DefaultConnection")));

            services.AddIdentity()
                .AddEntityFrameworkStores()
                .AddDefaultTokenProviders();

            services.AddControllersWithViews();

            services.AddIdentityServer()
                .AddDeveloperSigningCredential()
                .AddInMemoryIdentityResources(IdentityServerHost.Configuration.Resources.IdentityResources)
                .AddInMemoryApiResources(IdentityServerHost.Configuration.Resources.ApiResources)
                .AddInMemoryApiScopes(IdentityServerHost.Configuration.Resources.ApiScopes)
                .AddInMemoryClients(Clients.Get())
                .AddAspNetIdentity();

            services.AddAuthentication()
                .AddOpenIdConnect("Google", "Google", options =>
                {
                    options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                    options.ForwardSignOut = IdentityServerConstants.DefaultCookieAuthenticationScheme;

                    options.Authority = "https://accounts.google.com/";
                    options.ClientId = "708996912208-9m4dkjb5hscn7cjrn5u0r4tbgkbj1fko.apps.googleusercontent.com";

                    options.CallbackPath = "/signin-google";
                    options.Scope.Add("email");
                });
        }

        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
                //app.UseDatabaseErrorPage();
            }
            else
            {
                app.UseExceptionHandler("/Home/Error");
            }

            app.UseStaticFiles();

            app.UseRouting();

            app.UseIdentityServer();

            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapDefaultControllerRoute();
            });
        }
    }
}


================================================
FILE: src/AspNetIdentity/host/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: src/AspNetIdentity/host/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: src/AspNetIdentity/host/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: src/AspNetIdentity/host/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: src/AspNetIdentity/host/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: src/AspNetIdentity/host/Views/Home/Index.cshtml
================================================
@using System.Diagnostics

@{
    var version = FileVersionInfo.GetVersionInfo(typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.Location).ProductVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: src/AspNetIdentity/host/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: src/AspNetIdentity/host/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: src/AspNetIdentity/host/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: src/AspNetIdentity/host/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: src/AspNetIdentity/host/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: src/AspNetIdentity/host/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: src/AspNetIdentity/host/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: src/AspNetIdentity/host/appsettings.json
================================================
{
  "ConnectionStrings": {
    "DefaultConnection": "Server=(localdb)\\mssqllocaldb;Database=IdentityServer8.AspNetIdentity-8.0.0;Trusted_Connection=True;MultipleActiveResultSets=true"
  },
  "Logging": {
    "IncludeScopes": false,
    "LogLevel": {
      "Default": "Warning"
    }
  }
}


================================================
FILE: src/AspNetIdentity/host/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: src/AspNetIdentity/host/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: src/AspNetIdentity/host/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: src/AspNetIdentity/host/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: src/AspNetIdentity/host/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8.Models;
global using IdentityServerHost;
global using IdentityServerHost.Data;
global using Microsoft.AspNetCore;
global using Microsoft.AspNetCore.Identity;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.EntityFrameworkCore.Infrastructure;
global using Microsoft.EntityFrameworkCore.Metadata;
global using Microsoft.EntityFrameworkCore.Migrations;
global using System.Security.Claims;


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Migrations/UsersDb/20200323135751_Users.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.UsersDb
{
    [DbContext(typeof(ApplicationDbContext))]
    [Migration("20200323135751_Users")]
    partial class Users
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.0")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.Models.ApplicationUser", b =>
                {
                    b.Property("Id")
                        .HasColumnType("nvarchar(450)");

                    b.Property("AccessFailedCount")
                        .HasColumnType("int");

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken()
                        .HasColumnType("nvarchar(max)");

                    b.Property("Email")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.Property("EmailConfirmed")
                        .HasColumnType("bit");

                    b.Property("LockoutEnabled")
                        .HasColumnType("bit");

                    b.Property("LockoutEnd")
                        .HasColumnType("datetimeoffset");

                    b.Property("NormalizedEmail")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.Property("NormalizedUserName")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.Property("PasswordHash")
                        .HasColumnType("nvarchar(max)");

                    b.Property("PhoneNumber")
                        .HasColumnType("nvarchar(max)");

                    b.Property("PhoneNumberConfirmed")
                        .HasColumnType("bit");

                    b.Property("SecurityStamp")
                        .HasColumnType("nvarchar(max)");

                    b.Property("TwoFactorEnabled")
                        .HasColumnType("bit");

                    b.Property("UserName")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedEmail")
                        .HasName("EmailIndex");

                    b.HasIndex("NormalizedUserName")
                        .IsUnique()
                        .HasName("UserNameIndex")
                        .HasFilter("[NormalizedUserName] IS NOT NULL");

                    b.ToTable("AspNetUsers");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
                {
                    b.Property("Id")
                        .HasColumnType("nvarchar(450)");

                    b.Property("ConcurrencyStamp")
                        .IsConcurrencyToken()
                        .HasColumnType("nvarchar(max)");

                    b.Property("Name")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.Property("NormalizedName")
                        .HasColumnType("nvarchar(256)")
                        .HasMaxLength(256);

                    b.HasKey("Id");

                    b.HasIndex("NormalizedName")
                        .IsUnique()
                        .HasName("RoleNameIndex")
                        .HasFilter("[NormalizedName] IS NOT NULL");

                    b.ToTable("AspNetRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClaimType")
                        .HasColumnType("nvarchar(max)");

                    b.Property("ClaimValue")
                        .HasColumnType("nvarchar(max)");

                    b.Property("RoleId")
                        .IsRequired()
                        .HasColumnType("nvarchar(450)");

                    b.HasKey("Id");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetRoleClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClaimType")
                        .HasColumnType("nvarchar(max)");

                    b.Property("ClaimValue")
                        .HasColumnType("nvarchar(max)");

                    b.Property("UserId")
                        .IsRequired()
                        .HasColumnType("nvarchar(450)");

                    b.HasKey("Id");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserClaims");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.Property("LoginProvider")
                        .HasColumnType("nvarchar(450)");

                    b.Property("ProviderKey")
                        .HasColumnType("nvarchar(450)");

                    b.Property("ProviderDisplayName")
                        .HasColumnType("nvarchar(max)");

                    b.Property("UserId")
                        .IsRequired()
                        .HasColumnType("nvarchar(450)");

                    b.HasKey("LoginProvider", "ProviderKey");

                    b.HasIndex("UserId");

                    b.ToTable("AspNetUserLogins");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.Property("UserId")
                        .HasColumnType("nvarchar(450)");

                    b.Property("RoleId")
                        .HasColumnType("nvarchar(450)");

                    b.HasKey("UserId", "RoleId");

                    b.HasIndex("RoleId");

                    b.ToTable("AspNetUserRoles");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.Property("UserId")
                        .HasColumnType("nvarchar(450)");

                    b.Property("LoginProvider")
                        .HasColumnType("nvarchar(450)");

                    b.Property("Name")
                        .HasColumnType("nvarchar(450)");

                    b.Property("Value")
                        .HasColumnType("nvarchar(max)");

                    b.HasKey("UserId", "LoginProvider", "Name");

                    b.ToTable("AspNetUserTokens");
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
                {
                    b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
                {
                    b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
                {
                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
                        .WithMany()
                        .HasForeignKey("RoleId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();

                    b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
                {
                    b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                        .WithMany()
                        .HasForeignKey("UserId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Migrations/UsersDb/20200323135751_Users.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer.Migrations.UsersDb;

public partial class Users : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "AspNetRoles",
            columns: table => new
            {
                Id = table.Column(nullable: false),
                Name = table.Column(maxLength: 256, nullable: true),
                NormalizedName = table.Column(maxLength: 256, nullable: true),
                ConcurrencyStamp = table.Column(nullable: true)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetRoles", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "AspNetUsers",
            columns: table => new
            {
                Id = table.Column(nullable: false),
                UserName = table.Column(maxLength: 256, nullable: true),
                NormalizedUserName = table.Column(maxLength: 256, nullable: true),
                Email = table.Column(maxLength: 256, nullable: true),
                NormalizedEmail = table.Column(maxLength: 256, nullable: true),
                EmailConfirmed = table.Column(nullable: false),
                PasswordHash = table.Column(nullable: true),
                SecurityStamp = table.Column(nullable: true),
                ConcurrencyStamp = table.Column(nullable: true),
                PhoneNumber = table.Column(nullable: true),
                PhoneNumberConfirmed = table.Column(nullable: false),
                TwoFactorEnabled = table.Column(nullable: false),
                LockoutEnd = table.Column(nullable: true),
                LockoutEnabled = table.Column(nullable: false),
                AccessFailedCount = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetUsers", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "AspNetRoleClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                RoleId = table.Column(nullable: false),
                ClaimType = table.Column(nullable: true),
                ClaimValue = table.Column(nullable: true)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetRoleClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_AspNetRoleClaims_AspNetRoles_RoleId",
                    column: x => x.RoleId,
                    principalTable: "AspNetRoles",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "AspNetUserClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                UserId = table.Column(nullable: false),
                ClaimType = table.Column(nullable: true),
                ClaimValue = table.Column(nullable: true)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetUserClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_AspNetUserClaims_AspNetUsers_UserId",
                    column: x => x.UserId,
                    principalTable: "AspNetUsers",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "AspNetUserLogins",
            columns: table => new
            {
                LoginProvider = table.Column(nullable: false),
                ProviderKey = table.Column(nullable: false),
                ProviderDisplayName = table.Column(nullable: true),
                UserId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetUserLogins", x => new { x.LoginProvider, x.ProviderKey });
                table.ForeignKey(
                    name: "FK_AspNetUserLogins_AspNetUsers_UserId",
                    column: x => x.UserId,
                    principalTable: "AspNetUsers",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "AspNetUserRoles",
            columns: table => new
            {
                UserId = table.Column(nullable: false),
                RoleId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetUserRoles", x => new { x.UserId, x.RoleId });
                table.ForeignKey(
                    name: "FK_AspNetUserRoles_AspNetRoles_RoleId",
                    column: x => x.RoleId,
                    principalTable: "AspNetRoles",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
                table.ForeignKey(
                    name: "FK_AspNetUserRoles_AspNetUsers_UserId",
                    column: x => x.UserId,
                    principalTable: "AspNetUsers",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "AspNetUserTokens",
            columns: table => new
            {
                UserId = table.Column(nullable: false),
                LoginProvider = table.Column(nullable: false),
                Name = table.Column(nullable: false),
                Value = table.Column(nullable: true)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_AspNetUserTokens", x => new { x.UserId, x.LoginProvider, x.Name });
                table.ForeignKey(
                    name: "FK_AspNetUserTokens_AspNetUsers_UserId",
                    column: x => x.UserId,
                    principalTable: "AspNetUsers",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateIndex(
            name: "IX_AspNetRoleClaims_RoleId",
            table: "AspNetRoleClaims",
            column: "RoleId");

        migrationBuilder.CreateIndex(
            name: "RoleNameIndex",
            table: "AspNetRoles",
            column: "NormalizedName",
            unique: true,
            filter: "[NormalizedName] IS NOT NULL");

        migrationBuilder.CreateIndex(
            name: "IX_AspNetUserClaims_UserId",
            table: "AspNetUserClaims",
            column: "UserId");

        migrationBuilder.CreateIndex(
            name: "IX_AspNetUserLogins_UserId",
            table: "AspNetUserLogins",
            column: "UserId");

        migrationBuilder.CreateIndex(
            name: "IX_AspNetUserRoles_RoleId",
            table: "AspNetUserRoles",
            column: "RoleId");

        migrationBuilder.CreateIndex(
            name: "EmailIndex",
            table: "AspNetUsers",
            column: "NormalizedEmail");

        migrationBuilder.CreateIndex(
            name: "UserNameIndex",
            table: "AspNetUsers",
            column: "NormalizedUserName",
            unique: true,
            filter: "[NormalizedUserName] IS NOT NULL");
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "AspNetRoleClaims");

        migrationBuilder.DropTable(
            name: "AspNetUserClaims");

        migrationBuilder.DropTable(
            name: "AspNetUserLogins");

        migrationBuilder.DropTable(
            name: "AspNetUserRoles");

        migrationBuilder.DropTable(
            name: "AspNetUserTokens");

        migrationBuilder.DropTable(
            name: "AspNetRoles");

        migrationBuilder.DropTable(
            name: "AspNetUsers");
    }
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Migrations/UsersDb/ApplicationDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.UsersDb;

[DbContext(typeof(ApplicationDbContext))]
partial class ApplicationDbContextModelSnapshot : ModelSnapshot
{
    protected override void BuildModel(ModelBuilder modelBuilder)
    {
#pragma warning disable 612, 618
        modelBuilder
            .HasAnnotation("ProductVersion", "3.1.0")
            .HasAnnotation("Relational:MaxIdentifierLength", 128)
            .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

        modelBuilder.Entity("IdentityServer8.Models.ApplicationUser", b =>
            {
                b.Property("Id")
                    .HasColumnType("nvarchar(450)");

                b.Property("AccessFailedCount")
                    .HasColumnType("int");

                b.Property("ConcurrencyStamp")
                    .IsConcurrencyToken()
                    .HasColumnType("nvarchar(max)");

                b.Property("Email")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.Property("EmailConfirmed")
                    .HasColumnType("bit");

                b.Property("LockoutEnabled")
                    .HasColumnType("bit");

                b.Property("LockoutEnd")
                    .HasColumnType("datetimeoffset");

                b.Property("NormalizedEmail")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.Property("NormalizedUserName")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.Property("PasswordHash")
                    .HasColumnType("nvarchar(max)");

                b.Property("PhoneNumber")
                    .HasColumnType("nvarchar(max)");

                b.Property("PhoneNumberConfirmed")
                    .HasColumnType("bit");

                b.Property("SecurityStamp")
                    .HasColumnType("nvarchar(max)");

                b.Property("TwoFactorEnabled")
                    .HasColumnType("bit");

                b.Property("UserName")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.HasKey("Id");

                b.HasIndex("NormalizedEmail")
                    .HasName("EmailIndex");

                b.HasIndex("NormalizedUserName")
                    .IsUnique()
                    .HasName("UserNameIndex")
                    .HasFilter("[NormalizedUserName] IS NOT NULL");

                b.ToTable("AspNetUsers");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
            {
                b.Property("Id")
                    .HasColumnType("nvarchar(450)");

                b.Property("ConcurrencyStamp")
                    .IsConcurrencyToken()
                    .HasColumnType("nvarchar(max)");

                b.Property("Name")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.Property("NormalizedName")
                    .HasColumnType("nvarchar(256)")
                    .HasMaxLength(256);

                b.HasKey("Id");

                b.HasIndex("NormalizedName")
                    .IsUnique()
                    .HasName("RoleNameIndex")
                    .HasFilter("[NormalizedName] IS NOT NULL");

                b.ToTable("AspNetRoles");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClaimType")
                    .HasColumnType("nvarchar(max)");

                b.Property("ClaimValue")
                    .HasColumnType("nvarchar(max)");

                b.Property("RoleId")
                    .IsRequired()
                    .HasColumnType("nvarchar(450)");

                b.HasKey("Id");

                b.HasIndex("RoleId");

                b.ToTable("AspNetRoleClaims");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClaimType")
                    .HasColumnType("nvarchar(max)");

                b.Property("ClaimValue")
                    .HasColumnType("nvarchar(max)");

                b.Property("UserId")
                    .IsRequired()
                    .HasColumnType("nvarchar(450)");

                b.HasKey("Id");

                b.HasIndex("UserId");

                b.ToTable("AspNetUserClaims");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
            {
                b.Property("LoginProvider")
                    .HasColumnType("nvarchar(450)");

                b.Property("ProviderKey")
                    .HasColumnType("nvarchar(450)");

                b.Property("ProviderDisplayName")
                    .HasColumnType("nvarchar(max)");

                b.Property("UserId")
                    .IsRequired()
                    .HasColumnType("nvarchar(450)");

                b.HasKey("LoginProvider", "ProviderKey");

                b.HasIndex("UserId");

                b.ToTable("AspNetUserLogins");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
            {
                b.Property("UserId")
                    .HasColumnType("nvarchar(450)");

                b.Property("RoleId")
                    .HasColumnType("nvarchar(450)");

                b.HasKey("UserId", "RoleId");

                b.HasIndex("RoleId");

                b.ToTable("AspNetUserRoles");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
            {
                b.Property("UserId")
                    .HasColumnType("nvarchar(450)");

                b.Property("LoginProvider")
                    .HasColumnType("nvarchar(450)");

                b.Property("Name")
                    .HasColumnType("nvarchar(450)");

                b.Property("Value")
                    .HasColumnType("nvarchar(max)");

                b.HasKey("UserId", "LoginProvider", "Name");

                b.ToTable("AspNetUserTokens");
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim", b =>
            {
                b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
                    .WithMany()
                    .HasForeignKey("RoleId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim", b =>
            {
                b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                    .WithMany()
                    .HasForeignKey("UserId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin", b =>
            {
                b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                    .WithMany()
                    .HasForeignKey("UserId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole", b =>
            {
                b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
                    .WithMany()
                    .HasForeignKey("RoleId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();

                b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                    .WithMany()
                    .HasForeignKey("UserId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken", b =>
            {
                b.HasOne("IdentityServer8.Models.ApplicationUser", null)
                    .WithMany()
                    .HasForeignKey("UserId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });
#pragma warning restore 612, 618
    }
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Migrations/UsersDb.sql
================================================
IF OBJECT_ID(N'[__EFMigrationsHistory]') IS NULL
BEGIN
    CREATE TABLE [__EFMigrationsHistory] (
        [MigrationId] nvarchar(150) NOT NULL,
        [ProductVersion] nvarchar(32) NOT NULL,
        CONSTRAINT [PK___EFMigrationsHistory] PRIMARY KEY ([MigrationId])
    );
END;

GO

CREATE TABLE [AspNetRoles] (
    [Id] nvarchar(450) NOT NULL,
    [Name] nvarchar(256) NULL,
    [NormalizedName] nvarchar(256) NULL,
    [ConcurrencyStamp] nvarchar(max) NULL,
    CONSTRAINT [PK_AspNetRoles] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [AspNetUsers] (
    [Id] nvarchar(450) NOT NULL,
    [UserName] nvarchar(256) NULL,
    [NormalizedUserName] nvarchar(256) NULL,
    [Email] nvarchar(256) NULL,
    [NormalizedEmail] nvarchar(256) NULL,
    [EmailConfirmed] bit NOT NULL,
    [PasswordHash] nvarchar(max) NULL,
    [SecurityStamp] nvarchar(max) NULL,
    [ConcurrencyStamp] nvarchar(max) NULL,
    [PhoneNumber] nvarchar(max) NULL,
    [PhoneNumberConfirmed] bit NOT NULL,
    [TwoFactorEnabled] bit NOT NULL,
    [LockoutEnd] datetimeoffset NULL,
    [LockoutEnabled] bit NOT NULL,
    [AccessFailedCount] int NOT NULL,
    CONSTRAINT [PK_AspNetUsers] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [AspNetRoleClaims] (
    [Id] int NOT NULL IDENTITY,
    [RoleId] nvarchar(450) NOT NULL,
    [ClaimType] nvarchar(max) NULL,
    [ClaimValue] nvarchar(max) NULL,
    CONSTRAINT [PK_AspNetRoleClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_AspNetRoleClaims_AspNetRoles_RoleId] FOREIGN KEY ([RoleId]) REFERENCES [AspNetRoles] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [AspNetUserClaims] (
    [Id] int NOT NULL IDENTITY,
    [UserId] nvarchar(450) NOT NULL,
    [ClaimType] nvarchar(max) NULL,
    [ClaimValue] nvarchar(max) NULL,
    CONSTRAINT [PK_AspNetUserClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_AspNetUserClaims_AspNetUsers_UserId] FOREIGN KEY ([UserId]) REFERENCES [AspNetUsers] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [AspNetUserLogins] (
    [LoginProvider] nvarchar(450) NOT NULL,
    [ProviderKey] nvarchar(450) NOT NULL,
    [ProviderDisplayName] nvarchar(max) NULL,
    [UserId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_AspNetUserLogins] PRIMARY KEY ([LoginProvider], [ProviderKey]),
    CONSTRAINT [FK_AspNetUserLogins_AspNetUsers_UserId] FOREIGN KEY ([UserId]) REFERENCES [AspNetUsers] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [AspNetUserRoles] (
    [UserId] nvarchar(450) NOT NULL,
    [RoleId] nvarchar(450) NOT NULL,
    CONSTRAINT [PK_AspNetUserRoles] PRIMARY KEY ([UserId], [RoleId]),
    CONSTRAINT [FK_AspNetUserRoles_AspNetRoles_RoleId] FOREIGN KEY ([RoleId]) REFERENCES [AspNetRoles] ([Id]) ON DELETE CASCADE,
    CONSTRAINT [FK_AspNetUserRoles_AspNetUsers_UserId] FOREIGN KEY ([UserId]) REFERENCES [AspNetUsers] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [AspNetUserTokens] (
    [UserId] nvarchar(450) NOT NULL,
    [LoginProvider] nvarchar(450) NOT NULL,
    [Name] nvarchar(450) NOT NULL,
    [Value] nvarchar(max) NULL,
    CONSTRAINT [PK_AspNetUserTokens] PRIMARY KEY ([UserId], [LoginProvider], [Name]),
    CONSTRAINT [FK_AspNetUserTokens_AspNetUsers_UserId] FOREIGN KEY ([UserId]) REFERENCES [AspNetUsers] ([Id]) ON DELETE CASCADE
);

GO

CREATE INDEX [IX_AspNetRoleClaims_RoleId] ON [AspNetRoleClaims] ([RoleId]);

GO

CREATE UNIQUE INDEX [RoleNameIndex] ON [AspNetRoles] ([NormalizedName]) WHERE [NormalizedName] IS NOT NULL;

GO

CREATE INDEX [IX_AspNetUserClaims_UserId] ON [AspNetUserClaims] ([UserId]);

GO

CREATE INDEX [IX_AspNetUserLogins_UserId] ON [AspNetUserLogins] ([UserId]);

GO

CREATE INDEX [IX_AspNetUserRoles_RoleId] ON [AspNetUserRoles] ([RoleId]);

GO

CREATE INDEX [EmailIndex] ON [AspNetUsers] ([NormalizedEmail]);

GO

CREATE UNIQUE INDEX [UserNameIndex] ON [AspNetUsers] ([NormalizedUserName]) WHERE [NormalizedUserName] IS NOT NULL;

GO

INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
VALUES (N'20200323135751_Users', N'3.1.0');

GO



================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer;

class Program
{
    public static void Main(string[] args)
    {
        var host = BuildWebHost(args);
        SeedData.EnsureSeedData(host.Services);
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup()
            .Build();
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:7603/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "SqlServer": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "http://localhost:7604/"
    }
  }
}

================================================
FILE: src/AspNetIdentity/migrations/SqlServer/SeedData.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost;

public class SeedData
{
    public static void EnsureSeedData(IServiceProvider serviceProvider)
    {
        using (var scope = serviceProvider.GetRequiredService().CreateScope())
        {
            var context = scope.ServiceProvider.GetService();
            context.Database.Migrate();

            var userMgr = scope.ServiceProvider.GetRequiredService>();
            var alice = userMgr.FindByNameAsync("alice").Result;
            if (alice == null)
            {
                alice = new ApplicationUser
                {
                    UserName = "alice"
                };
                var result = userMgr.CreateAsync(alice, "Pass123$").Result;
                if (!result.Succeeded)
                {
                    throw new Exception(result.Errors.First().Description);
                }

                result = userMgr.AddClaimsAsync(alice, new Claim[]{
                    new Claim(JwtClaimTypes.Name, "Alice Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Alice"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "AliceSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                    new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServer8.IdentityServerConstants.ClaimValueTypes.Json)
                }).Result;
                if (!result.Succeeded)
                {
                    throw new Exception(result.Errors.First().Description);
                }
                Console.WriteLine("alice created");
            }
            else
            {
                Console.WriteLine("alice already exists");
            }

            var bob = userMgr.FindByNameAsync("bob").Result;
            if (bob == null)
            {
                bob = new ApplicationUser
                {
                    UserName = "bob"
                };
                var result = userMgr.CreateAsync(bob, "Pass123$").Result;
                if (!result.Succeeded)
                {
                    throw new Exception(result.Errors.First().Description);
                }

                result = userMgr.AddClaimsAsync(bob, new Claim[]{
                    new Claim(JwtClaimTypes.Name, "Bob Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Bob"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                    new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServer8.IdentityServerConstants.ClaimValueTypes.Json),
                    new Claim("location", "somewhere")
                }).Result;
                if (!result.Succeeded)
                {
                    throw new Exception(result.Errors.First().Description);
                }
                Console.WriteLine("bob created");
            }
            else
            {
                Console.WriteLine("bob already exists");
            }
        }
    }
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/SqlServer.csproj
================================================

  
    
  

  
    
    
  




================================================
FILE: src/AspNetIdentity/migrations/SqlServer/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer;

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration config)
    {
        Configuration = config;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var cn = Configuration.GetConnectionString("db");
        services.AddDbContext(options =>
        {
            options.UseSqlServer(cn, dbOpts => dbOpts.MigrationsAssembly(typeof(Startup).Assembly.FullName));
        });

        services.AddIdentity()
            .AddEntityFrameworkStores()
            .AddDefaultTokenProviders();
    }

    public void Configure(IApplicationBuilder app)
    {
    }
}


================================================
FILE: src/AspNetIdentity/migrations/SqlServer/appsettings.json
================================================
{
  "ConnectionStrings": {
    "db": "server=(localdb)\\mssqllocaldb;database=IdentityServer8.AspNetIdentity-8.0.0;trusted_connection=yes;"
  }
}

================================================
FILE: src/AspNetIdentity/migrations/SqlServer/builddb.bat
================================================
rmdir /S /Q Migrations

dotnet ef database drop

dotnet ef migrations add Users -o Migrations/UsersDb
dotnet ef migrations script -o Migrations/UsersDb.sql

dotnet ef database update


================================================
FILE: src/AspNetIdentity/src/Decorator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.AspNetIdentity;

internal class Decorator
{
    public TService Instance { get; set; }

    public Decorator(TService instance)
    {
        Instance = instance;
    }
}

internal class Decorator : Decorator
    where TImpl : class, TService
{
    public Decorator(TImpl instance) : base(instance)
    {
    }
}

internal class DisposableDecorator : Decorator, IDisposable
{
    public DisposableDecorator(TService instance) : base(instance)
    {
    }

    public void Dispose()
    {
        (Instance as IDisposable)?.Dispose();
    }
}


================================================
FILE: src/AspNetIdentity/src/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.AspNetIdentity;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Validation;
global using Microsoft.AspNetCore.Authentication.Cookies;
global using Microsoft.AspNetCore.Identity;
global using Microsoft.Extensions.Logging;
global using System.Security.Claims;
global using static IdentityModel.OidcConstants;


================================================
FILE: src/AspNetIdentity/src/IdentityServer8.AspNetIdentity.csproj
================================================


  
      ASP.NET Core Identity Integration for IdentityServer8
      true
      true
      true
  

  
    True
    True
  

  
    
  



================================================
FILE: src/AspNetIdentity/src/IdentityServerBuilderExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Extension methods to add ASP.NET Identity support to IdentityServer.
/// 
public static class IdentityServerBuilderExtensions
{
    /// 
    /// Configures IdentityServer to use the ASP.NET Identity implementations 
    /// of IUserClaimsPrincipalFactory, IResourceOwnerPasswordValidator, and IProfileService.
    /// Also configures some of ASP.NET Identity's options for use with IdentityServer (such as claim types to use
    /// and authentication cookie settings).
    /// 
    /// The type of the user.
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddAspNetIdentity(this IIdentityServerBuilder builder)
        where TUser : class
    {
        builder.Services.AddTransientDecorator, UserClaimsFactory>();

        builder.Services.Configure(options =>
        {
            options.ClaimsIdentity.UserIdClaimType = JwtClaimTypes.Subject;
            options.ClaimsIdentity.UserNameClaimType = JwtClaimTypes.Name;
            options.ClaimsIdentity.RoleClaimType = JwtClaimTypes.Role;
        });

        builder.Services.Configure(opts =>
        {
            opts.OnRefreshingPrincipal = SecurityStampValidatorCallback.UpdatePrincipal;
        });

        builder.Services.ConfigureApplicationCookie(options =>
        {
            options.Cookie.IsEssential = true;
            // we need to disable to allow iframe for authorize requests
            options.Cookie.SameSite = AspNetCore.Http.SameSiteMode.None;
        });

        builder.Services.ConfigureExternalCookie(options =>
        {
            options.Cookie.IsEssential = true;
            // https://github.com/alexhiggins732/IdentityServer8/issues/2595
            options.Cookie.SameSite = AspNetCore.Http.SameSiteMode.None;
        });

        builder.Services.Configure(IdentityConstants.TwoFactorRememberMeScheme, options =>
        {
            options.Cookie.IsEssential = true;
        });

        builder.Services.Configure(IdentityConstants.TwoFactorUserIdScheme, options =>
        {
            options.Cookie.IsEssential = true;
        });

        builder.Services.AddAuthentication(options =>
        {
            if (options.DefaultAuthenticateScheme == null &&
                options.DefaultScheme == IdentityServerConstants.DefaultCookieAuthenticationScheme)
            {
                options.DefaultScheme = IdentityConstants.ApplicationScheme;
            }
        });

        builder.AddResourceOwnerValidator>();
        builder.AddProfileService>();

        return builder;
    }

    internal static void AddTransientDecorator(this IServiceCollection services)
        where TService : class
        where TImplementation : class, TService
    {
        services.AddDecorator();
        services.AddTransient();
    }

    internal static void AddDecorator(this IServiceCollection services)
    {
        var registration = services.LastOrDefault(x => x.ServiceType == typeof(TService));
        if (registration == null)
        {
            throw new InvalidOperationException("Service type: " + typeof(TService).Name + " not registered.");
        }
        if (services.Any(x => x.ServiceType == typeof(Decorator)))
        {
            throw new InvalidOperationException("Decorator already registered for type: " + typeof(TService).Name + ".");
        }

        services.Remove(registration);

        if (registration.ImplementationInstance != null)
        {
            var type = registration.ImplementationInstance.GetType();
            var innerType = typeof(Decorator<,>).MakeGenericType(typeof(TService), type);
            services.Add(new ServiceDescriptor(typeof(Decorator), innerType, ServiceLifetime.Transient));
            services.Add(new ServiceDescriptor(type, registration.ImplementationInstance));
        }
        else if (registration.ImplementationFactory != null)
        {
            services.Add(new ServiceDescriptor(typeof(Decorator), provider =>
            {
                return new DisposableDecorator((TService)registration.ImplementationFactory(provider));
            }, registration.Lifetime));
        }
        else
        {
            var type = registration.ImplementationType;
            var innerType = typeof(Decorator<,>).MakeGenericType(typeof(TService), registration.ImplementationType);
            services.Add(new ServiceDescriptor(typeof(Decorator), innerType, ServiceLifetime.Transient));
            services.Add(new ServiceDescriptor(type, type, registration.Lifetime));
        }
    }
}


================================================
FILE: src/AspNetIdentity/src/ProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.AspNetIdentity;

/// 
/// IProfileService to integrate with ASP.NET Identity.
/// 
/// The type of the user.
/// 
public class ProfileService : IProfileService
    where TUser : class
{
    /// 
    /// The claims factory.
    /// 
    protected readonly IUserClaimsPrincipalFactory ClaimsFactory;
    
    /// 
    /// The logger
    /// 
    protected readonly ILogger> Logger;

    /// 
    /// The user manager.
    /// 
    protected readonly UserManager UserManager;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The user manager.
    /// The claims factory.
    public ProfileService(UserManager userManager,
        IUserClaimsPrincipalFactory claimsFactory)
    {
        UserManager = userManager;
        ClaimsFactory = claimsFactory;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The user manager.
    /// The claims factory.
    /// The logger.
    public ProfileService(UserManager userManager,
        IUserClaimsPrincipalFactory claimsFactory,
        ILogger> logger)
    {
        UserManager = userManager;
        ClaimsFactory = claimsFactory;
        Logger = logger;
    }

    /// 
    /// This method is called whenever claims about the user are requested (e.g. during token creation or via the userinfo endpoint)
    /// 
    /// The context.
    /// 
    public virtual async Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        var sub = context.Subject?.GetSubjectId();
        if (sub == null) throw new Exception("No sub claim present");

        await GetProfileDataAsync(context, sub);
    }

    /// 
    /// Called to get the claims for the subject based on the profile request.
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task GetProfileDataAsync(ProfileDataRequestContext context, string subjectId)
    {
        var user = await FindUserAsync(subjectId);
        if (user != null)
        {
            await GetProfileDataAsync(context, user);
        }
    }

    /// 
    /// Called to get the claims for the user based on the profile request.
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task GetProfileDataAsync(ProfileDataRequestContext context, TUser user)
    {
        var principal = await GetUserClaimsAsync(user);
        context.AddRequestedClaims(principal.Claims);
    }

    /// 
    /// Gets the claims for a user.
    /// 
    /// 
    /// 
    protected virtual async Task GetUserClaimsAsync(TUser user)
    {
        var principal = await ClaimsFactory.CreateAsync(user);
        if (principal == null) throw new Exception("ClaimsFactory failed to create a principal");
        
        return principal;
    }

    /// 
    /// This method gets called whenever identity server needs to determine if the user is valid or active (e.g. if the user's account has been deactivated since they logged in).
    /// (e.g. during token issuance or validation).
    /// 
    /// The context.
    /// 
    public virtual async Task IsActiveAsync(IsActiveContext context)
    {
        var sub = context.Subject?.GetSubjectId();
        if (sub == null) throw new Exception("No subject Id claim present");

        await IsActiveAsync(context, sub);
    }

    /// 
    /// Determines if the subject is active.
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task IsActiveAsync(IsActiveContext context, string subjectId)
    {
        var user = await FindUserAsync(subjectId);
        if (user != null)
        {
            await IsActiveAsync(context, user);
        }
        else
        {
            context.IsActive = false;
        }
    }

    /// 
    /// Determines if the user is active.
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task IsActiveAsync(IsActiveContext context, TUser user)
    {
        context.IsActive = await IsUserActiveAsync(user);
    }

    /// 
    /// Returns if the user is active.
    /// 
    /// 
    /// 
    public virtual Task IsUserActiveAsync(TUser user)
    {
        return Task.FromResult(true);
    }

    /// 
    /// Loads the user by the subject id.
    /// 
    /// 
    /// 
    protected virtual async Task FindUserAsync(string subjectId)
    {
        var user = await UserManager.FindByIdAsync(subjectId);
        if (user == null)
        {
            Logger?.LogWarning("No user found matching subject Id: {subjectId}", subjectId);
        }

        return user;
    }
}


================================================
FILE: src/AspNetIdentity/src/ResourceOwnerPasswordValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.AspNetIdentity;

/// 
/// IResourceOwnerPasswordValidator that integrates with ASP.NET Identity.
/// 
/// The type of the user.
/// 
public class ResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
    where TUser : class
{
    private readonly SignInManager _signInManager;
    private readonly UserManager _userManager;
    private readonly ILogger> _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The user manager.
    /// The sign in manager.
    /// The logger.
    public ResourceOwnerPasswordValidator(
        UserManager userManager,
        SignInManager signInManager,
        ILogger> logger)
    {
        _userManager = userManager;
        _signInManager = signInManager;
        _logger = logger;
    }

    /// 
    /// Validates the resource owner password credential
    /// 
    /// The context.
    /// 
    public virtual async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {
        var user = await _userManager.FindByNameAsync(context.UserName);
        if (user != null)
        {
            var result = await _signInManager.CheckPasswordSignInAsync(user, context.Password, true);
            if (result.Succeeded)
            {
                var sub = await _userManager.GetUserIdAsync(user);

                _logger.LogInformation("Credentials validated for username: {username}", context.UserName);

                context.Result = new GrantValidationResult(sub, AuthenticationMethods.Password);
                return;
            }
            else if (result.IsLockedOut)
            {
                _logger.LogInformation("Authentication failed for username: {username}, reason: locked out", context.UserName);
            }
            else if (result.IsNotAllowed)
            {
                _logger.LogInformation("Authentication failed for username: {username}, reason: not allowed", context.UserName);
            }
            else
            {
                _logger.LogInformation("Authentication failed for username: {username}, reason: invalid credentials", context.UserName);
            }
        }
        else
        {
            _logger.LogInformation("No user found matching username: {username}", context.UserName);
        }

        context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
    }
}


================================================
FILE: src/AspNetIdentity/src/SecurityStampValidatorCallback.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.AspNetIdentity;

/// 
/// Implements callback for SecurityStampValidator's OnRefreshingPrincipal event.
/// 
public class SecurityStampValidatorCallback
{
    /// 
    /// Maintains the claims captured at login time that are not being created by ASP.NET Identity.
    /// This is needed to preserve claims such as idp, auth_time, amr.
    /// 
    /// The context.
    /// 
    public static Task UpdatePrincipal(SecurityStampRefreshingPrincipalContext context)
    {
        var newClaimTypes = context.NewPrincipal.Claims.Select(x => x.Type).ToArray();
        var currentClaimsToKeep = context.CurrentPrincipal.Claims.Where(x => !newClaimTypes.Contains(x.Type)).ToArray();

        var id = context.NewPrincipal.Identities.First();
        id.AddClaims(currentClaimsToKeep);

        return Task.CompletedTask;
    }
}


================================================
FILE: src/AspNetIdentity/src/UserClaimsFactory.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.AspNetIdentity;

internal class UserClaimsFactory : IUserClaimsPrincipalFactory
    where TUser : class
{
    private readonly Decorator> _inner;
    private UserManager _userManager;

    public UserClaimsFactory(Decorator> inner, UserManager userManager)
    {
        _inner = inner;
        _userManager = userManager;
    }

    public async Task CreateAsync(TUser user)
    {
        var principal = await _inner.Instance.CreateAsync(user);
        var identity = principal.Identities.First();

        if (!identity.HasClaim(x => x.Type == JwtClaimTypes.Subject))
        {
            var sub = await _userManager.GetUserIdAsync(user);
            identity.AddClaim(new Claim(JwtClaimTypes.Subject, sub));
        }

        var username = await _userManager.GetUserNameAsync(user);
        var usernameClaim = identity.FindFirst(claim => claim.Type == _userManager.Options.ClaimsIdentity.UserNameClaimType && claim.Value == username);
        if (usernameClaim != null)
        {
            identity.RemoveClaim(usernameClaim);
            identity.AddClaim(new Claim(JwtClaimTypes.PreferredUserName, username));
        }

        if (!identity.HasClaim(x=>x.Type == JwtClaimTypes.Name))
        {
            identity.AddClaim(new Claim(JwtClaimTypes.Name, username));
        }

        if (_userManager.SupportsUserEmail)
        {
            var email = await _userManager.GetEmailAsync(user);
            if (!String.IsNullOrWhiteSpace(email))
            {
                identity.AddClaims(new[]
                {
                    new Claim(JwtClaimTypes.Email, email),
                    new Claim(JwtClaimTypes.EmailVerified,
                        await _userManager.IsEmailConfirmedAsync(user) ? "true" : "false", ClaimValueTypes.Boolean)
                });
            }
        }

        if (_userManager.SupportsUserPhoneNumber)
        {
            var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
            if (!String.IsNullOrWhiteSpace(phoneNumber))
            {
                identity.AddClaims(new[]
                {
                    new Claim(JwtClaimTypes.PhoneNumber, phoneNumber),
                    new Claim(JwtClaimTypes.PhoneNumberVerified,
                        await _userManager.IsPhoneNumberConfirmedAsync(user) ? "true" : "false", ClaimValueTypes.Boolean)
                });
            }
        }

        return principal;
    }
}


================================================
FILE: src/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/Directory.BuildOld.targets
================================================


  
    3.1.0
    3.1.0
    3.1.0
    
    4.1.2-*
  

  
    
    
    
    
    

    
    
    
    
    

    
    

    
    
    
    
    

    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

  

  
    
      $(MinVerMajor).$(MinVerMinor).$(MinVerPatch).0
    
  


================================================
FILE: src/EntityFramework/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/EntityFramework/IdentityServer8.EntityFramework.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.29230.61
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{8BFDA83B-FD73-4776-9C2C-5F7FFE440C1F}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework", "src\IdentityServer8.EntityFramework.csproj", "{AB83F911-8B78-4973-A3A9-2A2D85581F25}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "host\Host.csproj", "{9E9EE58E-4B98-4495-8E8B-00281B3EABDA}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "seeding", "seeding", "{26921EED-9592-4174-94D6-8A0F604029F1}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "migrations\SqlServer\SqlServer.csproj", "{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "tests", "tests", "{19FEB622-0912-4F5E-840F-827B4B9EF026}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "IdentityServer8.EntityFramework.Tests", "test\IdentityServer8.EntityFramework.Tests\IdentityServer8.EntityFramework.Tests.csproj", "{E3685B06-F135-4318-B841-889C35479D5C}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Release|Any CPU.Build.0 = Release|Any CPU
		{9E9EE58E-4B98-4495-8E8B-00281B3EABDA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{9E9EE58E-4B98-4495-8E8B-00281B3EABDA}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{9E9EE58E-4B98-4495-8E8B-00281B3EABDA}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{9E9EE58E-4B98-4495-8E8B-00281B3EABDA}.Release|Any CPU.Build.0 = Release|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Release|Any CPU.Build.0 = Release|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{AB83F911-8B78-4973-A3A9-2A2D85581F25} = {8BFDA83B-FD73-4776-9C2C-5F7FFE440C1F}
		{9E9EE58E-4B98-4495-8E8B-00281B3EABDA} = {8BFDA83B-FD73-4776-9C2C-5F7FFE440C1F}
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69} = {26921EED-9592-4174-94D6-8A0F604029F1}
		{E3685B06-F135-4318-B841-889C35479D5C} = {19FEB622-0912-4F5E-840F-827B4B9EF026}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {A023D63E-FDD1-4984-9746-45981BCFBACA}
	EndGlobalSection
EndGlobal


================================================
FILE: src/EntityFramework/README.md
================================================
# IdentityServer8.EntityFramework

IdentityServer8.EntityFramework is a package that provides the configuration APIs to add persistence for IdentityServer 4 configuration data that uses EntityFramework as its database abstraction.

## Issues

For issues, use the [consolidated IdentityServer8 issue tracker](https://github.com/alexhiggins732/IdentityServer8/issues).


================================================
FILE: src/EntityFramework/build.cmd
================================================
@echo off
dotnet run --project build -- %*

================================================
FILE: src/EntityFramework/build.ps1
================================================
$ErrorActionPreference = "Stop";
dotnet run --project build -- $args

================================================
FILE: src/EntityFramework/build.sh
================================================
#!/usr/bin/env bash
set -euo pipefail
dotnet run --project build -- "$@"

================================================
FILE: src/EntityFramework/dropdb.bat
================================================
cd src\Host
dotnet ef database drop -c PersistedGrantDbContext
dotnet ef database drop -c ConfigurationDbContext
cd ..\..


================================================
FILE: src/EntityFramework/host/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.Options;
global using Newtonsoft.Json;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System.ComponentModel.DataAnnotations;
global using System.Diagnostics;
global using System.Security.Claims;
global using System.Text;
global using ILogger = Microsoft.Extensions.Logging.ILogger;
global using ClaimValueTypes = System.Security.Claims.ClaimValueTypes;


================================================
FILE: src/EntityFramework/host/Host.csproj
================================================




  
    
    
    
    

    
    
    
  




================================================
FILE: src/EntityFramework/host/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost;

public class Program
{
        public static int Main(string[] args)
        {
            Console.Title = "IdentityServer8.EntityFramework";
            Activity.DefaultIdFormat = ActivityIdFormat.W3C;

            Log.Logger = new LoggerConfiguration()
                .MinimumLevel.Debug()
                .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
                .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
                .MinimumLevel.Override("System", LogEventLevel.Warning)
                .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
                .Enrich.FromLogContext()
                //.WriteTo.File(@"IdentityServer8_log.txt")
                // uncomment to write to Azure diagnostics stream
                //.WriteTo.File(
                //    @"D:\home\LogFiles\Application\identityserver.txt",
                //    fileSizeLimitBytes: 1_000_000,
                //    rollOnFileSizeLimit: true,
                //    shared: true,
                //    flushToDiskInterval: TimeSpan.FromSeconds(1))
                .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
                .CreateLogger();

            try
            {
                Log.Information("Starting host...");
                CreateHostBuilder(args).Build().Run();
                return 0;
            }
            catch (Exception ex)
            {
                Log.Fatal(ex, "Host terminated unexpectedly.");
                return 1;
            }
            finally
            {
                Log.CloseAndFlush();
            }
        }

        public static IHostBuilder CreateHostBuilder(string[] args) =>
            Host.CreateDefaultBuilder(args)
                .UseSerilog()
                .ConfigureWebHostDefaults(webBuilder =>
                {
                    webBuilder.UseStartup();
                });
}


================================================
FILE: src/EntityFramework/host/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": true,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:5000",
      "sslPort": 44334
    }
  },
  "profiles": {
    "Host": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001"
    }
  }
}

================================================
FILE: src/EntityFramework/host/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
        private readonly TestUserStore _users;
        private readonly IIdentityServerInteractionService _interaction;
        private readonly IClientStore _clientStore;
        private readonly IAuthenticationSchemeProvider _schemeProvider;
        private readonly IEventService _events;

        public AccountController(
            IIdentityServerInteractionService interaction,
            IClientStore clientStore,
            IAuthenticationSchemeProvider schemeProvider,
            IEventService events,
            TestUserStore users = null)
        {
            // if the TestUserStore is not in DI, then we'll just use the global users collection
            // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
            _users = users ?? new TestUserStore(TestUsers.Users);

            _interaction = interaction;
            _clientStore = clientStore;
            _schemeProvider = schemeProvider;
            _events = events;
        }

        /// 
        /// Entry point into the login workflow
        /// 
        [HttpGet]
        public async Task Login(string returnUrl)
        {
            // build a model so we know what to show on the login page
            var vm = await BuildLoginViewModelAsync(returnUrl);

            if (vm.IsExternalLoginOnly)
            {
                // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
            }

            return View(vm);
        }

        /// 
        /// Handle postback from username/password login
        /// 
        [HttpPost]
        [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
        {
            // check if we are in the context of an authorization request
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

            if (ModelState.IsValid)
            {
                // validate username/password against in-memory store
                if (_users.ValidateCredentials(model.Username, model.Password))
                {
                    var user = _users.FindByUsername(model.Username);
                    await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                    // only set explicit expiration here if user chooses "remember me". 
                    // otherwise we rely upon expiration configured in cookie middleware.
                    AuthenticationProperties props = null;
                    if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                    {
                        props = new AuthenticationProperties
                        {
                            IsPersistent = true,
                            ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                        };
                    };

                    // issue authentication cookie with subject ID and username
                    var isuser = new IdentityServerUser(user.SubjectId)
                    {
                        DisplayName = user.Username
                    };

                    await HttpContext.SignInAsync(isuser, props);

                    if (context != null)
                    {
                        if (context.IsNativeClient())
                        {
                            // The client is native, so this change in how to
                            // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                        }

                        // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // request for a local page
                    if (Url.IsLocalUrl(model.ReturnUrl))
                    {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }
                    else if (string.IsNullOrEmpty(model.ReturnUrl))
                    {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                    }
                    else
                    {
                        // user might have clicked on a malicious link - should be logged
                        throw new Exception("invalid return URL");
                    }
                }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
                ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
            }

            // something went wrong, show form with error
            var vm = await BuildLoginViewModelAsync(model);
            return View(vm);
        }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }
        
        /// 
        /// Show logout page
        /// 
        [HttpGet]
        public async Task Logout(string logoutId)
        {
            // build a model so the logout page knows what to display
            var vm = await BuildLogoutViewModelAsync(logoutId);

            if (vm.ShowLogoutPrompt == false)
            {
                // if the request for logout was properly authenticated from IdentityServer, then
                // we don't need to show the prompt and can just log the user out directly.
                return await Logout(vm);
            }

            return View(vm);
        }

        /// 
        /// Handle logout page postback
        /// 
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task Logout(LogoutInputModel model)
        {
            // build a model so the logged out page knows what to display
            var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

            if (User?.Identity.IsAuthenticated == true)
            {
                // delete local authentication cookie
                await HttpContext.SignOutAsync();

                // raise the logout event
                await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
            }

            // check if we need to trigger sign-out at an upstream identity provider
            if (vm.TriggerExternalSignout)
            {
                // build a return URL so the upstream provider will redirect back
                // to us after the user has logged out. this allows us to then
                // complete our single sign-out processing.
                string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

                // this triggers a redirect to the external provider for sign-out
                return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
            }

            return View("LoggedOut", vm);
        }

        [HttpGet]
        public IActionResult AccessDenied()
        {
            return View();
        }


        /*****************************************/
        /* helper APIs for the AccountController */
        /*****************************************/
        private async Task BuildLoginViewModelAsync(string returnUrl)
        {
            var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
            if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
            {
                var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

                // this is meant to short circuit the UI and only trigger the one external IdP
                var vm = new LoginViewModel
                {
                    EnableLocalLogin = local,
                    ReturnUrl = returnUrl,
                    Username = context?.LoginHint,
                };

                if (!local)
                {
                    vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
                }

                return vm;
            }

            var schemes = await _schemeProvider.GetAllSchemesAsync();

            var providers = schemes
                .Where(x => x.DisplayName != null)
                .Select(x => new ExternalProvider
                {
                    DisplayName = x.DisplayName ?? x.Name,
                    AuthenticationScheme = x.Name
                }).ToList();

            var allowLocal = true;
            if (context?.Client.ClientId != null)
            {
                var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
                if (client != null)
                {
                    allowLocal = client.EnableLocalLogin;

                    if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                    {
                        providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                    }
                }
            }

            return new LoginViewModel
            {
                AllowRememberLogin = AccountOptions.AllowRememberLogin,
                EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
                ExternalProviders = providers.ToArray()
            };
        }

        private async Task BuildLoginViewModelAsync(LoginInputModel model)
        {
            var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
            vm.Username = model.Username;
            vm.RememberLogin = model.RememberLogin;
            return vm;
        }

        private async Task BuildLogoutViewModelAsync(string logoutId)
        {
            var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

            if (User?.Identity.IsAuthenticated != true)
            {
                // if the user is not authenticated, then just show logged out page
                vm.ShowLogoutPrompt = false;
                return vm;
            }

            var context = await _interaction.GetLogoutContextAsync(logoutId);
            if (context?.ShowSignoutPrompt == false)
            {
                // it's safe to automatically sign-out
                vm.ShowLogoutPrompt = false;
                return vm;
            }

            // show the logout prompt. this prevents attacks where the user
            // is automatically signed out by another malicious web page.
            return vm;
        }

        private async Task BuildLoggedOutViewModelAsync(string logoutId)
        {
            // get context information (client name, post logout redirect URI and iframe for federated signout)
            var logout = await _interaction.GetLogoutContextAsync(logoutId);

            var vm = new LoggedOutViewModel
            {
                AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
                PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
                ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
                SignOutIframeUrl = logout?.SignOutIFrameUrl,
                LogoutId = logoutId
            };

            if (User?.Identity.IsAuthenticated == true)
            {
                var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
                if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
                {
                    var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                    if (providerSupportsSignout)
                    {
                        if (vm.LogoutId == null)
                        {
                            // if there's no current logout context, we need to create one
                            // this captures necessary info from the current logged in user
                            // before we signout and redirect away to the external IdP for signout
                            vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                        }

                        vm.ExternalAuthenticationScheme = idp;
                    }
                }
            }

            return vm;
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class AccountOptions
{
    public static bool AllowLocalLogin = true;
    public static bool AllowRememberLogin = true;
    public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

    public static bool ShowLogoutPrompt = true;
    public static bool AutomaticRedirectAfterSignOut = false;

    public static string InvalidCredentialsErrorMessage = "Invalid username or password";
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
        private readonly TestUserStore _users;
        private readonly IIdentityServerInteractionService _interaction;
        private readonly IClientStore _clientStore;
        private readonly ILogger _logger;
        private readonly IEventService _events;

        public ExternalController(
            IIdentityServerInteractionService interaction,
            IClientStore clientStore,
            IEventService events,
            ILogger logger,
            TestUserStore users = null)
        {
            // if the TestUserStore is not in DI, then we'll just use the global users collection
            // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
            _users = users ?? new TestUserStore(TestUsers.Users);

            _interaction = interaction;
            _clientStore = clientStore;
            _logger = logger;
            _events = events;
        }

        /// 
        /// initiate roundtrip to external authentication provider
        /// 
        [HttpGet]
        public IActionResult Challenge(string scheme, string returnUrl)
        {
            if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

            // validate returnUrl - either it is a valid OIDC URL or back to a local page
            if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
            {
                // user might have clicked on a malicious link - should be logged
                throw new Exception("invalid return URL");
            }
            
            // start challenge and roundtrip the return URL and scheme 
            var props = new AuthenticationProperties
            {
                RedirectUri = Url.Action(nameof(Callback)), 
                Items =
                {
                    { "returnUrl", returnUrl }, 
                    { "scheme", scheme },
                }
            };

            return Challenge(props, scheme);
            
        }

        /// 
        /// Post processing of external authentication
        /// 
        [HttpGet]
        public async Task Callback()
        {
            // read external identity from the temporary cookie
            var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
            if (result?.Succeeded != true)
            {
                throw new Exception("External authentication error");
            }

            if (_logger.IsEnabled(LogLevel.Debug))
            {
                var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
                _logger.LogDebug("External claims: {@claims}", externalClaims);
            }

            // lookup our user and external provider info
            var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
            if (user == null)
            {
                // this might be where you might initiate a custom workflow for user registration
                // in this sample we don't show how that would be done, as our sample implementation
                // simply auto-provisions new external user
                user = AutoProvisionUser(provider, providerUserId, claims);
            }

            // this allows us to collect any additional claims or properties
            // for the specific protocols used and store them in the local auth cookie.
            // this is typically used to store data needed for signout from those protocols.
            var additionalLocalClaims = new List();
            var localSignInProps = new AuthenticationProperties();
            ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
            
            // issue authentication cookie for user
            var isuser = new IdentityServerUser(user.SubjectId)
            {
                DisplayName = user.Username,
                IdentityProvider = provider,
                AdditionalClaims = additionalLocalClaims
            };

            await HttpContext.SignInAsync(isuser, localSignInProps);

            // delete temporary cookie used during external authentication
            await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

            // retrieve return URL
            var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

            // check if external login is in the context of an OIDC request
            var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
            await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

            if (context != null)
            {
                if (context.IsNativeClient())
                {
                    // The client is native, so this change in how to
                    // return the response is for better UX for the end user.
                    return this.LoadingPage("Redirect", returnUrl);
                }
            }

            return Redirect(returnUrl);
        }

        private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
        {
            var externalUser = result.Principal;

            // try to determine the unique id of the external user (issued by the provider)
            // the most common claim type for that are the sub claim and the NameIdentifier
            // depending on the external provider, some other claim type might be used
            var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                              externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                              throw new Exception("Unknown userid");

            // remove the user id claim so we don't include it as an extra claim if/when we provision the user
            var claims = externalUser.Claims.ToList();
            claims.Remove(userIdClaim);

            var provider = result.Properties.Items["scheme"];
            var providerUserId = userIdClaim.Value;

            // find external user
            var user = _users.FindByExternalProvider(provider, providerUserId);

            return (user, provider, providerUserId, claims);
        }

        private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
        {
            var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
            return user;
        }

        // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
        // this will be different for WS-Fed, SAML2p or other protocols
        private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
        {
            // if the external system sent a session id claim, copy it over
            // so we can use it for single sign-out
            var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
            if (sid != null)
            {
                localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
            }

            // if the external provider issued an id_token, we'll keep it for signout
            var idToken = externalResult.Properties.GetTokenValue("id_token");
            if (idToken != null)
            {
                localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
        public string LogoutId { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
        public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: src/EntityFramework/host/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
        public string RedirectUrl { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
        private readonly IIdentityServerInteractionService _interaction;
        private readonly IEventService _events;
        private readonly ILogger _logger;

        public ConsentController(
            IIdentityServerInteractionService interaction,
            IEventService events,
            ILogger logger)
        {
            _interaction = interaction;
            _events = events;
            _logger = logger;
        }

        /// 
        /// Shows the consent screen
        /// 
        /// 
        /// 
        [HttpGet]
        public async Task Index(string returnUrl)
        {
            var vm = await BuildViewModelAsync(returnUrl);
            if (vm != null)
            {
                return View("Index", vm);
            }

            return View("Error");
        }

        /// 
        /// Handles the consent screen postback
        /// 
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task Index(ConsentInputModel model)
        {
            var result = await ProcessConsent(model);

            if (result.IsRedirect)
            {
                var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
                if (context?.IsNativeClient() == true)
                {
                    // The client is native, so this change in how to
                    // return the response is for better UX for the end user.
                    return this.LoadingPage("Redirect", result.RedirectUri);
                }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
            }

            if (result.HasValidationError)
            {
                ModelState.AddModelError(string.Empty, result.ValidationError);
            }

            if (result.ShowView)
            {
                return View("Index", result.ViewModel);
            }

            return View("Error");
        }

        /*****************************************/
        /* helper APIs for the ConsentController */
        /*****************************************/
        private async Task ProcessConsent(ConsentInputModel model)
        {
            var result = new ProcessConsentResult();

            // validate return url is still valid
            var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (request == null) return result;

            ConsentResponse grantedConsent = null;

            // user clicked 'no' - send back the standard 'access_denied' response
            if (model?.Button == "no")
            {
                grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

                // emit event
                await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
            }
            // user clicked 'yes' - validate the data
            else if (model?.Button == "yes")
            {
                // if the user consented to some scope, build the response model
                if (model.ScopesConsented != null && model.ScopesConsented.Any())
                {
                    var scopes = model.ScopesConsented;
                    if (ConsentOptions.EnableOfflineAccess == false)
                    {
                        scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                    }

                    grantedConsent = new ConsentResponse
                    {
                        RememberConsent = model.RememberConsent,
                        ScopesValuesConsented = scopes.ToArray(),
                        Description = model.Description
                    };

                    // emit event
                    await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
                }
                else
                {
                    result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
                }
            }
            else
            {
                result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
            }

            if (grantedConsent != null)
            {
                // communicate outcome of consent back to identityserver
                await _interaction.GrantConsentAsync(request, grantedConsent);

                // indicate that's it ok to redirect back to authorization endpoint
                result.RedirectUri = model.ReturnUrl;
                result.Client = request.Client;
            }
            else
            {
                // we need to redisplay the consent UI
                result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
            }

            return result;
        }

        private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
        {
            var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
            if (request != null)
            {
                return CreateConsentViewModel(model, returnUrl, request);
            }
            else
            {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
            }

            return null;
        }

        private ConsentViewModel CreateConsentViewModel(
            ConsentInputModel model, string returnUrl,
            AuthorizationRequest request)
        {
            var vm = new ConsentViewModel
            {
                RememberConsent = model?.RememberConsent ?? true,
                ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
                Description = model?.Description,

                ReturnUrl = returnUrl,

                ClientName = request.Client.ClientName ?? request.Client.ClientId,
                ClientUrl = request.Client.ClientUri,
                ClientLogoUrl = request.Client.LogoUri,
                AllowRememberConsent = request.Client.AllowRememberConsent
            };

            vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

            var apiScopes = new List();
            foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
            {
                var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
                if (apiScope != null)
                {
                    var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                    apiScopes.Add(scopeVm);
                }
            }
            if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
            {
                apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
            }
            vm.ApiScopes = apiScopes;

            return vm;
        }

        private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
        {
            return new ScopeViewModel
            {
                Value = identity.Name,
                DisplayName = identity.DisplayName ?? identity.Name,
                Description = identity.Description,
                Emphasize = identity.Emphasize,
                Required = identity.Required,
                Checked = check || identity.Required
            };
        }

        public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
        {
            var displayName = apiScope.DisplayName ?? apiScope.Name;
            if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
            {
                displayName += ":" + parsedScopeValue.ParsedParameter;
            }

            return new ScopeViewModel
            {
                Value = parsedScopeValue.RawValue,
                DisplayName = displayName,
                Description = apiScope.Description,
                Emphasize = apiScope.Emphasize,
                Required = apiScope.Required,
                Checked = check || apiScope.Required
            };
        }

        private ScopeViewModel GetOfflineAccessScope(bool check)
        {
            return new ScopeViewModel
            {
                Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
                DisplayName = ConsentOptions.OfflineAccessDisplayName,
                Description = ConsentOptions.OfflineAccessDescription,
                Emphasize = true,
                Checked = check
            };
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
        public string Button { get; set; }
        public IEnumerable ScopesConsented { get; set; }
        public bool RememberConsent { get; set; }
        public string ReturnUrl { get; set; }
        public string Description { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
        public static bool EnableOfflineAccess = true;
        public static string OfflineAccessDisplayName = "Offline Access";
        public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

        public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
        public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
        public string ClientName { get; set; }
        public string ClientUrl { get; set; }
        public string ClientLogoUrl { get; set; }
        public bool AllowRememberConsent { get; set; }

        public IEnumerable IdentityScopes { get; set; }
        public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
        public bool IsRedirect => RedirectUri != null;
        public string RedirectUri { get; set; }
        public Client Client { get; set; }

        public bool ShowView => ViewModel != null;
        public ConsentViewModel ViewModel { get; set; }

        public bool HasValidationError => ValidationError != null;
        public string ValidationError { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
        public string Value { get; set; }
        public string DisplayName { get; set; }
        public string Description { get; set; }
        public bool Emphasize { get; set; }
        public bool Required { get; set; }
        public bool Checked { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
        public string UserCode { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
        public string UserCode { get; set; }
        public bool ConfirmUserCode { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
        private readonly IDeviceFlowInteractionService _interaction;
        private readonly IEventService _events;
        private readonly IOptions _options;
        private readonly ILogger _logger;

        public DeviceController(
            IDeviceFlowInteractionService interaction,
            IEventService eventService,
            IOptions options,
            ILogger logger)
        {
            _interaction = interaction;
            _events = eventService;
            _options = options;
            _logger = logger;
        }

        [HttpGet]
        public async Task Index()
        {
            string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
            string userCode = Request.Query[userCodeParamName];
            if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

            var vm = await BuildViewModelAsync(userCode);
            if (vm == null) return View("Error");

            vm.ConfirmUserCode = true;
            return View("UserCodeConfirmation", vm);
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task UserCodeCapture(string userCode)
        {
            var vm = await BuildViewModelAsync(userCode);
            if (vm == null) return View("Error");

            return View("UserCodeConfirmation", vm);
        }

        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task Callback(DeviceAuthorizationInputModel model)
        {
            if (model == null) throw new ArgumentNullException(nameof(model));

            var result = await ProcessConsent(model);
            if (result.HasValidationError) return View("Error");

            return View("Success");
        }

        private async Task ProcessConsent(DeviceAuthorizationInputModel model)
        {
            var result = new ProcessConsentResult();

            var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
            if (request == null) return result;

            ConsentResponse grantedConsent = null;

            // user clicked 'no' - send back the standard 'access_denied' response
            if (model.Button == "no")
            {
                grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

                // emit event
                await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
            }
            // user clicked 'yes' - validate the data
            else if (model.Button == "yes")
            {
                // if the user consented to some scope, build the response model
                if (model.ScopesConsented != null && model.ScopesConsented.Any())
                {
                    var scopes = model.ScopesConsented;
                    if (ConsentOptions.EnableOfflineAccess == false)
                    {
                        scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                    }

                    grantedConsent = new ConsentResponse
                    {
                        RememberConsent = model.RememberConsent,
                        ScopesValuesConsented = scopes.ToArray(),
                        Description = model.Description
                    };

                    // emit event
                    await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
                }
                else
                {
                    result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
                }
            }
            else
            {
                result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
            }

            if (grantedConsent != null)
            {
                // communicate outcome of consent back to identityserver
                await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

                // indicate that's it ok to redirect back to authorization endpoint
                result.RedirectUri = model.ReturnUrl;
                result.Client = request.Client;
            }
            else
            {
                // we need to redisplay the consent UI
                result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
            }

            return result;
        }

        private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
        {
            var request = await _interaction.GetAuthorizationContextAsync(userCode);
            if (request != null)
            {
                return CreateConsentViewModel(userCode, model, request);
            }

            return null;
        }

        private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
        {
            var vm = new DeviceAuthorizationViewModel
            {
                UserCode = userCode,
                Description = model?.Description,

                RememberConsent = model?.RememberConsent ?? true,
                ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

                ClientName = request.Client.ClientName ?? request.Client.ClientId,
                ClientUrl = request.Client.ClientUri,
                ClientLogoUrl = request.Client.LogoUri,
                AllowRememberConsent = request.Client.AllowRememberConsent
            };

            vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

            var apiScopes = new List();
            foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
            {
                var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
                if (apiScope != null)
                {
                    var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                    apiScopes.Add(scopeVm);
                }
            }
            if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
            {
                apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
            }
            vm.ApiScopes = apiScopes;

            return vm;
        }

        private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
        {
            return new ScopeViewModel
            {
                Value = identity.Name,
                DisplayName = identity.DisplayName ?? identity.Name,
                Description = identity.Description,
                Emphasize = identity.Emphasize,
                Required = identity.Required,
                Checked = check || identity.Required
            };
        }

        public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
        {
            return new ScopeViewModel
            {
                Value = parsedScopeValue.RawValue,
                // todo: use the parsed scope value in the display?
                DisplayName = apiScope.DisplayName ?? apiScope.Name,
                Description = apiScope.Description,
                Emphasize = apiScope.Emphasize,
                Required = apiScope.Required,
                Checked = check || apiScope.Required
            };
        }
        private ScopeViewModel GetOfflineAccessScope(bool check)
        {
            return new ScopeViewModel
            {
                Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
                DisplayName = ConsentOptions.OfflineAccessDisplayName,
                Description = ConsentOptions.OfflineAccessDescription,
                Emphasize = true,
                Checked = check
            };
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
        public async Task Index()
        {
            var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
            if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
            {
                return NotFound();
            }

            var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
            return View(model);
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
        public DiagnosticsViewModel(AuthenticateResult result)
        {
            AuthenticateResult = result;

            if (result.Properties.Items.ContainsKey("client_list"))
            {
                var encoded = result.Properties.Items["client_list"];
                var bytes = Base64Url.Decode(encoded);
                var value = Encoding.UTF8.GetString(bytes);

                Clients = JsonConvert.DeserializeObject(value);
            }
        }

        public AuthenticateResult AuthenticateResult { get; }
        public IEnumerable Clients { get; } = new List();
}


================================================
FILE: src/EntityFramework/host/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
        /// 
        /// Checks if the redirect URI is for a native client.
        /// 
        /// 
        public static bool IsNativeClient(this AuthorizationRequest context)
        {
            return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
               && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
        }

        public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
        {
            controller.HttpContext.Response.StatusCode = 200;
            controller.HttpContext.Response.Headers["Location"] = "";
            
            return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
        private readonly IIdentityServerInteractionService _interaction;
        private readonly IClientStore _clients;
        private readonly IResourceStore _resources;
        private readonly IEventService _events;

        public GrantsController(IIdentityServerInteractionService interaction,
            IClientStore clients,
            IResourceStore resources,
            IEventService events)
        {
            _interaction = interaction;
            _clients = clients;
            _resources = resources;
            _events = events;
        }

        /// 
        /// Show list of grants
        /// 
        [HttpGet]
        public async Task Index()
        {
            return View("Index", await BuildViewModelAsync());
        }

        /// 
        /// Handle postback to revoke a client
        /// 
        [HttpPost]
        [ValidateAntiForgeryToken]
        public async Task Revoke(string clientId)
        {
            await _interaction.RevokeUserConsentAsync(clientId);
            await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

            return RedirectToAction("Index");
        }

        private async Task BuildViewModelAsync()
        {
            var grants = await _interaction.GetAllUserGrantsAsync();

            var list = new List();
            foreach(var grant in grants)
            {
                var client = await _clients.FindClientByIdAsync(grant.ClientId);
                if (client != null)
                {
                    var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                    var item = new GrantViewModel()
                    {
                        ClientId = client.ClientId,
                        ClientName = client.ClientName ?? client.ClientId,
                        ClientLogoUrl = client.LogoUri,
                        ClientUrl = client.ClientUri,
                        Description = grant.Description,
                        Created = grant.CreationTime,
                        Expires = grant.Expiration,
                        IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                        ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                    };

                    list.Add(item);
                }
            }

            return new GrantsViewModel
            {
                Grants = list
            };
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
        public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
        public string ClientId { get; set; }
        public string ClientName { get; set; }
        public string ClientUrl { get; set; }
        public string ClientLogoUrl { get; set; }
        public string Description { get; set; }
        public DateTime Created { get; set; }
        public DateTime? Expires { get; set; }
        public IEnumerable IdentityGrantNames { get; set; }
        public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
        public ErrorViewModel()
        {
        }

        public ErrorViewModel(string error)
        {
            Error = new ErrorMessage { Error = error };
        }

        public ErrorMessage Error { get; set; }
}


================================================
FILE: src/EntityFramework/host/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
        private readonly IIdentityServerInteractionService _interaction;
        private readonly IWebHostEnvironment _environment;
        private readonly ILogger _logger;

        public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
        {
            _interaction = interaction;
            _environment = environment;
            _logger = logger;
        }

        public IActionResult Index()
        {
            if (_environment.IsDevelopment())
            {
                // only show in development
                return View();
            }

            _logger.LogInformation("Homepage is disabled in production. Returning 404.");
            return NotFound();
        }

        /// 
        /// Shows the error page
        /// 
        public async Task Error(string errorId)
        {
            var vm = new ErrorViewModel();

            // retrieve error details from identityserver
            var message = await _interaction.GetErrorContextAsync(errorId);
            if (message != null)
            {
                vm.Error = message;

                if (!_environment.IsDevelopment())
                {
                    // only show in development
                    message.ErrorDescription = null;
                }
            }

            return View("Error", vm);
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
        public override void OnResultExecuting(ResultExecutingContext context)
        {
            var result = context.Result;
            if (result is ViewResult)
            {
                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
                if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
                {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
                }

                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
                if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
                {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
                }

                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
                var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
                // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
                //csp += "upgrade-insecure-requests;";
                // also an example if you need client images to be displayed from twitter
                // csp += "img-src 'self' https://pbs.twimg.com;";

                // once for standards compliant browsers
                if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
                {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
                }
                // and once again for IE
                if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
                {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
                }

                // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
                var referrer_policy = "no-referrer";
                if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
                {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: src/EntityFramework/host/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{
    public static List Users
    {
        get
        {
            var address = new
            {
                street_address = "One Hacker Way",
                locality = "Heidelberg",
                postal_code = 69118,
                country = "Germany"
            };

            return new List
    {
                new TestUser
        {
                    SubjectId = "818727",
                    Username = "alice",
                    Password = "alice",
                Claims = 
                {
                    new Claim(JwtClaimTypes.Name, "Alice Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Alice"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "AliceSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                        new Claim(JwtClaimTypes.Address, JsonSerializer.Serialize(address), IdentityServerConstants.ClaimValueTypes.Json)
                }
            },
                new TestUser
                {
                    SubjectId = "88421113",
                    Username = "bob",
                    Password = "bob",
                Claims = 
                {
                    new Claim(JwtClaimTypes.Name, "Bob Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Bob"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                        new Claim(JwtClaimTypes.Address, JsonSerializer.Serialize(address), IdentityServerConstants.ClaimValueTypes.Json)
                }
            }
        };
        }
    }
}


================================================
FILE: src/EntityFramework/host/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;

namespace IdentityServerHost;

public class Startup
{
    private readonly IConfiguration _config;

    public Startup(IConfiguration config)
    {
        _config = config;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews();

        var connectionString = _config.GetConnectionString("db");

        services.AddIdentityServer()
            .AddDeveloperSigningCredential()
            .AddTestUsers(TestUsers.Users)
            // this adds the config data from DB (clients, resources, CORS)
            .AddConfigurationStore(options =>
            {
                options.ConfigureDbContext = builder => builder.UseSqlServer(connectionString);
            })
            // this adds the operational data from DB (codes, tokens, consents)
            .AddOperationalStore(options =>
            {
                options.ConfigureDbContext = builder => builder.UseSqlServer(connectionString);

                // this enables automatic token cleanup. this is optional.
                options.EnableTokenCleanup = true;
                options.TokenCleanupInterval = 5; // interval in seconds, short for testing
            });
        // this is something you will want in production to reduce load on and requests to the DB
        //.AddConfigurationStoreCache();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseDeveloperExceptionPage();

        app.UseStaticFiles();

        app.UseRouting();

        app.UseIdentityServer();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapDefaultControllerRoute();
        });
    }
}


================================================
FILE: src/EntityFramework/host/TestOperationalStoreNotification.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework;
using IdentityServer8.EntityFramework.Entities;
using PersistedGrant = IdentityServer8.EntityFramework.Entities.PersistedGrant;

namespace IdentityServerHost
{
    public class TestOperationalStoreNotification : IOperationalStoreNotification
    {
        public TestOperationalStoreNotification()
        {
            Console.WriteLine("ctor");
        }

        public Task PersistedGrantsRemovedAsync(IEnumerable persistedGrants)
        {
            foreach (var grant in persistedGrants)
            {
                Console.WriteLine("cleaned: " + grant.Type);
            }
            return Task.CompletedTask;
        }

        public Task DeviceCodesRemovedAsync(IEnumerable deviceCodes)
        {
            foreach (var deviceCode in deviceCodes) 
            {
                Console.WriteLine("cleaned device code");
            }
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/EntityFramework/host/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: src/EntityFramework/host/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: src/EntityFramework/host/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: src/EntityFramework/host/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: src/EntityFramework/host/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: src/EntityFramework/host/Views/Home/Index.cshtml
================================================
@using System.Diagnostics
@using System.Reflection

@{
    var version = typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.GetCustomAttribute()?.InformationalVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: src/EntityFramework/host/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: src/EntityFramework/host/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: src/EntityFramework/host/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: src/EntityFramework/host/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: src/EntityFramework/host/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: src/EntityFramework/host/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: src/EntityFramework/host/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: src/EntityFramework/host/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: src/EntityFramework/host/appsettings.json
================================================
{
  "ConnectionStrings": {
    "db": "server=(localdb)\\mssqllocaldb;database=IdentityServer8.EntityFramework-4.0.0;trusted_connection=yes;",
  }
}

================================================
FILE: src/EntityFramework/host/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: src/EntityFramework/host/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: src/EntityFramework/host/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: src/EntityFramework/host/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: src/EntityFramework/migrations/SqlServer/Configuration/Clients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using System.Collections.Generic;

namespace IdentityServerHost.Configuration;

public static class Clients
{
    public static IEnumerable Get()
    {
        var clients = new List();
        
        clients.AddRange(ClientsConsole.Get());
        clients.AddRange(ClientsWeb.Get());

        return clients;
    }
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/Configuration/ClientsConsole.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8;
using IdentityServer8.Models;

namespace IdentityServerHost.Configuration;

public static class ClientsConsole
{
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////////////////////////
            // Console-based Client
            ///////////////////////////////////////////////////////////////


            ///////////////////////////////////////////
            // Console Client Credentials Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1", IdentityServerConstants.LocalApi.ScopeName}
            },
            
            ///////////////////////////////////////////
            // Console Structured Scope Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "parameterized.client",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "transaction" }
            },

            ///////////////////////////////////////////
            // X509 mTLS Client
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mtls",
                ClientSecrets =
                {
                    // new Secret(@"CN=mtls.test, OU=ROO\ballen@roo, O=mkcert development certificate", "mtls.test")
                    // {
                    //     Type = SecretTypes.X509CertificateName
                    // },
                    new Secret("5D9E9B6B333CD42C99D1DE6175CC0F3EF99DDF68", "mtls.test")
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateThumbprint
                    },
                },
                
                AccessTokenType = AccessTokenType.Jwt,
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Client Credentials Flow with client JWT assertion
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.jwt",
                ClientSecrets =
                {
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value =
                            "MIIEgTCCAumgAwIBAgIQDMMu7l/umJhfEbzJMpcttzANBgkqhkiG9w0BAQsFADCBkzEeMBwGA1UEChMVbWtjZXJ0IGRldmVsb3BtZW50IENBMTQwMgYDVQQLDCtkb21pbmlja0Bkb21icDE2LmZyaXR6LmJveCAoRG9taW5pY2sgQmFpZXIpMTswOQYDVQQDDDJta2NlcnQgZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTAeFw0xOTA2MDEwMDAwMDBaFw0zMDAxMDMxMjM0MDdaMHAxJzAlBgNVBAoTHm1rY2VydCBkZXZlbG9wbWVudCBjZXJ0aWZpY2F0ZTE0MDIGA1UECwwrZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTEPMA0GA1UEAxMGY2xpZW50MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvNtpipaS8k1zA6w0Aoy8U4l+8zM4jHhhblExf3PULrMR6RauxniTki8p+P8CsZT4V8A4qo+JwsgpLIHrVQrbt9DEhHfBKzxwHqt+GoHt7byTfTtp8A/5nLhYc/5CW4HiR194gVx5+HAlvt+BriMTb1czvTf+H20dj41yUPsN7nMdyRLF+uXapQYMLYnq2BJIDq83mqGwojHk7d+N6GwoO95jlyas7KSoj8/FvfbaqkRNx0446hqPOzFHKc8er8K5VrLp6tVjh8ZJyY0F0dKgx6yWITsL54ctbj/cCyfuGjWEMbS2XXgc+x/xQMnmpfhK1qQAUn9jg5EzF9n6mQomOwIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEMUlw41YsKZQVls3pEG6CrJk4O8wEQYDVR0RBAowCIIGY2xpZW50MA0GCSqGSIb3DQEBCwUAA4IBgQC0TjNY4Q3Wmw7ggamDImV6HUng3WbYGLYbbL2e3myBrjIxGd1Bi8ZyOu8qeUMIRAbZt2YsSX5S8kx0biaVg2zC+aO5eHhEWMwKB66huInXFjI4wtxZ22r+33fg1R0cLuEUePhftOWrbL0MS4YXVyn9HUMWO4WptG9PJdxNw1UbEB8nw3FkVOdAC9RGqiqalSK+E2UT/kUbTIQ1gPSdQ3nh52mre0H/T9+IRqiozJtNK/CQg4NuEV7rUXHnp7Fmigp6RIJ4TCozglspL341y0rV8M7npU1FYZC2UKNr4ed+GOO1n/sF3LbXDlPXwne99CVVn85wjDaevoR7Md0y2KwE9EggLYcViXNehx4YVv/BjfgqxW8NxiKAxP6kPOZE0XdBrZj2rmcDcGOXCzzYpcduKhFyTOpA0K5RNGC3j1KOUjPVlOtLvjASP7udBEYNfH3mgqXAgqNDOEKi2jG9LITv2IyGUsXhTAsKNJ6A6qiDBzDrvPAYDvsfabPq6tRTwjA="
                    },
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value =
                            "{'e':'AQAB','kid':'ZzAjSnraU3bkWGnnAqLapYGpTyNfLbjbzgAPbbW2GEA','kty':'RSA','n':'wWwQFtSzeRjjerpEM5Rmqz_DsNaZ9S1Bw6UbZkDLowuuTCjBWUax0vBMMxdy6XjEEK4Oq9lKMvx9JzjmeJf1knoqSNrox3Ka0rnxXpNAz6sATvme8p9mTXyp0cX4lF4U2J54xa2_S9NF5QWvpXvBeC4GAJx7QaSw4zrUkrc6XyaAiFnLhQEwKJCwUw4NOqIuYvYp_IXhw-5Ti_icDlZS-282PcccnBeOcX7vc21pozibIdmZJKqXNsL1Ibx5Nkx1F1jLnekJAmdaACDjYRLL_6n3W4wUp19UvzB1lGtXcJKLLkqB6YDiZNu16OSiSprfmrRXvYmvD8m6Fnl5aetgKw'}"
                    }
                },
                
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Custom Grant Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.custom",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = {"custom", "custom.nosubject"},
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    "custom.profile",
                    "resource1.scope1", "resource2.scope1"
                }
            },

            ///////////////////////////////////////////
            // Console Public Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.public",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },

            ///////////////////////////////////////////
            // Console with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "console.pkce",
                ClientName = "Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = {"http://127.0.0.1"},
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },
            ///////////////////////////////////////////
            // WinConsole with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "winconsole",
                ClientName = "Windows Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = {"sample-windows-client://callback"},
                RequireConsent = false,
                AllowOfflineAccess = true,
                AllowedIdentityTokenSigningAlgorithms = {"ES256"},
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            },


            ///////////////////////////////////////////
            // Introspection Client Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.reference",
                ClientSecrets = {new Secret("secret".Sha256())},
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" },
                AccessTokenType = AccessTokenType.Reference
            },
            
            ///////////////////////////////////////////
            // Device Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "device",
                ClientName = "Device Flow Client",

                AllowedGrantTypes = GrantTypes.DeviceFlow,
                RequireClientSecret = false,

                AllowOfflineAccess = true,

                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1", "resource2.scope1"
                }
            }
        };
    }
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/Configuration/ClientsWeb.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8;
using IdentityServer8.Models;

namespace IdentityServerHost.Configuration;

public static class ClientsWeb
{
    static string[] allowedScopes = 
    {
        IdentityServerConstants.StandardScopes.OpenId,
        IdentityServerConstants.StandardScopes.Profile,
        IdentityServerConstants.StandardScopes.Email,
        "resource1.scope1", 
        "resource2.scope1",
        "transaction"
    };
    
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////
            // JS OIDC Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "js_oidc",
                ClientName = "JavaScript OIDC Client",
                ClientUri = "http://identityserver8.io",
                
                AllowedGrantTypes = GrantTypes.Code,
                RequireClientSecret = false,
                
                RedirectUris = 
                {
                    "https://localhost:44300/index.html",
                    "https://localhost:44300/callback.html",
                    "https://localhost:44300/silent.html",
                    "https://localhost:44300/popup.html"
                },

                PostLogoutRedirectUris = { "https://localhost:44300/index.html" },
                AllowedCorsOrigins = { "https://localhost:44300" },

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Automatic Token Management Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.tokenmanagement",
                
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,

                AccessTokenLifetime = 75,

                RedirectUris = { "https://localhost:44301/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44301/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44301/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Code Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.code",
                ClientName = "MVC Code Flow",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                RequireConsent = true,
                AllowedGrantTypes = GrantTypes.Code,

                RedirectUris = { "https://localhost:44302/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44302/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44302/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Hybrid Flow Sample (Back Channel logout)
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.hybrid.backchannel",
                ClientName = "MVC Hybrid (with BackChannel logout)",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Hybrid,
                RequirePkce = false,

                RedirectUris = { "https://localhost:44303/signin-oidc" },
                BackChannelLogoutUri = "https://localhost:44303/logout",
                PostLogoutRedirectUris = { "https://localhost:44303/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            }
        };
    }
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/Configuration/Resources.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityModel;
using IdentityServer8.Models;
using System.Collections.Generic;
using static IdentityServer8.IdentityServerConstants;

namespace IdentityServerHost.Configuration;

public class Resources
{
    // identity resources represent identity data about a user that can be requested via the scope parameter (OpenID Connect)
    public static readonly IEnumerable IdentityResources =
        new[]
        {
            // some standard scopes from the OIDC spec
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email(),

            // custom identity resource with some consolidated claims
            new IdentityResource("custom.profile", new[] { JwtClaimTypes.Name, JwtClaimTypes.Email, "location" })
        };

    // API scopes represent values that describe scope of access and can be requested by the scope parameter (OAuth)
    public static readonly IEnumerable ApiScopes =
        new[]
        {
            // local API scope
            new ApiScope(LocalApi.ScopeName),

            // resource specific scopes
            new ApiScope("resource1.scope1"),
            new ApiScope("resource2.scope1"), 
            
            // a scope without resource association
            new ApiScope("scope3"),
            
            // a scope shared by multiple resources
            new ApiScope("shared.scope"),

            // a parameterized scope
            new ApiScope("transaction", "Transaction")
            {
                Description = "Some Transaction"
            }
        };

    // API resources are more formal representation of a resource with processing rules and their scopes (if any)
    public static readonly IEnumerable ApiResources = 
        new[]
        {
            new ApiResource("resource1", "Resource 1")
            {
                ApiSecrets = { new Secret("secret".Sha256()) },

                Scopes = { "resource1.scope1", "shared.scope" }
            },
            
            // expanded version if more control is needed
            new ApiResource("resource2", "Resource 2")
            {
                ApiSecrets =
                {
                    new Secret("secret".Sha256())
                },

                // additional claims to put into access token
                UserClaims =
                {
                    JwtClaimTypes.Name,
                    JwtClaimTypes.Email
                },

                Scopes = { "resource2.scope1", "shared.scope" }
            }
        };
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore;

namespace SqlServer;

class Program
{
    public static void Main(string[] args)
    {
        var host = BuildWebHost(args);
        SeedData.EnsureSeedData(host.Services);
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup()
            .Build();
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:7603/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "SqlServer": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "http://localhost:7604/"
    }
  }
}

================================================
FILE: src/EntityFramework/migrations/SqlServer/SeedData.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServerHost.Configuration;

namespace SqlServer;

public class SeedData
{
    public static void EnsureSeedData(IServiceProvider serviceProvider)
    {
        using (var scope = serviceProvider.GetRequiredService().CreateScope())
        {
            using (var context = scope.ServiceProvider.GetService())
            {
                EnsureSeedData(context);
            }
        }
    }

    private static void EnsureSeedData(ConfigurationDbContext context)
    {
        Console.WriteLine("Seeding database...");

        if (!context.Clients.Any())
        {
            Console.WriteLine("Clients being populated");
            foreach (var client in Clients.Get())
            {
                context.Clients.Add(client.ToEntity());
            }
            context.SaveChanges();
        }
        else
        {
            Console.WriteLine("Clients already populated");
        }

        if (!context.IdentityResources.Any())
        {
            Console.WriteLine("IdentityResources being populated");
            foreach (var resource in Resources.IdentityResources)
            {
                context.IdentityResources.Add(resource.ToEntity());
            }
            context.SaveChanges();
        }
        else
        {
            Console.WriteLine("IdentityResources already populated");
        }

        if (!context.ApiResources.Any())
        {
            Console.WriteLine("ApiResources being populated");
            foreach (var resource in Resources.ApiResources)
            {
                context.ApiResources.Add(resource.ToEntity());
            }
            context.SaveChanges();
        }
        else
        {
            Console.WriteLine("ApiResources already populated");
        }

        if (!context.ApiScopes.Any())
        {
            Console.WriteLine("Scopes being populated");
            foreach (var resource in Resources.ApiScopes)
            {
                context.ApiScopes.Add(resource.ToEntity());
            }
            context.SaveChanges();
        }
        else
        {
            Console.WriteLine("Scopes already populated");
        }

        Console.WriteLine("Done seeding database.");
        Console.WriteLine();
    }
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/SqlServer.csproj
================================================




  
    

    
  




================================================
FILE: src/EntityFramework/migrations/SqlServer/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;

namespace SqlServer;

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration config)
    {
        Configuration = config;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var cn = Configuration.GetConnectionString("db");

        services.AddIdentityServer()
            .AddConfigurationStore(options => {
                options.ConfigureDbContext = b => b.UseSqlServer(cn);
            })
            .AddOperationalStore(options => {
                options.ConfigureDbContext = b => b.UseSqlServer(cn);
            });
    }

    public void Configure(IApplicationBuilder app)
    {
    }
}


================================================
FILE: src/EntityFramework/migrations/SqlServer/appsettings.json
================================================
{
  "ConnectionStrings": {
    "db": "server=(localdb)\\mssqllocaldb;database=IdentityServer8.EntityFramework-8.0.0;trusted_connection=yes;",
  }
}

================================================
FILE: src/EntityFramework/migrations.bat
================================================
cd host
rmdir /S /Q Migrations

dotnet ef migrations add Grants -c PersistedGrantDbContext -o Migrations/IdentityServer/PersistedGrantDb
dotnet ef migrations add Config -c ConfigurationDbContext -o Migrations/IdentityServer/ConfigurationDb
dotnet ef migrations script -c PersistedGrantDbContext -o Migrations/IdentityServer/PersistedGrantDb.sql
dotnet ef migrations script -c ConfigurationDbContext -o Migrations/IdentityServer/ConfigurationDb.sql

cd ..


================================================
FILE: src/EntityFramework/src/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityServer8.EntityFramework;
global using IdentityServer8.EntityFramework.DbContexts;
global using IdentityServer8.EntityFramework.Interfaces;
global using IdentityServer8.EntityFramework.Options;
global using IdentityServer8.EntityFramework.Services;
global using IdentityServer8.EntityFramework.Storage;
global using IdentityServer8.EntityFramework.Stores;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using Microsoft.AspNetCore.Http;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Hosting;
global using Microsoft.Extensions.Logging;


================================================
FILE: src/EntityFramework/src/IdentityServer8.EntityFramework.csproj
================================================


    
        EntityFramework persistence layer for IdentityServer8
        true
        true
    

    
        True
        True
    

    
        
        
    


================================================
FILE: src/EntityFramework/src/IdentityServerEntityFrameworkBuilderExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Extension methods to add EF database support to IdentityServer.
/// 
public static class IdentityServerEntityFrameworkBuilderExtensions
{
    /// 
    /// Configures EF implementation of IClientStore, IResourceStore, and ICorsPolicyService with IdentityServer.
    /// 
    /// The builder.
    /// The store options action.
    /// 
    public static IIdentityServerBuilder AddConfigurationStore(
        this IIdentityServerBuilder builder,
        Action storeOptionsAction = null)
    {
        return builder.AddConfigurationStore(storeOptionsAction);
    }

    /// 
    /// Configures EF implementation of IClientStore, IResourceStore, and ICorsPolicyService with IdentityServer.
    /// 
    /// The IConfigurationDbContext to use.
    /// The builder.
    /// The store options action.
    /// 
    public static IIdentityServerBuilder AddConfigurationStore(
        this IIdentityServerBuilder builder,
        Action storeOptionsAction = null)
        where TContext : DbContext, IConfigurationDbContext
    {
        builder.Services.AddConfigurationDbContext(storeOptionsAction);

        builder.AddClientStore();
        builder.AddResourceStore();
        builder.AddCorsPolicyService();

        return builder;
    }

    /// 
    /// Configures caching for IClientStore, IResourceStore, and ICorsPolicyService with IdentityServer.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddConfigurationStoreCache(
        this IIdentityServerBuilder builder)
    {
        builder.AddInMemoryCaching();

        // add the caching decorators
        builder.AddClientStoreCache();
        builder.AddResourceStoreCache();
        builder.AddCorsPolicyCache();

        return builder;
    }

    /// 
    /// Configures EF implementation of IPersistedGrantStore with IdentityServer.
    /// 
    /// The builder.
    /// The store options action.
    /// 
    public static IIdentityServerBuilder AddOperationalStore(
        this IIdentityServerBuilder builder,
        Action storeOptionsAction = null)
    {
        return builder.AddOperationalStore(storeOptionsAction);
    }

    /// 
    /// Configures EF implementation of IPersistedGrantStore with IdentityServer.
    /// 
    /// The IPersistedGrantDbContext to use.
    /// The builder.
    /// The store options action.
    /// 
    public static IIdentityServerBuilder AddOperationalStore(
        this IIdentityServerBuilder builder,
        Action storeOptionsAction = null)
        where TContext : DbContext, IPersistedGrantDbContext
    {
        builder.Services.AddOperationalDbContext(storeOptionsAction);

        builder.Services.AddTransient();
        builder.Services.AddTransient();
        builder.Services.AddSingleton();

        return builder;
    }

    /// 
    /// Adds an implementation of the IOperationalStoreNotification to IdentityServer.
    /// 
    /// 
    /// 
    /// 
    public static IIdentityServerBuilder AddOperationalStoreNotification(
       this IIdentityServerBuilder builder)
       where T : class, IOperationalStoreNotification
    {
        builder.Services.AddOperationalStoreNotification();
        return builder;
    }
}


================================================
FILE: src/EntityFramework/src/Services/CorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Services;

/// 
/// Implementation of ICorsPolicyService that consults the client configuration in the database for allowed CORS origins.
/// 
/// 
public class CorsPolicyService : ICorsPolicyService
{
    private readonly IHttpContextAccessor _context;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The context.
    /// The logger.
    /// context
    public CorsPolicyService(IHttpContextAccessor context, ILogger logger)
    {
        _context = context ?? throw new ArgumentNullException(nameof(context));
        _logger = logger;
    }

    /// 
    /// Determines whether origin is allowed.
    /// 
    /// The origin.
    /// 
    public async Task IsOriginAllowedAsync(string origin)
    {
        origin = origin.ToLowerInvariant();

        // doing this here and not in the ctor because: https://github.com/aspnet/CORS/issues/105
        var dbContext = _context.HttpContext.RequestServices.GetRequiredService();

        var query = from o in dbContext.ClientCorsOrigins
                    where o.Origin == origin
                    select o;
        
        var isAllowed = await query.AnyAsync();

        _logger.LogDebug("Origin {origin} is allowed: {originAllowed}", Ioc.Sanitizer.Log.Sanitize(origin), isAllowed);

        return isAllowed;
    }
}


================================================
FILE: src/EntityFramework/src/TokenCleanupHost.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Helper to cleanup expired persisted grants.
/// 
public class TokenCleanupHost : IHostedService
{
    private readonly IServiceProvider _serviceProvider;
    private readonly OperationalStoreOptions _options;
    private readonly ILogger _logger;

    private TimeSpan CleanupInterval => TimeSpan.FromSeconds(_options.TokenCleanupInterval);
    
    private CancellationTokenSource _source;

    /// 
    /// Constructor for TokenCleanupHost.
    /// 
    /// 
    /// 
    /// 
    public TokenCleanupHost(IServiceProvider serviceProvider, OperationalStoreOptions options, ILogger logger)
    {
        _serviceProvider = serviceProvider ?? throw new ArgumentNullException(nameof(serviceProvider));
        _options = options ?? throw new ArgumentNullException(nameof(options));
        _logger = logger;
    }

    /// 
    /// Starts the token cleanup polling.
    /// 
    public Task StartAsync(CancellationToken cancellationToken)
    {
        if (_options.EnableTokenCleanup)
        {
            if (_source != null) throw new InvalidOperationException("Already started. Call Stop first.");

            _logger.LogDebug("Starting grant removal");

            _source = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);

            Task.Factory.StartNew(() => StartInternalAsync(_source.Token));
        }
        
        return Task.CompletedTask;
    }

    /// 
    /// Stops the token cleanup polling.
    /// 
    public Task StopAsync(CancellationToken cancellationToken)
    {
        if (_options.EnableTokenCleanup)
        {
            if (_source == null) throw new InvalidOperationException("Not started. Call Start first.");

            _logger.LogDebug("Stopping grant removal");

            _source.Cancel();
            _source = null;
        }

        return Task.CompletedTask;
    }

    private async Task StartInternalAsync(CancellationToken cancellationToken)
    {
        while (true)
        {
            if (cancellationToken.IsCancellationRequested)
            {
                _logger.LogDebug("CancellationRequested. Exiting.");
                break;
            }

            try
            {
                await Task.Delay(CleanupInterval, cancellationToken);
            }
            catch (TaskCanceledException)
            {
                _logger.LogDebug("TaskCanceledException. Exiting.");
                break;
            }
            catch (Exception ex)
            {
                _logger.LogError("Task.Delay exception: {0}. Exiting.", ex.Message);
                break;
            }

            if (cancellationToken.IsCancellationRequested)
            {
                _logger.LogDebug("CancellationRequested. Exiting.");
                break;
            }

            await RemoveExpiredGrantsAsync();
        }
    }

    async Task RemoveExpiredGrantsAsync()
    {
        try
        {
            using (var serviceScope = _serviceProvider.GetRequiredService().CreateScope())
            {
                var tokenCleanupService = serviceScope.ServiceProvider.GetRequiredService();
                await tokenCleanupService.RemoveExpiredGrantsAsync();
            }
        }
        catch (Exception ex)
        {
            _logger.LogError("Exception removing expired grants: {exception}", ex.Message);
        }
    }
}


================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/DatabaseProviderBuilder.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// Helper methods to initialize DbContextOptions for the specified database provider and context.
/// 
public class DatabaseProviderBuilder
{
    public static DbContextOptions BuildInMemory(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseInMemoryDatabase(name);
        return builder.Options;
    }

    public static DbContextOptions BuildSqlite(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseSqlite($"Filename=./Test.IdentityServer8.EntityFramework-3.1.0.{name}.db");
        return builder.Options;
    }

    public static DbContextOptions BuildLocalDb(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseSqlServer(
            $@"Data Source=(LocalDb)\MSSQLLocalDB;database=Test.IdentityServer8.EntityFramework-3.1.0.{name};trusted_connection=yes;");
        return builder.Options;
    }

    public static DbContextOptions BuildAppVeyorSqlServer2016(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseSqlServer($@"Server=(local)\SQL2016;Database=Test.IdentityServer8.EntityFramework-3.1.0.{name};User ID=sa;Password=Password12!");
        return builder.Options;
    }
}


================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/DatabaseProviderFixture.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.EntityFrameworkCore;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// xUnit ClassFixture for creating and deleting integration test databases.
/// 
/// DbContext of Type T
public class DatabaseProviderFixture : IDisposable where T : DbContext
{
    public object StoreOptions;
    public List> Options;

    public void Dispose()
    {
        if (Options != null) // null check since fixtures are created even when tests are skipped
        {
            foreach (var option in Options.ToList())
            {
                using (var context = (T)Activator.CreateInstance(typeof(T), option, StoreOptions))
                {
                    context.Database.EnsureDeleted();
                }
            }
        }
    }
}


================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/FakeLogger.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.Extensions.Logging;

namespace IdentityServer8.EntityFramework.IntegrationTests;

public class FakeLogger : FakeLogger, ILogger
{
    public static ILogger Create()
    {
        return new FakeLogger();
    }
}

public class FakeLogger : ILogger, IDisposable
{
    public IDisposable BeginScope(TState state)
    {
        return this;
    }

    public void Dispose()
    {
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return false;
    }

    public void Log(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func formatter)
    {
    }
}


================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/IdentityServer8.EntityFramework.Tests.csproj
================================================


  
    false
  

  
    
    
    
    
    
        runtime; build; native; contentfiles; analyzers; buildtransitive
        all
    
      
    
    
  

  
    
  
  
  




================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/IntegrationTest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using System.Runtime.InteropServices;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// Base class for integration tests, responsible for initializing test database providers & an xUnit class fixture
/// 
/// The type of the class.
/// The type of the database context.
/// The type of the store option.
/// 
public class IntegrationTest : IClassFixture>
    where TDbContext : DbContext
{
    public static readonly TheoryData> TestDatabaseProviders;
    protected readonly TStoreOption StoreOptions = Activator.CreateInstance();

    static IntegrationTest()
    {
        var config = new ConfigurationBuilder()
            .AddEnvironmentVariables()
            .Build();

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            Console.WriteLine($"Running Local Tests for {typeof(TClass).Name}");

            TestDatabaseProviders = new TheoryData>
            {
                DatabaseProviderBuilder.BuildInMemory(typeof(TClass).Name),
                DatabaseProviderBuilder.BuildSqlite(typeof(TClass).Name),
                DatabaseProviderBuilder.BuildLocalDb(typeof(TClass).Name)
            };
        }
        else
        {
            TestDatabaseProviders = new TheoryData>
            {
                DatabaseProviderBuilder.BuildInMemory(typeof(TClass).Name),
                DatabaseProviderBuilder.BuildSqlite(typeof(TClass).Name)
            };
            Console.WriteLine("Skipping DB integration tests on non-Windows");
        }
    }

    protected IntegrationTest(DatabaseProviderFixture fixture)
    {
        fixture.Options = TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList();
        fixture.StoreOptions = StoreOptions;
    }
}


================================================
FILE: src/EntityFramework/test/IdentityServer8.EntityFramework.Tests/Services/CorsPolicyServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Interfaces;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Services;
using IdentityServer8.Models;
using Microsoft.AspNetCore.Http;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.Services;

public class CorsPolicyServiceTests : IntegrationTest
{
    public CorsPolicyServiceTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new ConfigurationDbContext(options, StoreOptions))
                context.Database.EnsureCreated();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task IsOriginAllowedAsync_WhenOriginIsAllowed_ExpectTrue(DbContextOptions options)
    {
        const string testCorsOrigin = "https://identityserver8.io/";

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.Clients.Add(new Client
            {
                ClientId = Guid.NewGuid().ToString(),
                ClientName = Guid.NewGuid().ToString(),
                AllowedCorsOrigins = new List { "https://www.identityserver8.com" }
            }.ToEntity());
            context.Clients.Add(new Client
            {
                ClientId = "2",
                ClientName = "2",
                AllowedCorsOrigins = new List { "https://www.identityserver8.com", testCorsOrigin }
            }.ToEntity());
            context.SaveChanges();
        }

        bool result;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var ctx = new DefaultHttpContext();
            var svcs = new ServiceCollection();
            svcs.AddSingleton(context);
            ctx.RequestServices = svcs.BuildServiceProvider();
            var ctxAccessor = new HttpContextAccessor();
            ctxAccessor.HttpContext = ctx;

            var service = new CorsPolicyService(ctxAccessor, FakeLogger.Create());
            result = await service.IsOriginAllowedAsync(testCorsOrigin);
        }

        Assert.True(result);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task IsOriginAllowedAsync_WhenOriginIsNotAllowed_ExpectFalse(DbContextOptions options)
    {
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.Clients.Add(new Client
            {
                ClientId = Guid.NewGuid().ToString(),
                ClientName = Guid.NewGuid().ToString(),
                AllowedCorsOrigins = new List { "https://www.identityserver8.com" }
            }.ToEntity());
            context.SaveChanges();
        }

        bool result;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var ctx = new DefaultHttpContext();
            var svcs = new ServiceCollection();
            svcs.AddSingleton(context);
            ctx.RequestServices = svcs.BuildServiceProvider();
            var ctxAccessor = new HttpContextAccessor();
            ctxAccessor.HttpContext = ctx;

            var service = new CorsPolicyService(ctxAccessor, FakeLogger.Create());
            result = await service.IsOriginAllowedAsync("InvalidOrigin");
        }

        Assert.False(result);
    }
}


================================================
FILE: src/EntityFramework/updatedb.bat
================================================
cd host
dotnet ef database update -c PersistedGrantDbContext
dotnet ef database update -c ConfigurationDbContext
dotnet run /seed
cd ..


================================================
FILE: src/EntityFramework.Storage/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/EntityFramework.Storage/IdentityServer8.EntityFramework.Storage.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 16
VisualStudioVersion = 16.0.30204.135
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{AF5DAC33-08AC-45EE-9772-4FF39FB09E57}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.Storage", "src\IdentityServer8.EntityFramework.Storage.csproj", "{5302DAB3-1662-4956-97AA-5EA5E85B10F6}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{712ED94A-F982-4667-A9CE-E8F21900BBED}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.UnitTests", "test\UnitTests\IdentityServer8.EntityFramework.UnitTests.csproj", "{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.IntegrationTests", "test\IntegrationTests\IdentityServer8.EntityFramework.IntegrationTests.csproj", "{E90F7470-C7F8-464B-9C28-87C474085812}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "migrations", "migrations", "{E3EF31E0-6658-4899-8BDA-FF84355E2FDD}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "migrations\SqlServer\SqlServer.csproj", "{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "host", "host", "{07C56E10-A807-4372-ACD9-ADED2D099BC8}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ConsoleHost", "host\ConsoleHost\ConsoleHost.csproj", "{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|x64.ActiveCfg = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|x64.Build.0 = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|x86.ActiveCfg = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|x86.Build.0 = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|Any CPU.Build.0 = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|x64.ActiveCfg = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|x64.Build.0 = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|x86.ActiveCfg = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|x86.Build.0 = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|x64.ActiveCfg = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|x64.Build.0 = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|x86.ActiveCfg = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|x86.Build.0 = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|Any CPU.Build.0 = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|x64.ActiveCfg = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|x64.Build.0 = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|x86.ActiveCfg = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|x86.Build.0 = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|x64.ActiveCfg = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|x64.Build.0 = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|x86.ActiveCfg = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|x86.Build.0 = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|Any CPU.Build.0 = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|x64.ActiveCfg = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|x64.Build.0 = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|x86.ActiveCfg = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|x86.Build.0 = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|x64.ActiveCfg = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|x64.Build.0 = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|x86.ActiveCfg = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|x86.Build.0 = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|Any CPU.Build.0 = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|x64.ActiveCfg = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|x64.Build.0 = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|x86.ActiveCfg = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|x86.Build.0 = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|x64.ActiveCfg = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|x64.Build.0 = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|x86.ActiveCfg = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|x86.Build.0 = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|Any CPU.Build.0 = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|x64.ActiveCfg = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|x64.Build.0 = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|x86.ActiveCfg = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6} = {AF5DAC33-08AC-45EE-9772-4FF39FB09E57}
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC} = {712ED94A-F982-4667-A9CE-E8F21900BBED}
		{E90F7470-C7F8-464B-9C28-87C474085812} = {712ED94A-F982-4667-A9CE-E8F21900BBED}
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3} = {E3EF31E0-6658-4899-8BDA-FF84355E2FDD}
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5} = {07C56E10-A807-4372-ACD9-ADED2D099BC8}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {4DB894E3-1BF2-4410-911A-14D32FD79A96}
	EndGlobalSection
EndGlobal


================================================
FILE: src/EntityFramework.Storage/README.md
================================================
# IdentityServer8.EntityFramework.Storage

IdentityServer8.EntityFramework.Storage is a persistence layer for IdentityServer 4 configuration data that uses EntityFramework as its database abstraction.

## Issues

For issues, use the [consolidated IdentityServer8 issue tracker](https://github.com/alexhiggins732/IdentityServer8/issues).


================================================
FILE: src/EntityFramework.Storage/build.cmd
================================================
@echo off
dotnet run --project build -- %*

================================================
FILE: src/EntityFramework.Storage/build.ps1
================================================
$ErrorActionPreference = "Stop";
dotnet run --project build -- $args

================================================
FILE: src/EntityFramework.Storage/build.sh
================================================
#!/usr/bin/env bash
set -euo pipefail
dotnet run --project build -- "$@"

================================================
FILE: src/EntityFramework.Storage/host/ConsoleHost/ConsoleHost.csproj
================================================


  
    Exe
  

  
    
    
  

  
    
  




================================================
FILE: src/EntityFramework.Storage/host/ConsoleHost/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityServer8.EntityFramework;
global using IdentityServer8.EntityFramework.Storage;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Logging;

================================================
FILE: src/EntityFramework.Storage/host/ConsoleHost/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace ConsoleHost;

class Program
{
    static void Main(string[] args)
    {
        var connectionString = "server=(localdb)\\mssqllocaldb;database=IdentityServer8.EntityFramework-8.0.0;trusted_connection=yes;";

        var services = new ServiceCollection();
        services.AddLogging(b => b.AddConsole().SetMinimumLevel(LogLevel.Trace));
        services.AddOperationalDbContext(options =>
        {
            options.ConfigureDbContext = builder => builder.UseSqlServer(connectionString);

            // this enables automatic token cleanup. this is optional.
            options.EnableTokenCleanup = false;
            options.TokenCleanupInterval = 5; // interval in seconds, short for testing
        });

        var sp = services.BuildServiceProvider();
        using (var scope = sp.CreateScope())
        {
            var svc = scope.ServiceProvider.GetRequiredService();
            svc.RemoveExpiredGrantsAsync().GetAwaiter().GetResult();
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/host/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/EntityFramework.Storage/migrations/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityServer8.EntityFramework.DbContexts;
global using IdentityServer8.EntityFramework.Storage;
global using Microsoft.AspNetCore;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.EntityFrameworkCore.Infrastructure;
global using Microsoft.EntityFrameworkCore.Metadata;
global using Microsoft.EntityFrameworkCore.Migrations;


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/ConfigurationDb/20200522172542_Config.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.ConfigurationDb
{
    [DbContext(typeof(ConfigurationDbContext))]
    [Migration("20200522172542_Config")]
    partial class Config
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.0")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AllowedAccessTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ApiResourceId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ApiResourceId");

                    b.ToTable("ApiResourceSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("ApiScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("ScopeId")
                        .HasColumnType("int");

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ScopeId");

                    b.ToTable("ApiScopeProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("AbsoluteRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenLifetime")
                        .HasColumnType("int");

                    b.Property("AccessTokenType")
                        .HasColumnType("int");

                    b.Property("AllowAccessTokensViaBrowser")
                        .HasColumnType("bit");

                    b.Property("AllowOfflineAccess")
                        .HasColumnType("bit");

                    b.Property("AllowPlainTextPkce")
                        .HasColumnType("bit");

                    b.Property("AllowRememberConsent")
                        .HasColumnType("bit");

                    b.Property("AllowedIdentityTokenSigningAlgorithms")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("AlwaysIncludeUserClaimsInIdToken")
                        .HasColumnType("bit");

                    b.Property("AlwaysSendClientClaims")
                        .HasColumnType("bit");

                    b.Property("AuthorizationCodeLifetime")
                        .HasColumnType("int");

                    b.Property("BackChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("BackChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ClientClaimsPrefix")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("ConsentLifetime")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DeviceCodeLifetime")
                        .HasColumnType("int");

                    b.Property("EnableLocalLogin")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutSessionRequired")
                        .HasColumnType("bit");

                    b.Property("FrontChannelLogoutUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("IdentityTokenLifetime")
                        .HasColumnType("int");

                    b.Property("IncludeJwtId")
                        .HasColumnType("bit");

                    b.Property("LastAccessed")
                        .HasColumnType("datetime2");

                    b.Property("LogoUri")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("PairWiseSubjectSalt")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ProtocolType")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("RefreshTokenExpiration")
                        .HasColumnType("int");

                    b.Property("RefreshTokenUsage")
                        .HasColumnType("int");

                    b.Property("RequireClientSecret")
                        .HasColumnType("bit");

                    b.Property("RequireConsent")
                        .HasColumnType("bit");

                    b.Property("RequirePkce")
                        .HasColumnType("bit");

                    b.Property("RequireRequestObject")
                        .HasColumnType("bit");

                    b.Property("SlidingRefreshTokenLifetime")
                        .HasColumnType("int");

                    b.Property("UpdateAccessTokenClaimsOnRefresh")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.Property("UserCodeType")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("UserSsoLifetime")
                        .HasColumnType("int");

                    b.HasKey("Id");

                    b.HasIndex("ClientId")
                        .IsUnique();

                    b.ToTable("Clients");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Origin")
                        .IsRequired()
                        .HasColumnType("nvarchar(150)")
                        .HasMaxLength(150);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientCorsOrigins");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("GrantType")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientGrantTypes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Provider")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientIdPRestrictions");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("PostLogoutRedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientPostLogoutRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("RedirectUri")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientRedirectUris");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Scope")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientScopes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("ClientId")
                        .HasColumnType("int");

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(4000)")
                        .HasMaxLength(4000);

                    b.HasKey("Id");

                    b.HasIndex("ClientId");

                    b.ToTable("ClientSecrets");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("Created")
                        .HasColumnType("datetime2");

                    b.Property("Description")
                        .HasColumnType("nvarchar(1000)")
                        .HasMaxLength(1000);

                    b.Property("DisplayName")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Emphasize")
                        .HasColumnType("bit");

                    b.Property("Enabled")
                        .HasColumnType("bit");

                    b.Property("Name")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("NonEditable")
                        .HasColumnType("bit");

                    b.Property("Required")
                        .HasColumnType("bit");

                    b.Property("ShowInDiscoveryDocument")
                        .HasColumnType("bit");

                    b.Property("Updated")
                        .HasColumnType("datetime2");

                    b.HasKey("Id");

                    b.HasIndex("Name")
                        .IsUnique();

                    b.ToTable("IdentityResources");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceClaims");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.Property("Id")
                        .ValueGeneratedOnAdd()
                        .HasColumnType("int")
                        .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                    b.Property("IdentityResourceId")
                        .HasColumnType("int");

                    b.Property("Key")
                        .IsRequired()
                        .HasColumnType("nvarchar(250)")
                        .HasMaxLength(250);

                    b.Property("Value")
                        .IsRequired()
                        .HasColumnType("nvarchar(2000)")
                        .HasMaxLength(2000);

                    b.HasKey("Id");

                    b.HasIndex("IdentityResourceId");

                    b.ToTable("IdentityResourceProperties");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Properties")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Scopes")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                        .WithMany("Secrets")
                        .HasForeignKey("ApiResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("UserClaims")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                        .WithMany("Properties")
                        .HasForeignKey("ScopeId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Claims")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedCorsOrigins")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedGrantTypes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("IdentityProviderRestrictions")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("PostLogoutRedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("Properties")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("RedirectUris")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("AllowedScopes")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                        .WithMany("ClientSecrets")
                        .HasForeignKey("ClientId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("UserClaims")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
                {
                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                        .WithMany("Properties")
                        .HasForeignKey("IdentityResourceId")
                        .OnDelete(DeleteBehavior.Cascade)
                        .IsRequired();
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/ConfigurationDb/20200522172542_Config.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer.Migrations.ConfigurationDb;

public partial class Config : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "ApiResources",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Enabled = table.Column(nullable: false),
                Name = table.Column(maxLength: 200, nullable: false),
                DisplayName = table.Column(maxLength: 200, nullable: true),
                Description = table.Column(maxLength: 1000, nullable: true),
                AllowedAccessTokenSigningAlgorithms = table.Column(maxLength: 100, nullable: true),
                ShowInDiscoveryDocument = table.Column(nullable: false),
                Created = table.Column(nullable: false),
                Updated = table.Column(nullable: true),
                LastAccessed = table.Column(nullable: true),
                NonEditable = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiResources", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "ApiScopes",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Enabled = table.Column(nullable: false),
                Name = table.Column(maxLength: 200, nullable: false),
                DisplayName = table.Column(maxLength: 200, nullable: true),
                Description = table.Column(maxLength: 1000, nullable: true),
                Required = table.Column(nullable: false),
                Emphasize = table.Column(nullable: false),
                ShowInDiscoveryDocument = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiScopes", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "Clients",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Enabled = table.Column(nullable: false),
                ClientId = table.Column(maxLength: 200, nullable: false),
                ProtocolType = table.Column(maxLength: 200, nullable: false),
                RequireClientSecret = table.Column(nullable: false),
                ClientName = table.Column(maxLength: 200, nullable: true),
                Description = table.Column(maxLength: 1000, nullable: true),
                ClientUri = table.Column(maxLength: 2000, nullable: true),
                LogoUri = table.Column(maxLength: 2000, nullable: true),
                RequireConsent = table.Column(nullable: false),
                AllowRememberConsent = table.Column(nullable: false),
                AlwaysIncludeUserClaimsInIdToken = table.Column(nullable: false),
                RequirePkce = table.Column(nullable: false),
                AllowPlainTextPkce = table.Column(nullable: false),
                RequireRequestObject = table.Column(nullable: false),
                AllowAccessTokensViaBrowser = table.Column(nullable: false),
                FrontChannelLogoutUri = table.Column(maxLength: 2000, nullable: true),
                FrontChannelLogoutSessionRequired = table.Column(nullable: false),
                BackChannelLogoutUri = table.Column(maxLength: 2000, nullable: true),
                BackChannelLogoutSessionRequired = table.Column(nullable: false),
                AllowOfflineAccess = table.Column(nullable: false),
                IdentityTokenLifetime = table.Column(nullable: false),
                AllowedIdentityTokenSigningAlgorithms = table.Column(maxLength: 100, nullable: true),
                AccessTokenLifetime = table.Column(nullable: false),
                AuthorizationCodeLifetime = table.Column(nullable: false),
                ConsentLifetime = table.Column(nullable: true),
                AbsoluteRefreshTokenLifetime = table.Column(nullable: false),
                SlidingRefreshTokenLifetime = table.Column(nullable: false),
                RefreshTokenUsage = table.Column(nullable: false),
                UpdateAccessTokenClaimsOnRefresh = table.Column(nullable: false),
                RefreshTokenExpiration = table.Column(nullable: false),
                AccessTokenType = table.Column(nullable: false),
                EnableLocalLogin = table.Column(nullable: false),
                IncludeJwtId = table.Column(nullable: false),
                AlwaysSendClientClaims = table.Column(nullable: false),
                ClientClaimsPrefix = table.Column(maxLength: 200, nullable: true),
                PairWiseSubjectSalt = table.Column(maxLength: 200, nullable: true),
                Created = table.Column(nullable: false),
                Updated = table.Column(nullable: true),
                LastAccessed = table.Column(nullable: true),
                UserSsoLifetime = table.Column(nullable: true),
                UserCodeType = table.Column(maxLength: 100, nullable: true),
                DeviceCodeLifetime = table.Column(nullable: false),
                NonEditable = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_Clients", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "IdentityResources",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Enabled = table.Column(nullable: false),
                Name = table.Column(maxLength: 200, nullable: false),
                DisplayName = table.Column(maxLength: 200, nullable: true),
                Description = table.Column(maxLength: 1000, nullable: true),
                Required = table.Column(nullable: false),
                Emphasize = table.Column(nullable: false),
                ShowInDiscoveryDocument = table.Column(nullable: false),
                Created = table.Column(nullable: false),
                Updated = table.Column(nullable: true),
                NonEditable = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_IdentityResources", x => x.Id);
            });

        migrationBuilder.CreateTable(
            name: "ApiResourceClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Type = table.Column(maxLength: 200, nullable: false),
                ApiResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiResourceClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiResourceClaims_ApiResources_ApiResourceId",
                    column: x => x.ApiResourceId,
                    principalTable: "ApiResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ApiResourceProperties",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Key = table.Column(maxLength: 250, nullable: false),
                Value = table.Column(maxLength: 2000, nullable: false),
                ApiResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiResourceProperties", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiResourceProperties_ApiResources_ApiResourceId",
                    column: x => x.ApiResourceId,
                    principalTable: "ApiResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ApiResourceScopes",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Scope = table.Column(maxLength: 200, nullable: false),
                ApiResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiResourceScopes", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiResourceScopes_ApiResources_ApiResourceId",
                    column: x => x.ApiResourceId,
                    principalTable: "ApiResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ApiResourceSecrets",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Description = table.Column(maxLength: 1000, nullable: true),
                Value = table.Column(maxLength: 4000, nullable: false),
                Expiration = table.Column(nullable: true),
                Type = table.Column(maxLength: 250, nullable: false),
                Created = table.Column(nullable: false),
                ApiResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiResourceSecrets", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiResourceSecrets_ApiResources_ApiResourceId",
                    column: x => x.ApiResourceId,
                    principalTable: "ApiResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ApiScopeClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Type = table.Column(maxLength: 200, nullable: false),
                ScopeId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiScopeClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiScopeClaims_ApiScopes_ScopeId",
                    column: x => x.ScopeId,
                    principalTable: "ApiScopes",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ApiScopeProperties",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Key = table.Column(maxLength: 250, nullable: false),
                Value = table.Column(maxLength: 2000, nullable: false),
                ScopeId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ApiScopeProperties", x => x.Id);
                table.ForeignKey(
                    name: "FK_ApiScopeProperties_ApiScopes_ScopeId",
                    column: x => x.ScopeId,
                    principalTable: "ApiScopes",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Type = table.Column(maxLength: 250, nullable: false),
                Value = table.Column(maxLength: 250, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientClaims_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientCorsOrigins",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Origin = table.Column(maxLength: 150, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientCorsOrigins", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientCorsOrigins_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientGrantTypes",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                GrantType = table.Column(maxLength: 250, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientGrantTypes", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientGrantTypes_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientIdPRestrictions",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Provider = table.Column(maxLength: 200, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientIdPRestrictions", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientIdPRestrictions_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientPostLogoutRedirectUris",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                PostLogoutRedirectUri = table.Column(maxLength: 2000, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientPostLogoutRedirectUris", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientPostLogoutRedirectUris_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientProperties",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Key = table.Column(maxLength: 250, nullable: false),
                Value = table.Column(maxLength: 2000, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientProperties", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientProperties_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientRedirectUris",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                RedirectUri = table.Column(maxLength: 2000, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientRedirectUris", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientRedirectUris_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientScopes",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Scope = table.Column(maxLength: 200, nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientScopes", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientScopes_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "ClientSecrets",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Description = table.Column(maxLength: 2000, nullable: true),
                Value = table.Column(maxLength: 4000, nullable: false),
                Expiration = table.Column(nullable: true),
                Type = table.Column(maxLength: 250, nullable: false),
                Created = table.Column(nullable: false),
                ClientId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_ClientSecrets", x => x.Id);
                table.ForeignKey(
                    name: "FK_ClientSecrets_Clients_ClientId",
                    column: x => x.ClientId,
                    principalTable: "Clients",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "IdentityResourceClaims",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Type = table.Column(maxLength: 200, nullable: false),
                IdentityResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_IdentityResourceClaims", x => x.Id);
                table.ForeignKey(
                    name: "FK_IdentityResourceClaims_IdentityResources_IdentityResourceId",
                    column: x => x.IdentityResourceId,
                    principalTable: "IdentityResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateTable(
            name: "IdentityResourceProperties",
            columns: table => new
            {
                Id = table.Column(nullable: false)
                    .Annotation("SqlServer:Identity", "1, 1"),
                Key = table.Column(maxLength: 250, nullable: false),
                Value = table.Column(maxLength: 2000, nullable: false),
                IdentityResourceId = table.Column(nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_IdentityResourceProperties", x => x.Id);
                table.ForeignKey(
                    name: "FK_IdentityResourceProperties_IdentityResources_IdentityResourceId",
                    column: x => x.IdentityResourceId,
                    principalTable: "IdentityResources",
                    principalColumn: "Id",
                    onDelete: ReferentialAction.Cascade);
            });

        migrationBuilder.CreateIndex(
            name: "IX_ApiResourceClaims_ApiResourceId",
            table: "ApiResourceClaims",
            column: "ApiResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiResourceProperties_ApiResourceId",
            table: "ApiResourceProperties",
            column: "ApiResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiResources_Name",
            table: "ApiResources",
            column: "Name",
            unique: true);

        migrationBuilder.CreateIndex(
            name: "IX_ApiResourceScopes_ApiResourceId",
            table: "ApiResourceScopes",
            column: "ApiResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiResourceSecrets_ApiResourceId",
            table: "ApiResourceSecrets",
            column: "ApiResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiScopeClaims_ScopeId",
            table: "ApiScopeClaims",
            column: "ScopeId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiScopeProperties_ScopeId",
            table: "ApiScopeProperties",
            column: "ScopeId");

        migrationBuilder.CreateIndex(
            name: "IX_ApiScopes_Name",
            table: "ApiScopes",
            column: "Name",
            unique: true);

        migrationBuilder.CreateIndex(
            name: "IX_ClientClaims_ClientId",
            table: "ClientClaims",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientCorsOrigins_ClientId",
            table: "ClientCorsOrigins",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientGrantTypes_ClientId",
            table: "ClientGrantTypes",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientIdPRestrictions_ClientId",
            table: "ClientIdPRestrictions",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientPostLogoutRedirectUris_ClientId",
            table: "ClientPostLogoutRedirectUris",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientProperties_ClientId",
            table: "ClientProperties",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientRedirectUris_ClientId",
            table: "ClientRedirectUris",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_Clients_ClientId",
            table: "Clients",
            column: "ClientId",
            unique: true);

        migrationBuilder.CreateIndex(
            name: "IX_ClientScopes_ClientId",
            table: "ClientScopes",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_ClientSecrets_ClientId",
            table: "ClientSecrets",
            column: "ClientId");

        migrationBuilder.CreateIndex(
            name: "IX_IdentityResourceClaims_IdentityResourceId",
            table: "IdentityResourceClaims",
            column: "IdentityResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_IdentityResourceProperties_IdentityResourceId",
            table: "IdentityResourceProperties",
            column: "IdentityResourceId");

        migrationBuilder.CreateIndex(
            name: "IX_IdentityResources_Name",
            table: "IdentityResources",
            column: "Name",
            unique: true);
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "ApiResourceClaims");

        migrationBuilder.DropTable(
            name: "ApiResourceProperties");

        migrationBuilder.DropTable(
            name: "ApiResourceScopes");

        migrationBuilder.DropTable(
            name: "ApiResourceSecrets");

        migrationBuilder.DropTable(
            name: "ApiScopeClaims");

        migrationBuilder.DropTable(
            name: "ApiScopeProperties");

        migrationBuilder.DropTable(
            name: "ClientClaims");

        migrationBuilder.DropTable(
            name: "ClientCorsOrigins");

        migrationBuilder.DropTable(
            name: "ClientGrantTypes");

        migrationBuilder.DropTable(
            name: "ClientIdPRestrictions");

        migrationBuilder.DropTable(
            name: "ClientPostLogoutRedirectUris");

        migrationBuilder.DropTable(
            name: "ClientProperties");

        migrationBuilder.DropTable(
            name: "ClientRedirectUris");

        migrationBuilder.DropTable(
            name: "ClientScopes");

        migrationBuilder.DropTable(
            name: "ClientSecrets");

        migrationBuilder.DropTable(
            name: "IdentityResourceClaims");

        migrationBuilder.DropTable(
            name: "IdentityResourceProperties");

        migrationBuilder.DropTable(
            name: "ApiResources");

        migrationBuilder.DropTable(
            name: "ApiScopes");

        migrationBuilder.DropTable(
            name: "Clients");

        migrationBuilder.DropTable(
            name: "IdentityResources");
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/ConfigurationDb/ConfigurationDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.ConfigurationDb;

[DbContext(typeof(ConfigurationDbContext))]
partial class ConfigurationDbContextModelSnapshot : ModelSnapshot
{
    protected override void BuildModel(ModelBuilder modelBuilder)
    {
#pragma warning disable 612, 618
        modelBuilder
            .HasAnnotation("ProductVersion", "3.1.0")
            .HasAnnotation("Relational:MaxIdentifierLength", 128)
            .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("AllowedAccessTokenSigningAlgorithms")
                    .HasColumnType("nvarchar(100)")
                    .HasMaxLength(100);

                b.Property("Created")
                    .HasColumnType("datetime2");

                b.Property("Description")
                    .HasColumnType("nvarchar(1000)")
                    .HasMaxLength(1000);

                b.Property("DisplayName")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Enabled")
                    .HasColumnType("bit");

                b.Property("LastAccessed")
                    .HasColumnType("datetime2");

                b.Property("Name")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("NonEditable")
                    .HasColumnType("bit");

                b.Property("ShowInDiscoveryDocument")
                    .HasColumnType("bit");

                b.Property("Updated")
                    .HasColumnType("datetime2");

                b.HasKey("Id");

                b.HasIndex("Name")
                    .IsUnique();

                b.ToTable("ApiResources");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ApiResourceId")
                    .HasColumnType("int");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("ApiResourceId");

                b.ToTable("ApiResourceClaims");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ApiResourceId")
                    .HasColumnType("int");

                b.Property("Key")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("ApiResourceId");

                b.ToTable("ApiResourceProperties");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ApiResourceId")
                    .HasColumnType("int");

                b.Property("Scope")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("ApiResourceId");

                b.ToTable("ApiResourceScopes");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ApiResourceId")
                    .HasColumnType("int");

                b.Property("Created")
                    .HasColumnType("datetime2");

                b.Property("Description")
                    .HasColumnType("nvarchar(1000)")
                    .HasMaxLength(1000);

                b.Property("Expiration")
                    .HasColumnType("datetime2");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(4000)")
                    .HasMaxLength(4000);

                b.HasKey("Id");

                b.HasIndex("ApiResourceId");

                b.ToTable("ApiResourceSecrets");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("Description")
                    .HasColumnType("nvarchar(1000)")
                    .HasMaxLength(1000);

                b.Property("DisplayName")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Emphasize")
                    .HasColumnType("bit");

                b.Property("Enabled")
                    .HasColumnType("bit");

                b.Property("Name")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Required")
                    .HasColumnType("bit");

                b.Property("ShowInDiscoveryDocument")
                    .HasColumnType("bit");

                b.HasKey("Id");

                b.HasIndex("Name")
                    .IsUnique();

                b.ToTable("ApiScopes");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ScopeId")
                    .HasColumnType("int");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("ScopeId");

                b.ToTable("ApiScopeClaims");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("Key")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("ScopeId")
                    .HasColumnType("int");

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("ScopeId");

                b.ToTable("ApiScopeProperties");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("AbsoluteRefreshTokenLifetime")
                    .HasColumnType("int");

                b.Property("AccessTokenLifetime")
                    .HasColumnType("int");

                b.Property("AccessTokenType")
                    .HasColumnType("int");

                b.Property("AllowAccessTokensViaBrowser")
                    .HasColumnType("bit");

                b.Property("AllowOfflineAccess")
                    .HasColumnType("bit");

                b.Property("AllowPlainTextPkce")
                    .HasColumnType("bit");

                b.Property("AllowRememberConsent")
                    .HasColumnType("bit");

                b.Property("AllowedIdentityTokenSigningAlgorithms")
                    .HasColumnType("nvarchar(100)")
                    .HasMaxLength(100);

                b.Property("AlwaysIncludeUserClaimsInIdToken")
                    .HasColumnType("bit");

                b.Property("AlwaysSendClientClaims")
                    .HasColumnType("bit");

                b.Property("AuthorizationCodeLifetime")
                    .HasColumnType("int");

                b.Property("BackChannelLogoutSessionRequired")
                    .HasColumnType("bit");

                b.Property("BackChannelLogoutUri")
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.Property("ClientClaimsPrefix")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ClientId")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ClientName")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ClientUri")
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.Property("ConsentLifetime")
                    .HasColumnType("int");

                b.Property("Created")
                    .HasColumnType("datetime2");

                b.Property("Description")
                    .HasColumnType("nvarchar(1000)")
                    .HasMaxLength(1000);

                b.Property("DeviceCodeLifetime")
                    .HasColumnType("int");

                b.Property("EnableLocalLogin")
                    .HasColumnType("bit");

                b.Property("Enabled")
                    .HasColumnType("bit");

                b.Property("FrontChannelLogoutSessionRequired")
                    .HasColumnType("bit");

                b.Property("FrontChannelLogoutUri")
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.Property("IdentityTokenLifetime")
                    .HasColumnType("int");

                b.Property("IncludeJwtId")
                    .HasColumnType("bit");

                b.Property("LastAccessed")
                    .HasColumnType("datetime2");

                b.Property("LogoUri")
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.Property("NonEditable")
                    .HasColumnType("bit");

                b.Property("PairWiseSubjectSalt")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ProtocolType")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("RefreshTokenExpiration")
                    .HasColumnType("int");

                b.Property("RefreshTokenUsage")
                    .HasColumnType("int");

                b.Property("RequireClientSecret")
                    .HasColumnType("bit");

                b.Property("RequireConsent")
                    .HasColumnType("bit");

                b.Property("RequirePkce")
                    .HasColumnType("bit");

                b.Property("RequireRequestObject")
                    .HasColumnType("bit");

                b.Property("SlidingRefreshTokenLifetime")
                    .HasColumnType("int");

                b.Property("UpdateAccessTokenClaimsOnRefresh")
                    .HasColumnType("bit");

                b.Property("Updated")
                    .HasColumnType("datetime2");

                b.Property("UserCodeType")
                    .HasColumnType("nvarchar(100)")
                    .HasMaxLength(100);

                b.Property("UserSsoLifetime")
                    .HasColumnType("int");

                b.HasKey("Id");

                b.HasIndex("ClientId")
                    .IsUnique();

                b.ToTable("Clients");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientClaims");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Origin")
                    .IsRequired()
                    .HasColumnType("nvarchar(150)")
                    .HasMaxLength(150);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientCorsOrigins");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("GrantType")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientGrantTypes");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Provider")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientIdPRestrictions");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("PostLogoutRedirectUri")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientPostLogoutRedirectUris");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Key")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientProperties");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("RedirectUri")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientRedirectUris");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Scope")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientScopes");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("ClientId")
                    .HasColumnType("int");

                b.Property("Created")
                    .HasColumnType("datetime2");

                b.Property("Description")
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.Property("Expiration")
                    .HasColumnType("datetime2");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(4000)")
                    .HasMaxLength(4000);

                b.HasKey("Id");

                b.HasIndex("ClientId");

                b.ToTable("ClientSecrets");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("Created")
                    .HasColumnType("datetime2");

                b.Property("Description")
                    .HasColumnType("nvarchar(1000)")
                    .HasMaxLength(1000);

                b.Property("DisplayName")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Emphasize")
                    .HasColumnType("bit");

                b.Property("Enabled")
                    .HasColumnType("bit");

                b.Property("Name")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("NonEditable")
                    .HasColumnType("bit");

                b.Property("Required")
                    .HasColumnType("bit");

                b.Property("ShowInDiscoveryDocument")
                    .HasColumnType("bit");

                b.Property("Updated")
                    .HasColumnType("datetime2");

                b.HasKey("Id");

                b.HasIndex("Name")
                    .IsUnique();

                b.ToTable("IdentityResources");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("IdentityResourceId")
                    .HasColumnType("int");

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("Id");

                b.HasIndex("IdentityResourceId");

                b.ToTable("IdentityResourceClaims");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
            {
                b.Property("Id")
                    .ValueGeneratedOnAdd()
                    .HasColumnType("int")
                    .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

                b.Property("IdentityResourceId")
                    .HasColumnType("int");

                b.Property("Key")
                    .IsRequired()
                    .HasColumnType("nvarchar(250)")
                    .HasMaxLength(250);

                b.Property("Value")
                    .IsRequired()
                    .HasColumnType("nvarchar(2000)")
                    .HasMaxLength(2000);

                b.HasKey("Id");

                b.HasIndex("IdentityResourceId");

                b.ToTable("IdentityResourceProperties");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                    .WithMany("UserClaims")
                    .HasForeignKey("ApiResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                    .WithMany("Properties")
                    .HasForeignKey("ApiResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                    .WithMany("Scopes")
                    .HasForeignKey("ApiResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
                    .WithMany("Secrets")
                    .HasForeignKey("ApiResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                    .WithMany("UserClaims")
                    .HasForeignKey("ScopeId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
                    .WithMany("Properties")
                    .HasForeignKey("ScopeId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("Claims")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("AllowedCorsOrigins")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("AllowedGrantTypes")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("IdentityProviderRestrictions")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("PostLogoutRedirectUris")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("Properties")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("RedirectUris")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("AllowedScopes")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
                    .WithMany("ClientSecrets")
                    .HasForeignKey("ClientId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                    .WithMany("UserClaims")
                    .HasForeignKey("IdentityResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
            {
                b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
                    .WithMany("Properties")
                    .HasForeignKey("IdentityResourceId")
                    .OnDelete(DeleteBehavior.Cascade)
                    .IsRequired();
            });
#pragma warning restore 612, 618
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/ConfigurationDb.sql
================================================
IF OBJECT_ID(N'[__EFMigrationsHistory]') IS NULL
BEGIN
    CREATE TABLE [__EFMigrationsHistory] (
        [MigrationId] nvarchar(150) NOT NULL,
        [ProductVersion] nvarchar(32) NOT NULL,
        CONSTRAINT [PK___EFMigrationsHistory] PRIMARY KEY ([MigrationId])
    );
END;

GO

CREATE TABLE [ApiResources] (
    [Id] int NOT NULL IDENTITY,
    [Enabled] bit NOT NULL,
    [Name] nvarchar(200) NOT NULL,
    [DisplayName] nvarchar(200) NULL,
    [Description] nvarchar(1000) NULL,
    [AllowedAccessTokenSigningAlgorithms] nvarchar(100) NULL,
    [ShowInDiscoveryDocument] bit NOT NULL,
    [Created] datetime2 NOT NULL,
    [Updated] datetime2 NULL,
    [LastAccessed] datetime2 NULL,
    [NonEditable] bit NOT NULL,
    CONSTRAINT [PK_ApiResources] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [ApiScopes] (
    [Id] int NOT NULL IDENTITY,
    [Enabled] bit NOT NULL,
    [Name] nvarchar(200) NOT NULL,
    [DisplayName] nvarchar(200) NULL,
    [Description] nvarchar(1000) NULL,
    [Required] bit NOT NULL,
    [Emphasize] bit NOT NULL,
    [ShowInDiscoveryDocument] bit NOT NULL,
    CONSTRAINT [PK_ApiScopes] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [Clients] (
    [Id] int NOT NULL IDENTITY,
    [Enabled] bit NOT NULL,
    [ClientId] nvarchar(200) NOT NULL,
    [ProtocolType] nvarchar(200) NOT NULL,
    [RequireClientSecret] bit NOT NULL,
    [ClientName] nvarchar(200) NULL,
    [Description] nvarchar(1000) NULL,
    [ClientUri] nvarchar(2000) NULL,
    [LogoUri] nvarchar(2000) NULL,
    [RequireConsent] bit NOT NULL,
    [AllowRememberConsent] bit NOT NULL,
    [AlwaysIncludeUserClaimsInIdToken] bit NOT NULL,
    [RequirePkce] bit NOT NULL,
    [AllowPlainTextPkce] bit NOT NULL,
    [RequireRequestObject] bit NOT NULL,
    [AllowAccessTokensViaBrowser] bit NOT NULL,
    [FrontChannelLogoutUri] nvarchar(2000) NULL,
    [FrontChannelLogoutSessionRequired] bit NOT NULL,
    [BackChannelLogoutUri] nvarchar(2000) NULL,
    [BackChannelLogoutSessionRequired] bit NOT NULL,
    [AllowOfflineAccess] bit NOT NULL,
    [IdentityTokenLifetime] int NOT NULL,
    [AllowedIdentityTokenSigningAlgorithms] nvarchar(100) NULL,
    [AccessTokenLifetime] int NOT NULL,
    [AuthorizationCodeLifetime] int NOT NULL,
    [ConsentLifetime] int NULL,
    [AbsoluteRefreshTokenLifetime] int NOT NULL,
    [SlidingRefreshTokenLifetime] int NOT NULL,
    [RefreshTokenUsage] int NOT NULL,
    [UpdateAccessTokenClaimsOnRefresh] bit NOT NULL,
    [RefreshTokenExpiration] int NOT NULL,
    [AccessTokenType] int NOT NULL,
    [EnableLocalLogin] bit NOT NULL,
    [IncludeJwtId] bit NOT NULL,
    [AlwaysSendClientClaims] bit NOT NULL,
    [ClientClaimsPrefix] nvarchar(200) NULL,
    [PairWiseSubjectSalt] nvarchar(200) NULL,
    [Created] datetime2 NOT NULL,
    [Updated] datetime2 NULL,
    [LastAccessed] datetime2 NULL,
    [UserSsoLifetime] int NULL,
    [UserCodeType] nvarchar(100) NULL,
    [DeviceCodeLifetime] int NOT NULL,
    [NonEditable] bit NOT NULL,
    CONSTRAINT [PK_Clients] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [IdentityResources] (
    [Id] int NOT NULL IDENTITY,
    [Enabled] bit NOT NULL,
    [Name] nvarchar(200) NOT NULL,
    [DisplayName] nvarchar(200) NULL,
    [Description] nvarchar(1000) NULL,
    [Required] bit NOT NULL,
    [Emphasize] bit NOT NULL,
    [ShowInDiscoveryDocument] bit NOT NULL,
    [Created] datetime2 NOT NULL,
    [Updated] datetime2 NULL,
    [NonEditable] bit NOT NULL,
    CONSTRAINT [PK_IdentityResources] PRIMARY KEY ([Id])
);

GO

CREATE TABLE [ApiResourceClaims] (
    [Id] int NOT NULL IDENTITY,
    [Type] nvarchar(200) NOT NULL,
    [ApiResourceId] int NOT NULL,
    CONSTRAINT [PK_ApiResourceClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiResourceClaims_ApiResources_ApiResourceId] FOREIGN KEY ([ApiResourceId]) REFERENCES [ApiResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ApiResourceProperties] (
    [Id] int NOT NULL IDENTITY,
    [Key] nvarchar(250) NOT NULL,
    [Value] nvarchar(2000) NOT NULL,
    [ApiResourceId] int NOT NULL,
    CONSTRAINT [PK_ApiResourceProperties] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiResourceProperties_ApiResources_ApiResourceId] FOREIGN KEY ([ApiResourceId]) REFERENCES [ApiResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ApiResourceScopes] (
    [Id] int NOT NULL IDENTITY,
    [Scope] nvarchar(200) NOT NULL,
    [ApiResourceId] int NOT NULL,
    CONSTRAINT [PK_ApiResourceScopes] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiResourceScopes_ApiResources_ApiResourceId] FOREIGN KEY ([ApiResourceId]) REFERENCES [ApiResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ApiResourceSecrets] (
    [Id] int NOT NULL IDENTITY,
    [Description] nvarchar(1000) NULL,
    [Value] nvarchar(4000) NOT NULL,
    [Expiration] datetime2 NULL,
    [Type] nvarchar(250) NOT NULL,
    [Created] datetime2 NOT NULL,
    [ApiResourceId] int NOT NULL,
    CONSTRAINT [PK_ApiResourceSecrets] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiResourceSecrets_ApiResources_ApiResourceId] FOREIGN KEY ([ApiResourceId]) REFERENCES [ApiResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ApiScopeClaims] (
    [Id] int NOT NULL IDENTITY,
    [Type] nvarchar(200) NOT NULL,
    [ScopeId] int NOT NULL,
    CONSTRAINT [PK_ApiScopeClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiScopeClaims_ApiScopes_ScopeId] FOREIGN KEY ([ScopeId]) REFERENCES [ApiScopes] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ApiScopeProperties] (
    [Id] int NOT NULL IDENTITY,
    [Key] nvarchar(250) NOT NULL,
    [Value] nvarchar(2000) NOT NULL,
    [ScopeId] int NOT NULL,
    CONSTRAINT [PK_ApiScopeProperties] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ApiScopeProperties_ApiScopes_ScopeId] FOREIGN KEY ([ScopeId]) REFERENCES [ApiScopes] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientClaims] (
    [Id] int NOT NULL IDENTITY,
    [Type] nvarchar(250) NOT NULL,
    [Value] nvarchar(250) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientClaims_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientCorsOrigins] (
    [Id] int NOT NULL IDENTITY,
    [Origin] nvarchar(150) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientCorsOrigins] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientCorsOrigins_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientGrantTypes] (
    [Id] int NOT NULL IDENTITY,
    [GrantType] nvarchar(250) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientGrantTypes] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientGrantTypes_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientIdPRestrictions] (
    [Id] int NOT NULL IDENTITY,
    [Provider] nvarchar(200) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientIdPRestrictions] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientIdPRestrictions_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientPostLogoutRedirectUris] (
    [Id] int NOT NULL IDENTITY,
    [PostLogoutRedirectUri] nvarchar(2000) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientPostLogoutRedirectUris] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientPostLogoutRedirectUris_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientProperties] (
    [Id] int NOT NULL IDENTITY,
    [Key] nvarchar(250) NOT NULL,
    [Value] nvarchar(2000) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientProperties] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientProperties_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientRedirectUris] (
    [Id] int NOT NULL IDENTITY,
    [RedirectUri] nvarchar(2000) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientRedirectUris] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientRedirectUris_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientScopes] (
    [Id] int NOT NULL IDENTITY,
    [Scope] nvarchar(200) NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientScopes] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientScopes_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [ClientSecrets] (
    [Id] int NOT NULL IDENTITY,
    [Description] nvarchar(2000) NULL,
    [Value] nvarchar(4000) NOT NULL,
    [Expiration] datetime2 NULL,
    [Type] nvarchar(250) NOT NULL,
    [Created] datetime2 NOT NULL,
    [ClientId] int NOT NULL,
    CONSTRAINT [PK_ClientSecrets] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_ClientSecrets_Clients_ClientId] FOREIGN KEY ([ClientId]) REFERENCES [Clients] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [IdentityResourceClaims] (
    [Id] int NOT NULL IDENTITY,
    [Type] nvarchar(200) NOT NULL,
    [IdentityResourceId] int NOT NULL,
    CONSTRAINT [PK_IdentityResourceClaims] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_IdentityResourceClaims_IdentityResources_IdentityResourceId] FOREIGN KEY ([IdentityResourceId]) REFERENCES [IdentityResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE TABLE [IdentityResourceProperties] (
    [Id] int NOT NULL IDENTITY,
    [Key] nvarchar(250) NOT NULL,
    [Value] nvarchar(2000) NOT NULL,
    [IdentityResourceId] int NOT NULL,
    CONSTRAINT [PK_IdentityResourceProperties] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_IdentityResourceProperties_IdentityResources_IdentityResourceId] FOREIGN KEY ([IdentityResourceId]) REFERENCES [IdentityResources] ([Id]) ON DELETE CASCADE
);

GO

CREATE INDEX [IX_ApiResourceClaims_ApiResourceId] ON [ApiResourceClaims] ([ApiResourceId]);

GO

CREATE INDEX [IX_ApiResourceProperties_ApiResourceId] ON [ApiResourceProperties] ([ApiResourceId]);

GO

CREATE UNIQUE INDEX [IX_ApiResources_Name] ON [ApiResources] ([Name]);

GO

CREATE INDEX [IX_ApiResourceScopes_ApiResourceId] ON [ApiResourceScopes] ([ApiResourceId]);

GO

CREATE INDEX [IX_ApiResourceSecrets_ApiResourceId] ON [ApiResourceSecrets] ([ApiResourceId]);

GO

CREATE INDEX [IX_ApiScopeClaims_ScopeId] ON [ApiScopeClaims] ([ScopeId]);

GO

CREATE INDEX [IX_ApiScopeProperties_ScopeId] ON [ApiScopeProperties] ([ScopeId]);

GO

CREATE UNIQUE INDEX [IX_ApiScopes_Name] ON [ApiScopes] ([Name]);

GO

CREATE INDEX [IX_ClientClaims_ClientId] ON [ClientClaims] ([ClientId]);

GO

CREATE INDEX [IX_ClientCorsOrigins_ClientId] ON [ClientCorsOrigins] ([ClientId]);

GO

CREATE INDEX [IX_ClientGrantTypes_ClientId] ON [ClientGrantTypes] ([ClientId]);

GO

CREATE INDEX [IX_ClientIdPRestrictions_ClientId] ON [ClientIdPRestrictions] ([ClientId]);

GO

CREATE INDEX [IX_ClientPostLogoutRedirectUris_ClientId] ON [ClientPostLogoutRedirectUris] ([ClientId]);

GO

CREATE INDEX [IX_ClientProperties_ClientId] ON [ClientProperties] ([ClientId]);

GO

CREATE INDEX [IX_ClientRedirectUris_ClientId] ON [ClientRedirectUris] ([ClientId]);

GO

CREATE UNIQUE INDEX [IX_Clients_ClientId] ON [Clients] ([ClientId]);

GO

CREATE INDEX [IX_ClientScopes_ClientId] ON [ClientScopes] ([ClientId]);

GO

CREATE INDEX [IX_ClientSecrets_ClientId] ON [ClientSecrets] ([ClientId]);

GO

CREATE INDEX [IX_IdentityResourceClaims_IdentityResourceId] ON [IdentityResourceClaims] ([IdentityResourceId]);

GO

CREATE INDEX [IX_IdentityResourceProperties_IdentityResourceId] ON [IdentityResourceProperties] ([IdentityResourceId]);

GO

CREATE UNIQUE INDEX [IX_IdentityResources_Name] ON [IdentityResources] ([Name]);

GO

INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
VALUES (N'20200522172542_Config', N'3.1.0');

GO



================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/PersistedGrantDb/20200522172538_Grants.Designer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.PersistedGrantDb
{
    [DbContext(typeof(PersistedGrantDbContext))]
    [Migration("20200522172538_Grants")]
    partial class Grants
    {
        protected override void BuildTargetModel(ModelBuilder modelBuilder)
        {
#pragma warning disable 612, 618
            modelBuilder
                .HasAnnotation("ProductVersion", "3.1.0")
                .HasAnnotation("Relational:MaxIdentifierLength", 128)
                .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.DeviceFlowCodes", b =>
                {
                    b.Property("UserCode")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("DeviceCode")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .IsRequired()
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.HasKey("UserCode");

                    b.HasIndex("DeviceCode")
                        .IsUnique();

                    b.HasIndex("Expiration");

                    b.ToTable("DeviceCodes");
                });

            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.PersistedGrant", b =>
                {
                    b.Property("Key")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ClientId")
                        .IsRequired()
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("ConsumedTime")
                        .HasColumnType("datetime2");

                    b.Property("CreationTime")
                        .HasColumnType("datetime2");

                    b.Property("Data")
                        .IsRequired()
                        .HasColumnType("nvarchar(max)")
                        .HasMaxLength(50000);

                    b.Property("Description")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Expiration")
                        .HasColumnType("datetime2");

                    b.Property("SessionId")
                        .HasColumnType("nvarchar(100)")
                        .HasMaxLength(100);

                    b.Property("SubjectId")
                        .HasColumnType("nvarchar(200)")
                        .HasMaxLength(200);

                    b.Property("Type")
                        .IsRequired()
                        .HasColumnType("nvarchar(50)")
                        .HasMaxLength(50);

                    b.HasKey("Key");

                    b.HasIndex("Expiration");

                    b.HasIndex("SubjectId", "ClientId", "Type");

                    b.HasIndex("SubjectId", "SessionId", "Type");

                    b.ToTable("PersistedGrants");
                });
#pragma warning restore 612, 618
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/PersistedGrantDb/20200522172538_Grants.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer.Migrations.PersistedGrantDb;

public partial class Grants : Migration
{
    protected override void Up(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.CreateTable(
            name: "DeviceCodes",
            columns: table => new
            {
                UserCode = table.Column(maxLength: 200, nullable: false),
                DeviceCode = table.Column(maxLength: 200, nullable: false),
                SubjectId = table.Column(maxLength: 200, nullable: true),
                SessionId = table.Column(maxLength: 100, nullable: true),
                ClientId = table.Column(maxLength: 200, nullable: false),
                Description = table.Column(maxLength: 200, nullable: true),
                CreationTime = table.Column(nullable: false),
                Expiration = table.Column(nullable: false),
                Data = table.Column(maxLength: 50000, nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_DeviceCodes", x => x.UserCode);
            });

        migrationBuilder.CreateTable(
            name: "PersistedGrants",
            columns: table => new
            {
                Key = table.Column(maxLength: 200, nullable: false),
                Type = table.Column(maxLength: 50, nullable: false),
                SubjectId = table.Column(maxLength: 200, nullable: true),
                SessionId = table.Column(maxLength: 100, nullable: true),
                ClientId = table.Column(maxLength: 200, nullable: false),
                Description = table.Column(maxLength: 200, nullable: true),
                CreationTime = table.Column(nullable: false),
                Expiration = table.Column(nullable: true),
                ConsumedTime = table.Column(nullable: true),
                Data = table.Column(maxLength: 50000, nullable: false)
            },
            constraints: table =>
            {
                table.PrimaryKey("PK_PersistedGrants", x => x.Key);
            });

        migrationBuilder.CreateIndex(
            name: "IX_DeviceCodes_DeviceCode",
            table: "DeviceCodes",
            column: "DeviceCode",
            unique: true);

        migrationBuilder.CreateIndex(
            name: "IX_DeviceCodes_Expiration",
            table: "DeviceCodes",
            column: "Expiration");

        migrationBuilder.CreateIndex(
            name: "IX_PersistedGrants_Expiration",
            table: "PersistedGrants",
            column: "Expiration");

        migrationBuilder.CreateIndex(
            name: "IX_PersistedGrants_SubjectId_ClientId_Type",
            table: "PersistedGrants",
            columns: new[] { "SubjectId", "ClientId", "Type" });

        migrationBuilder.CreateIndex(
            name: "IX_PersistedGrants_SubjectId_SessionId_Type",
            table: "PersistedGrants",
            columns: new[] { "SubjectId", "SessionId", "Type" });
    }

    protected override void Down(MigrationBuilder migrationBuilder)
    {
        migrationBuilder.DropTable(
            name: "DeviceCodes");

        migrationBuilder.DropTable(
            name: "PersistedGrants");
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/PersistedGrantDb/PersistedGrantDbContextModelSnapshot.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

// 

namespace SqlServer.Migrations.PersistedGrantDb;

[DbContext(typeof(PersistedGrantDbContext))]
partial class PersistedGrantDbContextModelSnapshot : ModelSnapshot
{
    protected override void BuildModel(ModelBuilder modelBuilder)
    {
#pragma warning disable 612, 618
        modelBuilder
            .HasAnnotation("ProductVersion", "3.1.0")
            .HasAnnotation("Relational:MaxIdentifierLength", 128)
            .HasAnnotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn);

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.DeviceFlowCodes", b =>
            {
                b.Property("UserCode")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ClientId")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("CreationTime")
                    .HasColumnType("datetime2");

                b.Property("Data")
                    .IsRequired()
                    .HasColumnType("nvarchar(max)")
                    .HasMaxLength(50000);

                b.Property("Description")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("DeviceCode")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Expiration")
                    .IsRequired()
                    .HasColumnType("datetime2");

                b.Property("SessionId")
                    .HasColumnType("nvarchar(100)")
                    .HasMaxLength(100);

                b.Property("SubjectId")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.HasKey("UserCode");

                b.HasIndex("DeviceCode")
                    .IsUnique();

                b.HasIndex("Expiration");

                b.ToTable("DeviceCodes");
            });

        modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.PersistedGrant", b =>
            {
                b.Property("Key")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ClientId")
                    .IsRequired()
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("ConsumedTime")
                    .HasColumnType("datetime2");

                b.Property("CreationTime")
                    .HasColumnType("datetime2");

                b.Property("Data")
                    .IsRequired()
                    .HasColumnType("nvarchar(max)")
                    .HasMaxLength(50000);

                b.Property("Description")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Expiration")
                    .HasColumnType("datetime2");

                b.Property("SessionId")
                    .HasColumnType("nvarchar(100)")
                    .HasMaxLength(100);

                b.Property("SubjectId")
                    .HasColumnType("nvarchar(200)")
                    .HasMaxLength(200);

                b.Property("Type")
                    .IsRequired()
                    .HasColumnType("nvarchar(50)")
                    .HasMaxLength(50);

                b.HasKey("Key");

                b.HasIndex("Expiration");

                b.HasIndex("SubjectId", "ClientId", "Type");

                b.HasIndex("SubjectId", "SessionId", "Type");

                b.ToTable("PersistedGrants");
            });
#pragma warning restore 612, 618
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Migrations/PersistedGrantDb.sql
================================================
IF OBJECT_ID(N'[__EFMigrationsHistory]') IS NULL
BEGIN
    CREATE TABLE [__EFMigrationsHistory] (
        [MigrationId] nvarchar(150) NOT NULL,
        [ProductVersion] nvarchar(32) NOT NULL,
        CONSTRAINT [PK___EFMigrationsHistory] PRIMARY KEY ([MigrationId])
    );
END;

GO

CREATE TABLE [DeviceCodes] (
    [UserCode] nvarchar(200) NOT NULL,
    [DeviceCode] nvarchar(200) NOT NULL,
    [SubjectId] nvarchar(200) NULL,
    [SessionId] nvarchar(100) NULL,
    [ClientId] nvarchar(200) NOT NULL,
    [Description] nvarchar(200) NULL,
    [CreationTime] datetime2 NOT NULL,
    [Expiration] datetime2 NOT NULL,
    [Data] nvarchar(max) NOT NULL,
    CONSTRAINT [PK_DeviceCodes] PRIMARY KEY ([UserCode])
);

GO

CREATE TABLE [PersistedGrants] (
    [Key] nvarchar(200) NOT NULL,
    [Type] nvarchar(50) NOT NULL,
    [SubjectId] nvarchar(200) NULL,
    [SessionId] nvarchar(100) NULL,
    [ClientId] nvarchar(200) NOT NULL,
    [Description] nvarchar(200) NULL,
    [CreationTime] datetime2 NOT NULL,
    [Expiration] datetime2 NULL,
    [ConsumedTime] datetime2 NULL,
    [Data] nvarchar(max) NOT NULL,
    CONSTRAINT [PK_PersistedGrants] PRIMARY KEY ([Key])
);

GO

CREATE UNIQUE INDEX [IX_DeviceCodes_DeviceCode] ON [DeviceCodes] ([DeviceCode]);

GO

CREATE INDEX [IX_DeviceCodes_Expiration] ON [DeviceCodes] ([Expiration]);

GO

CREATE INDEX [IX_PersistedGrants_Expiration] ON [PersistedGrants] ([Expiration]);

GO

CREATE INDEX [IX_PersistedGrants_SubjectId_ClientId_Type] ON [PersistedGrants] ([SubjectId], [ClientId], [Type]);

GO

CREATE INDEX [IX_PersistedGrants_SubjectId_SessionId_Type] ON [PersistedGrants] ([SubjectId], [SessionId], [Type]);

GO

INSERT INTO [__EFMigrationsHistory] ([MigrationId], [ProductVersion])
VALUES (N'20200522172538_Grants', N'3.1.0');

GO



================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer;

class Program
{
    public static void Main(string[] args)
    {
    }

    public static IWebHost BuildWebHost(string[] args) =>
        WebHost.CreateDefaultBuilder(args)
            .UseStartup()
            .Build();
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Properties/launchSettings.json
================================================
{
  "iisSettings": {
    "windowsAuthentication": false,
    "anonymousAuthentication": true,
    "iisExpress": {
      "applicationUrl": "http://localhost:7603/",
      "sslPort": 0
    }
  },
  "profiles": {
    "IIS Express": {
      "commandName": "IISExpress",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      }
    },
    "SqlServer": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "http://localhost:7604/"
    }
  }
}

================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/SqlServer.csproj
================================================


  
    
    
    
  
  


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace SqlServer;

public class Startup
{
    public IConfiguration Configuration { get; }

    public Startup(IConfiguration config)
    {
        Configuration = config;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var cn = Configuration.GetConnectionString("db");

        services.AddOperationalDbContext(options => {
            options.ConfigureDbContext = b =>
                b.UseSqlServer(cn, dbOpts => dbOpts.MigrationsAssembly(typeof(Startup).Assembly.FullName));
        });

        services.AddConfigurationDbContext(options => {
            options.ConfigureDbContext = b =>
                b.UseSqlServer(cn, dbOpts => dbOpts.MigrationsAssembly(typeof(Startup).Assembly.FullName));
        });
    }

    public void Configure(IApplicationBuilder app)
    {
    }
}


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/appsettings.json
================================================
{
  "ConnectionStrings": {
    "db": "server=(localdb)\\mssqllocaldb;database=IdentityServer8.EntityFramework-8.0.0;trusted_connection=yes;",
    //"db": "Data Source=IdentityServer.db;"
  }
}

================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/buildschema.bat
================================================
rmdir /S /Q Migrations

dotnet ef migrations add Grants -c PersistedGrantDbContext -o Migrations/PersistedGrantDb
dotnet ef migrations add Configuration -c ConfigurationDbContext -o Migrations/ConfigurationDb

dotnet ef migrations script -c PersistedGrantDbContext -o Migrations/PersistedGrantDb.sql
dotnet ef migrations script -c ConfigurationDbContext -o Migrations/ConfigurationDb.sql


================================================
FILE: src/EntityFramework.Storage/migrations/SqlServer/createdb.bat
================================================
dotnet ef database update -c PersistedGrantDbContext
dotnet ef database update -c ConfigurationDbContext 


================================================
FILE: src/EntityFramework.Storage/src/Configuration/ServiceCollectionExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Storage
{
    /// 
    /// Extension methods to add EF database support to IdentityServer.
    /// 
    public static class IdentityServerEntityFrameworkBuilderExtensions
    {
        /// 
        /// Add Configuration DbContext to the DI system.
        /// 
        /// 
        /// The store options action.
        /// 
        public static IServiceCollection AddConfigurationDbContext(this IServiceCollection services,
            Action storeOptionsAction = null)
        {
            return services.AddConfigurationDbContext(storeOptionsAction);
        }

        /// 
        /// Add Configuration DbContext to the DI system.
        /// 
        /// The IConfigurationDbContext to use.
        /// 
        /// The store options action.
        /// 
        public static IServiceCollection AddConfigurationDbContext(this IServiceCollection services,
        Action storeOptionsAction = null)
        where TContext : DbContext, IConfigurationDbContext
        {
            var options = new ConfigurationStoreOptions();
            services.AddSingleton(options);
            storeOptionsAction?.Invoke(options);

            if (options.ResolveDbContextOptions != null)
            {
                services.AddDbContext(options.ResolveDbContextOptions);
            }
            else
            {
                services.AddDbContext(dbCtxBuilder =>
                {
                    options.ConfigureDbContext?.Invoke(dbCtxBuilder);
                });
            }
            services.AddScoped();

            return services;
        }

        /// 
        /// Adds operational DbContext to the DI system.
        /// 
        /// 
        /// The store options action.
        /// 
        public static IServiceCollection AddOperationalDbContext(this IServiceCollection services,
            Action storeOptionsAction = null)
        {
            return services.AddOperationalDbContext(storeOptionsAction);
        }

        /// 
        /// Adds operational DbContext to the DI system.
        /// 
        /// The IPersistedGrantDbContext to use.
        /// 
        /// The store options action.
        /// 
        public static IServiceCollection AddOperationalDbContext(this IServiceCollection services,
            Action storeOptionsAction = null)
            where TContext : DbContext, IPersistedGrantDbContext
        {
            var storeOptions = new OperationalStoreOptions();
            services.AddSingleton(storeOptions);
            storeOptionsAction?.Invoke(storeOptions);

            if (storeOptions.ResolveDbContextOptions != null)
            {
                services.AddDbContext(storeOptions.ResolveDbContextOptions);
            }
            else
            {
                services.AddDbContext(dbCtxBuilder =>
                {
                    storeOptions.ConfigureDbContext?.Invoke(dbCtxBuilder);
                });
            }

            services.AddScoped();
            services.AddTransient();

            return services;
        }

        /// 
        /// Adds an implementation of the IOperationalStoreNotification to the DI system.
        /// 
        /// 
        /// 
        /// 
        public static IServiceCollection AddOperationalStoreNotification(this IServiceCollection services)
           where T : class, IOperationalStoreNotification
        {
            services.AddTransient();
            return services;
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/DbContexts/ConfigurationDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.DbContexts
{
    /// 
    /// DbContext for the IdentityServer configuration data.
    /// 
    /// 
    /// 
    public class ConfigurationDbContext : ConfigurationDbContext
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The options.
        /// The store options.
        /// storeOptions
        public ConfigurationDbContext(DbContextOptions options, ConfigurationStoreOptions storeOptions)
            : base(options, storeOptions)
        {
        }
    }

    /// 
    /// DbContext for the IdentityServer configuration data.
    /// 
    /// 
    /// 
    public class ConfigurationDbContext : DbContext, IConfigurationDbContext
        where TContext : DbContext, IConfigurationDbContext
    {
        private readonly ConfigurationStoreOptions storeOptions;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The options.
        /// The store options.
        /// storeOptions
        public ConfigurationDbContext(DbContextOptions options, ConfigurationStoreOptions storeOptions)
            : base(options)
        {
            this.storeOptions = storeOptions ?? throw new ArgumentNullException(nameof(storeOptions));
        }

        /// 
        /// Gets or sets the clients.
        /// 
        /// 
        /// The clients.
        /// 
        public DbSet Clients { get; set; }

        /// 
        /// Gets or sets the clients' CORS origins.
        /// 
        /// 
        /// The clients CORS origins.
        /// 
        public DbSet ClientCorsOrigins { get; set; }

        /// 
        /// Gets or sets the identity resources.
        /// 
        /// 
        /// The identity resources.
        /// 
        public DbSet IdentityResources { get; set; }

        /// 
        /// Gets or sets the API resources.
        /// 
        /// 
        /// The API resources.
        /// 
        public DbSet ApiResources { get; set; }

        /// 
        /// Gets or sets the API scopes.
        /// 
        /// 
        /// The API resources.
        /// 
        public DbSet ApiScopes { get; set; }

        /// 
        /// Override this method to further configure the model that was discovered by convention from the entity types
        /// exposed in  properties on your derived context. The resulting model may be cached
        /// and re-used for subsequent instances of your derived context.
        /// 
        /// The builder being used to construct the model for this context. Databases (and other extensions) typically
        /// define extension methods on this object that allow you to configure aspects of the model that are specific
        /// to a given database.
        /// 
        /// If a model is explicitly set on the options for this context (via )
        /// then this method will not be run.
        /// 
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.ConfigureClientContext(storeOptions);
            modelBuilder.ConfigureResourcesContext(storeOptions);

            base.OnModelCreating(modelBuilder);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/DbContexts/PersistedGrantDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.DbContexts
{
    /// 
    /// DbContext for the IdentityServer operational data.
    /// 
    /// 
    /// 
    public class PersistedGrantDbContext : PersistedGrantDbContext
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The options.
        /// The store options.
        /// storeOptions
        public PersistedGrantDbContext(DbContextOptions options, OperationalStoreOptions storeOptions)
            : base(options, storeOptions)
        {
        }
    }

    /// 
    /// DbContext for the IdentityServer operational data.
    /// 
    /// 
    /// 
    public class PersistedGrantDbContext : DbContext, IPersistedGrantDbContext
        where TContext : DbContext, IPersistedGrantDbContext
    {
        private readonly OperationalStoreOptions storeOptions;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The options.
        /// The store options.
        /// storeOptions
        public PersistedGrantDbContext(DbContextOptions options, OperationalStoreOptions storeOptions)
            : base(options)
        {
            if (storeOptions == null) throw new ArgumentNullException(nameof(storeOptions));
            this.storeOptions = storeOptions;
        }

        /// 
        /// Gets or sets the persisted grants.
        /// 
        /// 
        /// The persisted grants.
        /// 
        public DbSet PersistedGrants { get; set; }

        /// 
        /// Gets or sets the device codes.
        /// 
        /// 
        /// The device codes.
        /// 
        public DbSet DeviceFlowCodes { get; set; }

        /// 
        /// Saves the changes.
        /// 
        /// 
        public virtual Task SaveChangesAsync()
        {
            return base.SaveChangesAsync();
        }

        /// 
        /// Override this method to further configure the model that was discovered by convention from the entity types
        /// exposed in  properties on your derived context. The resulting model may be cached
        /// and re-used for subsequent instances of your derived context.
        /// 
        /// The builder being used to construct the model for this context. Databases (and other extensions) typically
        /// define extension methods on this object that allow you to configure aspects of the model that are specific
        /// to a given database.
        /// 
        /// If a model is explicitly set on the options for this context (via )
        /// then this method will not be run.
        /// 
        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.ConfigurePersistedGrantContext(storeOptions);

            base.OnModelCreating(modelBuilder);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiResource.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiResource
    {
        public int Id { get; set; }
        public bool Enabled { get; set; } = true;
        public string Name { get; set; }
        public string DisplayName { get; set; }
        public string Description { get; set; }
        public string AllowedAccessTokenSigningAlgorithms { get; set; }
        public bool ShowInDiscoveryDocument { get; set; } = true;
        public List Secrets { get; set; }
        public List Scopes { get; set; }
        public List UserClaims { get; set; }
        public List Properties { get; set; }
        public DateTime Created { get; set; } = DateTime.UtcNow;
        public DateTime? Updated { get; set; }
        public DateTime? LastAccessed { get; set; }
        public bool NonEditable { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiResourceClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiResourceClaim : UserClaim
    {
        public int ApiResourceId { get; set; }
        public ApiResource ApiResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiResourceProperty.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiResourceProperty : Property
    {
        public int ApiResourceId { get; set; }
        public ApiResource ApiResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiResourceScope.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiResourceScope
    {
        public int Id { get; set; }
        public string Scope { get; set; }

        public int ApiResourceId { get; set; }
        public ApiResource ApiResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiResourceSecret.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiResourceSecret : Secret
    {
        public int ApiResourceId { get; set; }
        public ApiResource ApiResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiScope.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

using System.Collections.Generic;

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiScope
    {
        public int Id { get; set; }
        public bool Enabled { get; set; } = true;
        public string Name { get; set; }
        public string DisplayName { get; set; }
        public string Description { get; set; }
        public bool Required { get; set; }
        public bool Emphasize { get; set; }
        public bool ShowInDiscoveryDocument { get; set; } = true;
        public List UserClaims { get; set; }
        public List Properties { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiScopeClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiScopeClaim : UserClaim
    {
        public int ScopeId { get; set; }
        public ApiScope Scope { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ApiScopeProperty.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ApiScopeProperty : Property
    {
        public int ScopeId { get; set; }
        public ApiScope Scope { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/Client.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Entities
{
    public class Client
    {
        public int Id { get; set; }
        public bool Enabled { get; set; } = true;
        public string ClientId { get; set; }
        public string ProtocolType { get; set; } = "oidc";
        public List ClientSecrets { get; set; }
        public bool RequireClientSecret { get; set; } = true;
        public string ClientName { get; set; }
        public string Description { get; set; }
        public string ClientUri { get; set; }
        public string LogoUri { get; set; }
        public bool RequireConsent { get; set; } = false;
        public bool AllowRememberConsent { get; set; } = true;
        public bool AlwaysIncludeUserClaimsInIdToken { get; set; }
        public List AllowedGrantTypes { get; set; }
        public bool RequirePkce { get; set; } = true;
        public bool AllowPlainTextPkce { get; set; }
        public bool RequireRequestObject { get; set; }
        public bool AllowAccessTokensViaBrowser { get; set; }
        public List RedirectUris { get; set; }
        public List PostLogoutRedirectUris { get; set; }
        public string FrontChannelLogoutUri { get; set; }
        public bool FrontChannelLogoutSessionRequired { get; set; } = true;
        public string BackChannelLogoutUri { get; set; }
        public bool BackChannelLogoutSessionRequired { get; set; } = true;
        public bool AllowOfflineAccess { get; set; }
        public List AllowedScopes { get; set; }
        public int IdentityTokenLifetime { get; set; } = 300;
        public string AllowedIdentityTokenSigningAlgorithms { get; set; }
        public int AccessTokenLifetime { get; set; } = 3600;
        public int AuthorizationCodeLifetime { get; set; } = 300;
        public int? ConsentLifetime { get; set; } = null;
        public int AbsoluteRefreshTokenLifetime { get; set; } = 2592000;
        public int SlidingRefreshTokenLifetime { get; set; } = 1296000;
        public int RefreshTokenUsage { get; set; } = (int)TokenUsage.OneTimeOnly;
        public bool UpdateAccessTokenClaimsOnRefresh { get; set; }
        public int RefreshTokenExpiration { get; set; } = (int)TokenExpiration.Absolute;
        public int AccessTokenType { get; set; } = (int)0; // AccessTokenType.Jwt;
        public bool EnableLocalLogin { get; set; } = true;
        public List IdentityProviderRestrictions { get; set; }
        public bool IncludeJwtId { get; set; }
        public List Claims { get; set; }
        public bool AlwaysSendClientClaims { get; set; }
        public string ClientClaimsPrefix { get; set; } = "client_";
        public string PairWiseSubjectSalt { get; set; }
        public List AllowedCorsOrigins { get; set; }
        public List Properties { get; set; }
        public DateTime Created { get; set; } = DateTime.UtcNow;
        public DateTime? Updated { get; set; }
        public DateTime? LastAccessed { get; set; }
        public int? UserSsoLifetime { get; set; }
        public string UserCodeType { get; set; }
        public int DeviceCodeLifetime { get; set; } = 300;
        public bool NonEditable { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientClaim
    {
        public int Id { get; set; }
        public string Type { get; set; }
        public string Value { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientCorsOrigin.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientCorsOrigin
    {
        public int Id { get; set; }
        public string Origin { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientGrantType.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientGrantType
    {
        public int Id { get; set; }
        public string GrantType { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientIdPRestriction.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientIdPRestriction
    {
        public int Id { get; set; }
        public string Provider { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientPostLogoutRedirectUri.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientPostLogoutRedirectUri
    {
        public int Id { get; set; }
        public string PostLogoutRedirectUri { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientProperty.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientProperty : Property
    {
        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientRedirectUri.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientRedirectUri
    {
        public int Id { get; set; }
        public string RedirectUri { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientScope.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientScope
    {
        public int Id { get; set; }
        public string Scope { get; set; }

        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/ClientSecret.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class ClientSecret : Secret
    {
        public int ClientId { get; set; }
        public Client Client { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/DeviceFlowCodes.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Entities
{
    /// 
    /// Entity for device flow codes
    /// 
    public class DeviceFlowCodes
    {
        /// 
        /// Gets or sets the device code.
        /// 
        /// 
        /// The device code.
        /// 
        public string DeviceCode { get; set; }

        /// 
        /// Gets or sets the user code.
        /// 
        /// 
        /// The user code.
        /// 
        public string UserCode { get; set; }

        /// 
        /// Gets or sets the subject identifier.
        /// 
        /// 
        /// The subject identifier.
        /// 
        public string SubjectId { get; set; }

        /// 
        /// Gets or sets the session identifier.
        /// 
        /// 
        /// The session identifier.
        /// 
        public string SessionId { get; set; }

        /// 
        /// Gets or sets the client identifier.
        /// 
        /// 
        /// The client identifier.
        /// 
        public string ClientId { get; set; }

        /// 
        /// Gets the description the user assigned to the device being authorized.
        /// 
        /// 
        /// The description.
        /// 
        public string Description { get; set; }

        /// 
        /// Gets or sets the creation time.
        /// 
        /// 
        /// The creation time.
        /// 
        public DateTime CreationTime { get; set; }

        /// 
        /// Gets or sets the expiration.
        /// 
        /// 
        /// The expiration.
        /// 
        public DateTime? Expiration { get; set; }

        /// 
        /// Gets or sets the data.
        /// 
        /// 
        /// The data.
        /// 
        public string Data { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/IdentityResource.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class IdentityResource
    {
        public int Id { get; set; }
        public bool Enabled { get; set; } = true;
        public string Name { get; set; }
        public string DisplayName { get; set; }
        public string Description { get; set; }
        public bool Required { get; set; }
        public bool Emphasize { get; set; }
        public bool ShowInDiscoveryDocument { get; set; } = true;
        public List UserClaims { get; set; }
        public List Properties { get; set; }
        public DateTime Created { get; set; } = DateTime.UtcNow;
        public DateTime? Updated { get; set; }
        public bool NonEditable { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/IdentityResourceClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class IdentityResourceClaim : UserClaim
    {
        public int IdentityResourceId { get; set; }
        public IdentityResource IdentityResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/IdentityResourceProperty.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class IdentityResourceProperty : Property
    {
        public int IdentityResourceId { get; set; }
        public IdentityResource IdentityResource { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/PersistedGrant.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public class PersistedGrant
    {
        public string Key { get; set; }
        public string Type { get; set; }
        public string SubjectId { get; set; }
        public string SessionId { get; set; }
        public string ClientId { get; set; }
        public string Description { get; set; }
        public DateTime CreationTime { get; set; }
        public DateTime? Expiration { get; set; }
        public DateTime? ConsumedTime { get; set; }
        public string Data { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/Property.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public abstract class Property
    {
        public int Id { get; set; }
        public string Key { get; set; }
        public string Value { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/Secret.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public abstract class Secret
    {
        public int Id { get; set; }
        public string Description { get; set; }
        public string Value { get; set; }
        public DateTime? Expiration { get; set; }
        public string Type { get; set; } = "SharedSecret";
        public DateTime Created { get; set; } = DateTime.UtcNow;
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Entities/UserClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.EntityFramework.Entities
{
    public abstract class UserClaim
    {
        public int Id { get; set; }
        public string Type { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Extensions/ModelBuilderExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Extensions
{
    /// 
    /// Extension methods to define the database schema for the configuration and operational data stores.
    /// 
    public static class ModelBuilderExtensions
    {
        private static EntityTypeBuilder ToTable(this EntityTypeBuilder entityTypeBuilder, TableConfiguration configuration)
            where TEntity : class
        {
            return string.IsNullOrWhiteSpace(configuration.Schema) ? entityTypeBuilder.ToTable(configuration.Name) : entityTypeBuilder.ToTable(configuration.Name, configuration.Schema);
        }

        /// 
        /// Configures the client context.
        /// 
        /// The model builder.
        /// The store options.
        public static void ConfigureClientContext(this ModelBuilder modelBuilder, ConfigurationStoreOptions storeOptions)
        {
            if (!string.IsNullOrWhiteSpace(storeOptions.DefaultSchema)) modelBuilder.HasDefaultSchema(storeOptions.DefaultSchema);

            modelBuilder.Entity(client =>
            {
                client.ToTable(storeOptions.Client);
                client.HasKey(x => x.Id);

                client.Property(x => x.ClientId).HasMaxLength(200).IsRequired();
                client.Property(x => x.ProtocolType).HasMaxLength(200).IsRequired();
                client.Property(x => x.ClientName).HasMaxLength(200);
                client.Property(x => x.ClientUri).HasMaxLength(2000);
                client.Property(x => x.LogoUri).HasMaxLength(2000);
                client.Property(x => x.Description).HasMaxLength(1000);
                client.Property(x => x.FrontChannelLogoutUri).HasMaxLength(2000);
                client.Property(x => x.BackChannelLogoutUri).HasMaxLength(2000);
                client.Property(x => x.ClientClaimsPrefix).HasMaxLength(200);
                client.Property(x => x.PairWiseSubjectSalt).HasMaxLength(200);
                client.Property(x => x.UserCodeType).HasMaxLength(100);
                client.Property(x => x.AllowedIdentityTokenSigningAlgorithms).HasMaxLength(100);

                client.HasIndex(x => x.ClientId).IsUnique();

                client.HasMany(x => x.AllowedGrantTypes).WithOne(x => x.Client).HasForeignKey(x=>x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.RedirectUris).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.PostLogoutRedirectUris).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.AllowedScopes).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.ClientSecrets).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.Claims).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.IdentityProviderRestrictions).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.AllowedCorsOrigins).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                client.HasMany(x => x.Properties).WithOne(x => x.Client).HasForeignKey(x => x.ClientId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity(grantType =>
            {
                grantType.ToTable(storeOptions.ClientGrantType);
                grantType.Property(x => x.GrantType).HasMaxLength(250).IsRequired();
            });

            modelBuilder.Entity(redirectUri =>
            {
                redirectUri.ToTable(storeOptions.ClientRedirectUri);
                redirectUri.Property(x => x.RedirectUri).HasMaxLength(2000).IsRequired();
            });

            modelBuilder.Entity(postLogoutRedirectUri =>
            {
                postLogoutRedirectUri.ToTable(storeOptions.ClientPostLogoutRedirectUri);
                postLogoutRedirectUri.Property(x => x.PostLogoutRedirectUri).HasMaxLength(2000).IsRequired();
            });

            modelBuilder.Entity(scope =>
            {
                scope.ToTable(storeOptions.ClientScopes);
                scope.Property(x => x.Scope).HasMaxLength(200).IsRequired();
            });

            modelBuilder.Entity(secret =>
            {
                secret.ToTable(storeOptions.ClientSecret);
                secret.Property(x => x.Value).HasMaxLength(4000).IsRequired();
                secret.Property(x => x.Type).HasMaxLength(250).IsRequired();
                secret.Property(x => x.Description).HasMaxLength(2000);
            });

            modelBuilder.Entity(claim =>
            {
                claim.ToTable(storeOptions.ClientClaim);
                claim.Property(x => x.Type).HasMaxLength(250).IsRequired();
                claim.Property(x => x.Value).HasMaxLength(250).IsRequired();
            });

            modelBuilder.Entity(idPRestriction =>
            {
                idPRestriction.ToTable(storeOptions.ClientIdPRestriction);
                idPRestriction.Property(x => x.Provider).HasMaxLength(200).IsRequired();
            });

            modelBuilder.Entity(corsOrigin =>
            {
                corsOrigin.ToTable(storeOptions.ClientCorsOrigin);
                corsOrigin.Property(x => x.Origin).HasMaxLength(150).IsRequired();
            });

            modelBuilder.Entity(property =>
            {
                property.ToTable(storeOptions.ClientProperty);
                property.Property(x => x.Key).HasMaxLength(250).IsRequired();
                property.Property(x => x.Value).HasMaxLength(2000).IsRequired();
            });
        }

        /// 
        /// Configures the persisted grant context.
        /// 
        /// The model builder.
        /// The store options.
        public static void ConfigurePersistedGrantContext(this ModelBuilder modelBuilder, OperationalStoreOptions storeOptions)
        {
            if (!string.IsNullOrWhiteSpace(storeOptions.DefaultSchema)) modelBuilder.HasDefaultSchema(storeOptions.DefaultSchema);

            modelBuilder.Entity(grant =>
            {
                grant.ToTable(storeOptions.PersistedGrants);

                grant.Property(x => x.Key).HasMaxLength(200).ValueGeneratedNever();
                grant.Property(x => x.Type).HasMaxLength(50).IsRequired();
                grant.Property(x => x.SubjectId).HasMaxLength(200);
                grant.Property(x => x.SessionId).HasMaxLength(100);
                grant.Property(x => x.ClientId).HasMaxLength(200).IsRequired();
                grant.Property(x => x.Description).HasMaxLength(200);
                grant.Property(x => x.CreationTime).IsRequired();
                // 50000 chosen to be explicit to allow enough size to avoid truncation, yet stay beneath the MySql row size limit of ~65K
                // apparently anything over 4K converts to nvarchar(max) on SqlServer
                grant.Property(x => x.Data).HasMaxLength(50000).IsRequired();

                grant.HasKey(x => x.Key);

                grant.HasIndex(x => new { x.SubjectId, x.ClientId, x.Type });
                grant.HasIndex(x => new { x.SubjectId, x.SessionId, x.Type });
                grant.HasIndex(x => x.Expiration);
            });

            modelBuilder.Entity(codes =>
            {
                codes.ToTable(storeOptions.DeviceFlowCodes);

                codes.Property(x => x.DeviceCode).HasMaxLength(200).IsRequired();
                codes.Property(x => x.UserCode).HasMaxLength(200).IsRequired();
                codes.Property(x => x.SubjectId).HasMaxLength(200);
                codes.Property(x => x.SessionId).HasMaxLength(100);
                codes.Property(x => x.ClientId).HasMaxLength(200).IsRequired();
                codes.Property(x => x.Description).HasMaxLength(200);
                codes.Property(x => x.CreationTime).IsRequired();
                codes.Property(x => x.Expiration).IsRequired();
                // 50000 chosen to be explicit to allow enough size to avoid truncation, yet stay beneath the MySql row size limit of ~65K
                // apparently anything over 4K converts to nvarchar(max) on SqlServer
                codes.Property(x => x.Data).HasMaxLength(50000).IsRequired();

                codes.HasKey(x => new {x.UserCode});

                codes.HasIndex(x => x.DeviceCode).IsUnique();
                codes.HasIndex(x => x.Expiration);
            });
        }

        /// 
        /// Configures the resources context.
        /// 
        /// The model builder.
        /// The store options.
        public static void ConfigureResourcesContext(this ModelBuilder modelBuilder, ConfigurationStoreOptions storeOptions)
        {
            if (!string.IsNullOrWhiteSpace(storeOptions.DefaultSchema)) modelBuilder.HasDefaultSchema(storeOptions.DefaultSchema);

            modelBuilder.Entity(identityResource =>
            {
                identityResource.ToTable(storeOptions.IdentityResource).HasKey(x => x.Id);

                identityResource.Property(x => x.Name).HasMaxLength(200).IsRequired();
                identityResource.Property(x => x.DisplayName).HasMaxLength(200);
                identityResource.Property(x => x.Description).HasMaxLength(1000);

                identityResource.HasIndex(x => x.Name).IsUnique();

                identityResource.HasMany(x => x.UserClaims).WithOne(x => x.IdentityResource).HasForeignKey(x => x.IdentityResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                identityResource.HasMany(x => x.Properties).WithOne(x => x.IdentityResource).HasForeignKey(x => x.IdentityResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity(claim =>
            {
                claim.ToTable(storeOptions.IdentityResourceClaim).HasKey(x => x.Id);

                claim.Property(x => x.Type).HasMaxLength(200).IsRequired();
            });

            modelBuilder.Entity(property =>
            {
                property.ToTable(storeOptions.IdentityResourceProperty);
                property.Property(x => x.Key).HasMaxLength(250).IsRequired();
                property.Property(x => x.Value).HasMaxLength(2000).IsRequired();
            });



            modelBuilder.Entity(apiResource =>
            {
                apiResource.ToTable(storeOptions.ApiResource).HasKey(x => x.Id);

                apiResource.Property(x => x.Name).HasMaxLength(200).IsRequired();
                apiResource.Property(x => x.DisplayName).HasMaxLength(200);
                apiResource.Property(x => x.Description).HasMaxLength(1000);
                apiResource.Property(x => x.AllowedAccessTokenSigningAlgorithms).HasMaxLength(100);

                apiResource.HasIndex(x => x.Name).IsUnique();

                apiResource.HasMany(x => x.Secrets).WithOne(x => x.ApiResource).HasForeignKey(x => x.ApiResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                apiResource.HasMany(x => x.Scopes).WithOne(x => x.ApiResource).HasForeignKey(x => x.ApiResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                apiResource.HasMany(x => x.UserClaims).WithOne(x => x.ApiResource).HasForeignKey(x => x.ApiResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
                apiResource.HasMany(x => x.Properties).WithOne(x => x.ApiResource).HasForeignKey(x => x.ApiResourceId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            });

            modelBuilder.Entity(apiSecret =>
            {
                apiSecret.ToTable(storeOptions.ApiResourceSecret).HasKey(x => x.Id);

                apiSecret.Property(x => x.Description).HasMaxLength(1000);
                apiSecret.Property(x => x.Value).HasMaxLength(4000).IsRequired();
                apiSecret.Property(x => x.Type).HasMaxLength(250).IsRequired();
            });

            modelBuilder.Entity(apiClaim =>
            {
                apiClaim.ToTable(storeOptions.ApiResourceClaim).HasKey(x => x.Id);

                apiClaim.Property(x => x.Type).HasMaxLength(200).IsRequired();
            });

            modelBuilder.Entity((System.Action>)(apiScope =>
            {
                apiScope.ToTable((TableConfiguration)storeOptions.ApiResourceScope).HasKey(x => x.Id);

                apiScope.Property(x => x.Scope).HasMaxLength(200).IsRequired();
            }));

            modelBuilder.Entity(property =>
            {
                property.ToTable(storeOptions.ApiResourceProperty);
                property.Property(x => x.Key).HasMaxLength(250).IsRequired();
                property.Property(x => x.Value).HasMaxLength(2000).IsRequired();
            });


            modelBuilder.Entity(scope =>
            {
                scope.ToTable(storeOptions.ApiScope).HasKey(x => x.Id);

                scope.Property(x => x.Name).HasMaxLength(200).IsRequired();
                scope.Property(x => x.DisplayName).HasMaxLength(200);
                scope.Property(x => x.Description).HasMaxLength(1000);

                scope.HasIndex(x => x.Name).IsUnique();

                scope.HasMany(x => x.UserClaims).WithOne(x => x.Scope).HasForeignKey(x => x.ScopeId).IsRequired().OnDelete(DeleteBehavior.Cascade);
            });
            modelBuilder.Entity(scopeClaim =>
            {
                scopeClaim.ToTable(storeOptions.ApiScopeClaim).HasKey(x => x.Id);

                scopeClaim.Property(x => x.Type).HasMaxLength(200).IsRequired();
            });
            modelBuilder.Entity(property =>
            {
                property.ToTable(storeOptions.ApiScopeProperty).HasKey(x => x.Id);
                property.Property(x => x.Key).HasMaxLength(250).IsRequired();
                property.Property(x => x.Value).HasMaxLength(2000).IsRequired();
            });


        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using AutoMapper;
global using IdentityModel;
global using IdentityServer8.EntityFramework.DbContexts;
global using IdentityServer8.EntityFramework.Extensions;
global using IdentityServer8.EntityFramework.Interfaces;
//global using IdentityServer8.EntityFramework.Entities;
global using IdentityServer8.EntityFramework.Mappers;
global using IdentityServer8.EntityFramework.Options;
global using IdentityServer8.Extensions;
//global using IdentityServer8.Models;
global using IdentityServer8.Stores;
global using IdentityServer8.Stores.Serialization;
global using Microsoft.EntityFrameworkCore;
global using Microsoft.EntityFrameworkCore.Metadata.Builders;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Logging;
global using System.Buffers;
global using System.Runtime.CompilerServices;
global using ClaimValueTypes = System.Security.Claims.ClaimValueTypes;


================================================
FILE: src/EntityFramework.Storage/src/IdentityServer8.EntityFramework.Storage.csproj
================================================


    
        EntityFramework persistence layer for IdentityServer8
        true
        true
    

    
        True
        True
    

    
        
        
    

    
        
        
    




================================================
FILE: src/EntityFramework.Storage/src/Interfaces/IConfigurationDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Interfaces
{
    /// 
    /// Abstraction for the configuration context.
    /// 
    /// 
    public interface IConfigurationDbContext : IDisposable
    {
        /// 
        /// Gets or sets the clients.
        /// 
        /// 
        /// The clients.
        /// 
        DbSet Clients { get; set; }
        
        /// 
        /// Gets or sets the clients' CORS origins.
        /// 
        /// 
        /// The clients CORS origins.
        /// 
        DbSet ClientCorsOrigins { get; set; }

        /// 
        /// Gets or sets the identity resources.
        /// 
        /// 
        /// The identity resources.
        /// 
        DbSet IdentityResources { get; set; }

        /// 
        /// Gets or sets the API resources.
        /// 
        /// 
        /// The API resources.
        /// 
        DbSet ApiResources { get; set; }

        /// 
        /// Gets or sets the scopes.
        /// 
        /// 
        /// The identity resources.
        /// 
        DbSet ApiScopes { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Interfaces/IPersistedGrantDbContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Interfaces
{
    /// 
    /// Abstraction for the operational data context.
    /// 
    /// 
    public interface IPersistedGrantDbContext : IDisposable
    {
        /// 
        /// Gets or sets the persisted grants.
        /// 
        /// 
        /// The persisted grants.
        /// 
        DbSet PersistedGrants { get; set; }

        /// 
        /// Gets or sets the device flow codes.
        /// 
        /// 
        /// The device flow codes.
        /// 
        DbSet DeviceFlowCodes { get; set; }

        /// 
        /// Saves the changes.
        /// 
        /// 
        Task SaveChangesAsync();
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/AllowedSigningAlgorithmsConverter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    class AllowedSigningAlgorithmsConverter : 
        IValueConverter, string>,
        IValueConverter>
    {
        public static AllowedSigningAlgorithmsConverter Converter = new AllowedSigningAlgorithmsConverter();

        public string Convert(ICollection sourceMember, ResolutionContext context)
        {
            if (sourceMember == null || !sourceMember.Any())
            {
                return null;
            }
            return sourceMember.Aggregate((x, y) => $"{x},{y}");
        }

        public ICollection Convert(string sourceMember, ResolutionContext context)
        {
            var list = new HashSet();
            if (!String.IsNullOrWhiteSpace(sourceMember))
            {
                sourceMember = sourceMember.Trim();
                foreach (var item in sourceMember.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Distinct())
                {
                    list.Add(item);
                }
            }
            return list;
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ApiResourceMapperProfile.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Defines entity/model mapping for API resources.
    /// 
    /// 
    public class ApiResourceMapperProfile : Profile
    {
        /// 
        /// 
        /// 
        public ApiResourceMapperProfile()
        {
            CreateMap>()
                .ReverseMap();

            CreateMap(MemberList.Destination)
                .ConstructUsing(src => new Models.ApiResource())
                .ForMember(x => x.ApiSecrets, opts => opts.MapFrom(x => x.Secrets))
                .ForMember(x=>x.AllowedAccessTokenSigningAlgorithms, opts => opts.ConvertUsing(AllowedSigningAlgorithmsConverter.Converter, x=>x.AllowedAccessTokenSigningAlgorithms))
                .ReverseMap()
                .ForMember(x => x.AllowedAccessTokenSigningAlgorithms, opts => opts.ConvertUsing(AllowedSigningAlgorithmsConverter.Converter, x => x.AllowedAccessTokenSigningAlgorithms));

            CreateMap()
                .ConstructUsing(x => x.Type)
                .ReverseMap()
                .ForMember(dest => dest.Type, opt => opt.MapFrom(src => src));

            CreateMap(MemberList.Destination)
                .ForMember(dest => dest.Type, opt => opt.Condition(srs => srs != null))
                .ReverseMap();

            CreateMap()
                .ConstructUsing(x => x.Scope)
                .ReverseMap()
                .ForMember(dest => dest.Scope, opt => opt.MapFrom(src => src));
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ApiResourceMappers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Extension methods to map to/from entity/model for API resources.
    /// 
    public static class ApiResourceMappers
    {
        static ApiResourceMappers()
        {
            Mapper = new MapperConfiguration(cfg => cfg.AddProfile())
                .CreateMapper();
        }

        internal static IMapper Mapper { get; }

        /// 
        /// Maps an entity to a model.
        /// 
        /// The entity.
        /// 
        public static Models.ApiResource ToModel(this ApiResource entity)
        {
            return entity == null ? null : Mapper.Map(entity);
        }

        /// 
        /// Maps a model to an entity.
        /// 
        /// The model.
        /// 
        public static ApiResource ToEntity(this Models.ApiResource model)
        {
            return model == null ? null : Mapper.Map(model);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ClientMapperProfile.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Defines entity/model mapping for clients.
    /// 
    /// 
    public class ClientMapperProfile : Profile
    {
        /// 
        /// 
        ///     {ClientMapperProfile}
        /// 
        /// 
        public ClientMapperProfile()
        {
            CreateMap>()
                .ReverseMap();

            CreateMap()
                .ForMember(dest => dest.ProtocolType, opt => opt.Condition(srs => srs != null))
                .ForMember(x => x.AllowedIdentityTokenSigningAlgorithms, opts => opts.ConvertUsing(AllowedSigningAlgorithmsConverter.Converter, x => x.AllowedIdentityTokenSigningAlgorithms))
                .ReverseMap()
                .ForMember(x => x.AllowedIdentityTokenSigningAlgorithms, opts => opts.ConvertUsing(AllowedSigningAlgorithmsConverter.Converter, x => x.AllowedIdentityTokenSigningAlgorithms));

            CreateMap()
                .ConstructUsing(src => src.Origin)
                .ReverseMap()
                .ForMember(dest => dest.Origin, opt => opt.MapFrom(src => src));

            CreateMap()
                .ConstructUsing(src => src.Provider)
                .ReverseMap()
                .ForMember(dest => dest.Provider, opt => opt.MapFrom(src => src));

            CreateMap(MemberList.None)
                .ConstructUsing(src => new ClientClaim(src.Type, src.Value, ClaimValueTypes.String))
                .ReverseMap();

            CreateMap()
                .ConstructUsing(src => src.Scope)
                .ReverseMap()
                .ForMember(dest => dest.Scope, opt => opt.MapFrom(src => src));

            CreateMap()
                .ConstructUsing(src => src.PostLogoutRedirectUri)
                .ReverseMap()
                .ForMember(dest => dest.PostLogoutRedirectUri, opt => opt.MapFrom(src => src));

            CreateMap()
                .ConstructUsing(src => src.RedirectUri)
                .ReverseMap()
                .ForMember(dest => dest.RedirectUri, opt => opt.MapFrom(src => src));

            CreateMap()
                .ConstructUsing(src => src.GrantType)
                .ReverseMap()
                .ForMember(dest => dest.GrantType, opt => opt.MapFrom(src => src));

            CreateMap(MemberList.Destination)
                .ForMember(dest => dest.Type, opt => opt.Condition(srs => srs != null))
                .ReverseMap();
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ClientMappers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Extension methods to map to/from entity/model for clients.
    /// 
    public static class ClientMappers
    {
        static ClientMappers()
        {
            Mapper = new MapperConfiguration(cfg => cfg.AddProfile())
                .CreateMapper();
        }

        internal static IMapper Mapper { get; }

        /// 
        /// Maps an entity to a model.
        /// 
        /// The entity.
        /// 
        public static Models.Client ToModel(this Entities.Client entity)
        {
            return Mapper.Map(entity);
        }

        /// 
        /// Maps a model to an entity.
        /// 
        /// The model.
        /// 
        public static Entities.Client ToEntity(this Models.Client model)
        {
            return Mapper.Map(model);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/IdentityResourceMapperProfile.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Defines entity/model mapping for identity resources.
    /// 
    /// 
    public class IdentityResourceMapperProfile : Profile
    {
        /// 
        /// 
        /// 
        public IdentityResourceMapperProfile()
        {
            CreateMap>()
                .ReverseMap();

            CreateMap(MemberList.Destination)
                .ConstructUsing(src => new Models.IdentityResource())
                .ReverseMap();

            CreateMap()
               .ConstructUsing(x => x.Type)
               .ReverseMap()
               .ForMember(dest => dest.Type, opt => opt.MapFrom(src => src));
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/IdentityResourceMappers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Extension methods to map to/from entity/model for identity resources.
    /// 
    public static class IdentityResourceMappers
    {
        static IdentityResourceMappers()
        {
            Mapper = new MapperConfiguration(cfg => cfg.AddProfile())
                .CreateMapper();
        }

        internal static IMapper Mapper { get; }

        /// 
        /// Maps an entity to a model.
        /// 
        /// The entity.
        /// 
        public static Models.IdentityResource ToModel(this IdentityResource entity)
        {
            return entity == null ? null : Mapper.Map(entity);
        }

        /// 
        /// Maps a model to an entity.
        /// 
        /// The model.
        /// 
        public static IdentityResource ToEntity(this Models.IdentityResource model)
        {
            return model == null ? null : Mapper.Map(model);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/PersistedGrantMapperProfile.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Defines entity/model mapping for persisted grants.
    /// 
    /// 
    public class PersistedGrantMapperProfile:Profile
    {
        /// 
        /// 
        /// 
        /// 
        public PersistedGrantMapperProfile()
        {
            CreateMap(MemberList.Destination)
                .ReverseMap();
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/PersistedGrantMappers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Extension methods to map to/from entity/model for persisted grants.
    /// 
    public static class PersistedGrantMappers
    {
        static PersistedGrantMappers()
        {
            Mapper = new MapperConfiguration(cfg =>cfg.AddProfile())
                .CreateMapper();
        }

        internal static IMapper Mapper { get; }

        /// 
        /// Maps an entity to a model.
        /// 
        /// The entity.
        /// 
        public static PersistedGrant ToModel(this Entities.PersistedGrant entity)
        {
            return entity == null ? null : Mapper.Map(entity);
        }

        /// 
        /// Maps a model to an entity.
        /// 
        /// The model.
        /// 
        public static Entities.PersistedGrant ToEntity(this PersistedGrant model)
        {
            return model == null ? null : Mapper.Map(model);
        }

        /// 
        /// Updates an entity from a model.
        /// 
        /// The model.
        /// The entity.
        public static void UpdateEntity(this PersistedGrant model, Entities.PersistedGrant entity)
        {
            Mapper.Map(model, entity);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ScopeMapperProfile.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Defines entity/model mapping for scopes.
    /// 
    /// 
    public class ScopeMapperProfile : Profile
    {
        /// 
        /// 
        /// 
        public ScopeMapperProfile()
        {
            CreateMap>()
                .ReverseMap();

            CreateMap()
               .ConstructUsing(x => x.Type)
               .ReverseMap()
               .ForMember(dest => dest.Type, opt => opt.MapFrom(src => src));

            CreateMap(MemberList.Destination)
                .ConstructUsing(src => new Models.ApiScope())
                .ForMember(x => x.Properties, opts => opts.MapFrom(x => x.Properties))
                .ForMember(x => x.UserClaims, opts => opts.MapFrom(x => x.UserClaims))
                .ReverseMap();
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Mappers/ScopeMappers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework.Mappers
{
    /// 
    /// Extension methods to map to/from entity/model for scopes.
    /// 
    public static class ScopeMappers
    {
        static ScopeMappers()
        {
            Mapper = new MapperConfiguration(cfg => cfg.AddProfile())
                .CreateMapper();
        }

        internal static IMapper Mapper { get; }

        /// 
        /// Maps an entity to a model.
        /// 
        /// The entity.
        /// 
        public static Models.ApiScope ToModel(this ApiScope entity)
        {
            return entity == null ? null : Mapper.Map(entity);
        }

        /// 
        /// Maps a model to an entity.
        /// 
        /// The model.
        /// 
        public static ApiScope ToEntity(this Models.ApiScope model)
        {
            return model == null ? null : Mapper.Map(model);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Options/ConfigurationStoreOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Options
{
    /// 
    /// Options for configuring the configuration context.
    /// 
    public class ConfigurationStoreOptions
    {
        /// 
        /// Callback to configure the EF DbContext.
        /// 
        /// 
        /// The configure database context.
        /// 
        public Action ConfigureDbContext { get; set; }

        /// 
        /// Callback in DI resolve the EF DbContextOptions. If set, ConfigureDbContext will not be used.
        /// 
        /// 
        /// The configure database context.
        /// 
        public Action ResolveDbContextOptions { get; set; }

        /// 
        /// Gets or sets the default schema.
        /// 
        /// 
        /// The default schema.
        /// 
        public string DefaultSchema { get; set; } = null;

        /// 
        /// Gets or sets the identity resource table configuration.
        /// 
        /// 
        /// The identity resource.
        /// 
        public TableConfiguration IdentityResource { get; set; } = new TableConfiguration("IdentityResources");
        /// 
        /// Gets or sets the identity claim table configuration.
        /// 
        /// 
        /// The identity claim.
        /// 
        public TableConfiguration IdentityResourceClaim { get; set; } = new TableConfiguration("IdentityResourceClaims");
        /// 
        /// Gets or sets the identity resource property table configuration.
        /// 
        /// 
        /// The client property.
        /// 
        public TableConfiguration IdentityResourceProperty { get; set; } = new TableConfiguration("IdentityResourceProperties");

        /// 
        /// Gets or sets the API resource table configuration.
        /// 
        /// 
        /// The API resource.
        /// 
        public TableConfiguration ApiResource { get; set; } = new TableConfiguration("ApiResources");
        /// 
        /// Gets or sets the API secret table configuration.
        /// 
        /// 
        /// The API secret.
        /// 
        public TableConfiguration ApiResourceSecret { get; set; } = new TableConfiguration("ApiResourceSecrets");
        /// 
        /// Gets or sets the API scope table configuration.
        /// 
        /// 
        /// The API scope.
        /// 
        public TableConfiguration ApiResourceScope { get; set; } = new TableConfiguration("ApiResourceScopes");
        /// 
        /// Gets or sets the API claim table configuration.
        /// 
        /// 
        /// The API claim.
        /// 
        public TableConfiguration ApiResourceClaim { get; set; } = new TableConfiguration("ApiResourceClaims");
        /// 
        /// Gets or sets the API resource property table configuration.
        /// 
        /// 
        /// The client property.
        /// 
        public TableConfiguration ApiResourceProperty { get; set; } = new TableConfiguration("ApiResourceProperties");

        /// 
        /// Gets or sets the client table configuration.
        /// 
        /// 
        /// The client.
        /// 
        public TableConfiguration Client { get; set; } = new TableConfiguration("Clients");
        /// 
        /// Gets or sets the type of the client grant table configuration.
        /// 
        /// 
        /// The type of the client grant.
        /// 
        public TableConfiguration ClientGrantType { get; set; } = new TableConfiguration("ClientGrantTypes");
        /// 
        /// Gets or sets the client redirect URI table configuration.
        /// 
        /// 
        /// The client redirect URI.
        /// 
        public TableConfiguration ClientRedirectUri { get; set; } = new TableConfiguration("ClientRedirectUris");
        /// 
        /// Gets or sets the client post logout redirect URI table configuration.
        /// 
        /// 
        /// The client post logout redirect URI.
        /// 
        public TableConfiguration ClientPostLogoutRedirectUri { get; set; } = new TableConfiguration("ClientPostLogoutRedirectUris");
        /// 
        /// Gets or sets the client scopes table configuration.
        /// 
        /// 
        /// The client scopes.
        /// 
        public TableConfiguration ClientScopes { get; set; } = new TableConfiguration("ClientScopes");
        /// 
        /// Gets or sets the client secret table configuration.
        /// 
        /// 
        /// The client secret.
        /// 
        public TableConfiguration ClientSecret { get; set; } = new TableConfiguration("ClientSecrets");
        /// 
        /// Gets or sets the client claim table configuration.
        /// 
        /// 
        /// The client claim.
        /// 
        public TableConfiguration ClientClaim { get; set; } = new TableConfiguration("ClientClaims");
        /// 
        /// Gets or sets the client IdP restriction table configuration.
        /// 
        /// 
        /// The client IdP restriction.
        /// 
        public TableConfiguration ClientIdPRestriction { get; set; } = new TableConfiguration("ClientIdPRestrictions");
        /// 
        /// Gets or sets the client cors origin table configuration.
        /// 
        /// 
        /// The client cors origin.
        /// 
        public TableConfiguration ClientCorsOrigin { get; set; } = new TableConfiguration("ClientCorsOrigins");
        /// 
        /// Gets or sets the client property table configuration.
        /// 
        /// 
        /// The client property.
        /// 
        public TableConfiguration ClientProperty { get; set; } = new TableConfiguration("ClientProperties");

        /// 
        /// Gets or sets the scope table configuration.
        /// 
        /// 
        /// The API resource.
        /// 
        public TableConfiguration ApiScope { get; set; } = new TableConfiguration("ApiScopes");
        /// 
        /// Gets or sets the scope claim table configuration.
        /// 
        /// 
        /// The API scope claim.
        /// 
        public TableConfiguration ApiScopeClaim { get; set; } = new TableConfiguration("ApiScopeClaims");
        /// 
        /// Gets or sets the API resource property table configuration.
        /// 
        /// 
        /// The client property.
        /// 
        public TableConfiguration ApiScopeProperty { get; set; } = new TableConfiguration("ApiScopeProperties");

    }
}


================================================
FILE: src/EntityFramework.Storage/src/Options/OperationalStoreOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Options
{
    /// 
    /// Options for configuring the operational context.
    /// 
    public class OperationalStoreOptions
    {
        /// 
        /// Callback to configure the EF DbContext.
        /// 
        /// 
        /// The configure database context.
        /// 
        public Action ConfigureDbContext { get; set; }

        /// 
        /// Callback in DI resolve the EF DbContextOptions. If set, ConfigureDbContext will not be used.
        /// 
        /// 
        /// The configure database context.
        /// 
        public Action ResolveDbContextOptions { get; set; }

        /// 
        /// Gets or sets the default schema.
        /// 
        /// 
        /// The default schema.
        /// 
        public string DefaultSchema { get; set; } = null;

        /// 
        /// Gets or sets the persisted grants table configuration.
        /// 
        /// 
        /// The persisted grants.
        /// 
        public TableConfiguration PersistedGrants { get; set; } = new TableConfiguration("PersistedGrants");

        /// 
        /// Gets or sets the device flow codes table configuration.
        /// 
        /// 
        /// The device flow codes.
        /// 
        public TableConfiguration DeviceFlowCodes { get; set; } = new TableConfiguration("DeviceCodes");

        /// 
        /// Gets or sets a value indicating whether stale entries will be automatically cleaned up from the database.
        /// This is implemented by periodically connecting to the database (according to the TokenCleanupInterval) from the hosting application.
        /// Defaults to false.
        /// 
        /// 
        ///   true if [enable token cleanup]; otherwise, false.
        /// 
        public bool EnableTokenCleanup { get; set; } = false;

        /// 
        /// Gets or sets the token cleanup interval (in seconds). The default is 3600 (1 hour).
        /// 
        /// 
        /// The token cleanup interval.
        /// 
        public int TokenCleanupInterval { get; set; } = 3600;

        /// 
        /// Gets or sets the number of records to remove at a time. Defaults to 100.
        /// 
        /// 
        /// The size of the token cleanup batch.
        /// 
        public int TokenCleanupBatchSize { get; set; } = 100;
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Options/TableConfiguration.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework.Options
{
    /// 
    /// Class to control a table's name and schema.
    /// 
    public class TableConfiguration
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The name.
        public TableConfiguration(string name)
        {
            Name = name;
        }

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The name.
        /// The schema.
        public TableConfiguration(string name, string schema)
        {
            Name = name;
            Schema = schema;
        }

        /// 
        /// Gets or sets the name.
        /// 
        /// 
        /// The name.
        /// 
        public string Name { get; set; }

        /// 
        /// Gets or sets the schema.
        /// 
        /// 
        /// The schema.
        /// 
        public string Schema { get; set; }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Properties/AssemblyInfo.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("IdentityServer8.EntityFramework.UnitTests, PublicKey = 002400000480000094000000060200000024000052534131000400000100010057b24455efc2a317afb0644a2169c05644e439985c42cf4eb98706779651801add1da073da8b5e253e8d4335d59b3197bb941ebe943c63f7efbc3005c428f0d69b809e86bdc828fa431fae4b71005f26b52a26a3ee5cf0f6fdf744d4534a7a503683123f58e1082828b018245d2e40d8542f72a623c01490d73a5d3ff94a88c5")]
[assembly: InternalsVisibleTo("IdentityServer8.EntityFramework.IntegrationTests, PublicKey = 002400000480000094000000060200000024000052534131000400000100010057b24455efc2a317afb0644a2169c05644e439985c42cf4eb98706779651801add1da073da8b5e253e8d4335d59b3197bb941ebe943c63f7efbc3005c428f0d69b809e86bdc828fa431fae4b71005f26b52a26a3ee5cf0f6fdf744d4534a7a503683123f58e1082828b018245d2e40d8542f72a623c01490d73a5d3ff94a88c5")]


================================================
FILE: src/EntityFramework.Storage/src/Stores/ClientStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Stores
{
    /// 
    /// Implementation of IClientStore thats uses EF.
    /// 
    /// 
    public class ClientStore : IClientStore
    {
        /// 
        /// The DbContext.
        /// 
        protected readonly IConfigurationDbContext Context;

        /// 
        /// The logger.
        /// 
        protected readonly ILogger Logger;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The context.
        /// The logger.
        /// context
        public ClientStore(IConfigurationDbContext context, ILogger logger)
        {
            Context = context ?? throw new ArgumentNullException(nameof(context));
            Logger = logger;
        }

        /// 
        /// Finds a client by id
        /// 
        /// The client id
        /// 
        /// The client
        /// 
        public virtual async Task FindClientByIdAsync(string clientId)
        {
            IQueryable baseQuery = Context.Clients
                .Where(x => x.ClientId == clientId);

            var client = (await baseQuery.ToArrayAsync())
                .SingleOrDefault(x => x.ClientId == clientId);
            if (client == null) return null;

            await baseQuery.Include(x => x.AllowedCorsOrigins).SelectMany(c => c.AllowedCorsOrigins).LoadAsync();
            await baseQuery.Include(x => x.AllowedGrantTypes).SelectMany(c => c.AllowedGrantTypes).LoadAsync();
            await baseQuery.Include(x => x.AllowedScopes).SelectMany(c => c.AllowedScopes).LoadAsync();
            await baseQuery.Include(x => x.Claims).SelectMany(c => c.Claims).LoadAsync();
            await baseQuery.Include(x => x.ClientSecrets).SelectMany(c => c.ClientSecrets).LoadAsync();
            await baseQuery.Include(x => x.IdentityProviderRestrictions).SelectMany(c => c.IdentityProviderRestrictions).LoadAsync();
            await baseQuery.Include(x => x.PostLogoutRedirectUris).SelectMany(c => c.PostLogoutRedirectUris).LoadAsync();
            await baseQuery.Include(x => x.Properties).SelectMany(c => c.Properties).LoadAsync();
            await baseQuery.Include(x => x.RedirectUris).SelectMany(c => c.RedirectUris).LoadAsync();

            var model = client.ToModel();

            Logger.LogDebug("{clientId} found in database: {clientIdFound}", Ioc.Sanitizer.Log.Sanitize(clientId), model != null);

            return model;
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Stores/DeviceFlowStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;
using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Stores
{
    /// 
    /// Implementation of IDeviceFlowStore thats uses EF.
    /// 
    /// 
    public class DeviceFlowStore : IDeviceFlowStore
    {
        /// 
        /// The DbContext.
        /// 
        protected readonly IPersistedGrantDbContext Context;

        /// 
        ///  The serializer.
        /// 
        protected readonly IPersistentGrantSerializer Serializer;

        /// 
        /// The logger.
        /// 
        protected readonly ILogger Logger;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The context.
        /// The serializer
        /// The logger.
        public DeviceFlowStore(
            IPersistedGrantDbContext context, 
            IPersistentGrantSerializer serializer, 
            ILogger logger)
        {
            Context = context;
            Serializer = serializer;
            Logger = logger;
        }

        /// 
        /// Stores the device authorization request.
        /// 
        /// The device code.
        /// The user code.
        /// The data.
        /// 
        public virtual async Task StoreDeviceAuthorizationAsync(string deviceCode, string userCode, DeviceCode data)
        {
            Context.DeviceFlowCodes.Add(ToEntity(data, deviceCode, userCode));

            await Context.SaveChangesAsync();
        }

        /// 
        /// Finds device authorization by user code.
        /// 
        /// The user code.
        /// 
        public virtual async Task FindByUserCodeAsync(string userCode)
        {
            var deviceFlowCodes = (await Context.DeviceFlowCodes.AsNoTracking().Where(x => x.UserCode == userCode).ToArrayAsync())
                .SingleOrDefault(x => x.UserCode == userCode);
            var model = ToModel(deviceFlowCodes?.Data);

            Logger.LogDebug("{userCode} found in database: {userCodeFound}", userCode, model != null);

            return model;
        }

        /// 
        /// Finds device authorization by device code.
        /// 
        /// The device code.
        /// 
        public virtual async Task FindByDeviceCodeAsync(string deviceCode)
        {
            var deviceFlowCodes = (await Context.DeviceFlowCodes.AsNoTracking().Where(x => x.DeviceCode == deviceCode).ToArrayAsync())
                .SingleOrDefault(x => x.DeviceCode == deviceCode);
            var model = ToModel(deviceFlowCodes?.Data);

            Logger.LogDebug("{deviceCode} found in database: {deviceCodeFound}", deviceCode, model != null);

            return model;
        }

        /// 
        /// Updates device authorization, searching by user code.
        /// 
        /// The user code.
        /// The data.
        /// 
        public virtual async Task UpdateByUserCodeAsync(string userCode, DeviceCode data)
        {
            var existing = (await Context.DeviceFlowCodes.Where(x => x.UserCode == userCode).ToArrayAsync())
                .SingleOrDefault(x => x.UserCode == userCode);
            if (existing == null)
            {
                Logger.LogError("{userCode} not found in database", userCode);
                throw new InvalidOperationException("Could not update device code");
            }

            var entity = ToEntity(data, existing.DeviceCode, userCode);
            Logger.LogDebug("{userCode} found in database", userCode);

            existing.SubjectId = data.Subject?.FindFirst(JwtClaimTypes.Subject).Value;
            existing.Data = entity.Data;

            try
            {
                await Context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                Logger.LogWarning("exception updating {userCode} user code in database: {error}", userCode, ex.Message);
            }
        }

        /// 
        /// Removes the device authorization, searching by device code.
        /// 
        /// The device code.
        /// 
        public virtual async Task RemoveByDeviceCodeAsync(string deviceCode)
        {
            var deviceFlowCodes = (await Context.DeviceFlowCodes.Where(x => x.DeviceCode == deviceCode).ToArrayAsync())
                .SingleOrDefault(x => x.DeviceCode == deviceCode);

            if(deviceFlowCodes != null)
            {
                Logger.LogDebug("removing {deviceCode} device code from database", deviceCode);

                Context.DeviceFlowCodes.Remove(deviceFlowCodes);

                try
                {
                    await Context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException ex)
                {
                    Logger.LogInformation("exception removing {deviceCode} device code from database: {error}", deviceCode, ex.Message);
                }
            }
            else
            {
                Logger.LogDebug("no {deviceCode} device code found in database", deviceCode);
            }
        }

        /// 
        /// Converts a model to an entity.
        /// 
        /// 
        /// 
        /// 
        /// 
        protected DeviceFlowCodes ToEntity(DeviceCode model, string deviceCode, string userCode)
        {
            if (model == null || deviceCode == null || userCode == null) return null;

            return new DeviceFlowCodes
            {
                DeviceCode = deviceCode,
                UserCode = userCode,
                ClientId = model.ClientId,
                SubjectId = model.Subject?.FindFirst(JwtClaimTypes.Subject).Value,
                CreationTime = model.CreationTime,
                Expiration = model.CreationTime.AddSeconds(model.Lifetime),
                Data = Serializer.Serialize(model)
            };
        }

        /// 
        /// Converts a serialized DeviceCode to a model.
        /// 
        /// 
        /// 
        protected DeviceCode ToModel(string entity)
        {
            if (entity == null) return null;

            return Serializer.Deserialize(entity);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Stores/PersistedGrantStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Stores
{
    /// 
    /// Implementation of IPersistedGrantStore thats uses EF.
    /// 
    /// 
    public class PersistedGrantStore : IPersistedGrantStore
    {
        /// 
        /// The DbContext.
        /// 
        protected readonly IPersistedGrantDbContext Context;

        /// 
        /// The logger.
        /// 
        protected readonly ILogger Logger;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The context.
        /// The logger.
        public PersistedGrantStore(IPersistedGrantDbContext context, ILogger logger)
        {
            Context = context;
            Logger = logger;
        }

        /// 
        public virtual async Task StoreAsync(PersistedGrant token)
        {
            var existing = (await Context.PersistedGrants.Where(x => x.Key == token.Key).ToArrayAsync())
                .SingleOrDefault(x => x.Key == token.Key);
            if (existing == null)
            {
                Logger.LogDebug("{persistedGrantKey} not found in database", token.Key);

                var persistedGrant = token.ToEntity();
                Context.PersistedGrants.Add(persistedGrant);
            }
            else
            {
                Logger.LogDebug("{persistedGrantKey} found in database", token.Key);

                token.UpdateEntity(existing);
            }

            try
            {
                await Context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                Logger.LogWarning("exception updating {persistedGrantKey} persisted grant in database: {error}", token.Key, ex.Message);
            }
        }

        /// 
        public virtual async Task GetAsync(string key)
        {
            var persistedGrant = (await Context.PersistedGrants.AsNoTracking().Where(x => x.Key == key).ToArrayAsync())
                .SingleOrDefault(x => x.Key == key);
            var model = persistedGrant?.ToModel();

            Logger.LogDebug("{persistedGrantKey} found in database: {persistedGrantKeyFound}", key, model != null);

            return model;
        }

        /// 
        public async Task> GetAllAsync(PersistedGrantFilter filter)
        {
            filter.Validate();

            var persistedGrants = await Filter(Context.PersistedGrants.AsQueryable(), filter).ToArrayAsync();
            persistedGrants = Filter(persistedGrants.AsQueryable(), filter).ToArray();
            
            var model = persistedGrants.Select(x => x.ToModel());

            Logger.LogDebug("{persistedGrantCount} persisted grants found for {@filter}", persistedGrants.Length, filter);

            return model;
        }

        /// 
        public virtual async Task RemoveAsync(string key)
        {
            var persistedGrant = (await Context.PersistedGrants.Where(x => x.Key == key).ToArrayAsync())
                .SingleOrDefault(x => x.Key == key);
            if (persistedGrant!= null)
            {
                Logger.LogDebug("removing {persistedGrantKey} persisted grant from database", key);

                Context.PersistedGrants.Remove(persistedGrant);

                try
                {
                    await Context.SaveChangesAsync();
                }
                catch(DbUpdateConcurrencyException ex)
                {
                    Logger.LogInformation("exception removing {persistedGrantKey} persisted grant from database: {error}", key, ex.Message);
                }
            }
            else
            {
                Logger.LogDebug("no {persistedGrantKey} persisted grant found in database", key);
            }
        }

        /// 
        public async Task RemoveAllAsync(PersistedGrantFilter filter)
        {
            filter.Validate();

            var persistedGrants = await Filter(Context.PersistedGrants.AsQueryable(), filter).ToArrayAsync();
            persistedGrants = Filter(persistedGrants.AsQueryable(), filter).ToArray();

            Logger.LogDebug("removing {persistedGrantCount} persisted grants from database for {@filter}", persistedGrants.Length, filter);

            Context.PersistedGrants.RemoveRange(persistedGrants);

            try
            {
                await Context.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException ex)
            {
                Logger.LogInformation("removing {persistedGrantCount} persisted grants from database for subject {@filter}: {error}", persistedGrants.Length, filter, ex.Message);
            }
        }


        private IQueryable Filter(IQueryable query, PersistedGrantFilter filter)
        {
            if (!String.IsNullOrWhiteSpace(filter.ClientId))
            {
                query = query.Where(x => x.ClientId == filter.ClientId);
            }
            if (!String.IsNullOrWhiteSpace(filter.SessionId))
            {
                query = query.Where(x => x.SessionId == filter.SessionId);
            }
            if (!String.IsNullOrWhiteSpace(filter.SubjectId))
            {
                query = query.Where(x => x.SubjectId == filter.SubjectId);
            }
            if (!String.IsNullOrWhiteSpace(filter.Type))
            {
                query = query.Where(x => x.Type == filter.Type);
            }

            return query;
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/Stores/ResourceStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;

namespace IdentityServer8.EntityFramework.Stores
{
    /// 
    /// Implementation of IResourceStore thats uses EF.
    /// 
    /// 
    public class ResourceStore : IResourceStore
    {
        /// 
        /// The DbContext.
        /// 
        protected readonly IConfigurationDbContext Context;
        
        /// 
        /// The logger.
        /// 
        protected readonly ILogger Logger;

        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The context.
        /// The logger.
        /// context
        public ResourceStore(IConfigurationDbContext context, ILogger logger)
        {
            Context = context ?? throw new ArgumentNullException(nameof(context));
            Logger = logger;
        }

        /// 
        /// Finds the API resources by name.
        /// 
        /// The names.
        /// 
        public virtual async Task> FindApiResourcesByNameAsync(IEnumerable apiResourceNames)
        {
            if (apiResourceNames == null) throw new ArgumentNullException(nameof(apiResourceNames));

            var query =
                from apiResource in Context.ApiResources
                where apiResourceNames.Contains(apiResource.Name)
                select apiResource;
            
            var apis = query
                .Include(x => x.Secrets)
                .Include(x => x.Scopes)
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();

            var result = (await apis.ToArrayAsync())
                .Where(x => apiResourceNames.Contains(x.Name))
                .Select(x => x.ToModel()).ToArray();

            if (result.Any())
            {
                Logger.LogDebug("Found {apis} API resource in database", result.Select(x => x.Name));
            }
            else
            {
                Logger.LogDebug("Did not find {apis} API resource in database", apiResourceNames);
            }

            return result;
        }

        /// 
        /// Gets API resources by scope name.
        /// 
        /// 
        /// 
        public virtual async Task> FindApiResourcesByScopeNameAsync(IEnumerable scopeNames)
        {
            var names = scopeNames.ToArray();

            var query =
                from api in Context.ApiResources
                where api.Scopes.Where(x => names.Contains(x.Scope)).Any()
                select api;

            var apis = query
                .Include(x => x.Secrets)
                .Include(x => x.Scopes)
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();

            var results = (await apis.ToArrayAsync())
                .Where(api => api.Scopes.Any(x => names.Contains(x.Scope)));
            var models = results.Select(x => x.ToModel()).ToArray();

            Logger.LogDebug("Found {apis} API resources in database", models.Select(x => x.Name));

            return models;
        }

        /// 
        /// Gets identity resources by scope name.
        /// 
        /// 
        /// 
        public virtual async Task> FindIdentityResourcesByScopeNameAsync(IEnumerable scopeNames)
        {
            var scopes = scopeNames.ToArray();

            var query =
                from identityResource in Context.IdentityResources
                where scopes.Contains(identityResource.Name)
                select identityResource;

            var resources = query
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();

            var results = (await resources.ToArrayAsync())
                .Where(x => scopes.Contains(x.Name));

            Logger.LogDebug("Found {scopes} identity scopes in database", results.Select(x => x.Name));

            return results.Select(x => x.ToModel()).ToArray();
        }

        /// 
        /// Gets scopes by scope name.
        /// 
        /// 
        /// 
        public virtual async Task> FindApiScopesByNameAsync(IEnumerable scopeNames)
        {
            var scopes = scopeNames.ToArray();

            var query =
                from scope in Context.ApiScopes
                where scopes.Contains(scope.Name)
                select scope;

            var resources = query
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();

            var results = (await resources.ToArrayAsync())
                .Where(x => scopes.Contains(x.Name));

            Logger.LogDebug("Found {scopes} scopes in database", results.Select(x => x.Name));

            return results.Select(x => x.ToModel()).ToArray();
        }

        /// 
        /// Gets all resources.
        /// 
        /// 
        public virtual async Task GetAllResourcesAsync()
        {
            var identity = Context.IdentityResources
              .Include(x => x.UserClaims)
              .Include(x => x.Properties);

            var apis = Context.ApiResources
                .Include(x => x.Secrets)
                .Include(x => x.Scopes)
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();
            
            var scopes = Context.ApiScopes
                .Include(x => x.UserClaims)
                .Include(x => x.Properties)
                .AsNoTracking();

            var result = new Resources(
                (await identity.ToArrayAsync()).Select(x => x.ToModel()),
                (await apis.ToArrayAsync()).Select(x => x.ToModel()),
                (await scopes.ToArrayAsync()).Select(x => x.ToModel())
            );

            Logger.LogDebug("Found {scopes} as all scopes, and {apis} as API resources", 
                result.IdentityResources.Select(x=>x.Name).Union(result.ApiScopes.Select(x=>x.Name)),
                result.ApiResources.Select(x=>x.Name));

            return result;
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/src/TokenCleanup/IOperationalStoreNotification.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Entities;

namespace IdentityServer8.EntityFramework
{
    /// 
    /// Interface to model notifications from the TokenCleanup feature.
    /// 
    public interface IOperationalStoreNotification
    {
        /// 
        /// Notification for persisted grants being removed.
        /// 
        /// 
        /// 
        Task PersistedGrantsRemovedAsync(IEnumerable persistedGrants);

        /// 
        /// Notification for device codes being removed.
        /// 
        /// 
        /// 
        Task DeviceCodesRemovedAsync(IEnumerable deviceCodes);
    }
}


================================================
FILE: src/EntityFramework.Storage/src/TokenCleanup/TokenCleanupService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.EntityFramework
{
    /// 
    /// Helper to cleanup stale persisted grants and device codes.
    /// 
    public class TokenCleanupService
    {
        private readonly OperationalStoreOptions _options;
        private readonly IPersistedGrantDbContext _persistedGrantDbContext;
        private readonly IOperationalStoreNotification _operationalStoreNotification;
        private readonly ILogger _logger;

        /// 
        /// Constructor for TokenCleanupService.
        /// 
        /// 
        /// 
        /// 
        /// 
        public TokenCleanupService(
            OperationalStoreOptions options,
            IPersistedGrantDbContext persistedGrantDbContext, 
            ILogger logger,
            IOperationalStoreNotification operationalStoreNotification = null)
        {
            _options = options ?? throw new ArgumentNullException(nameof(options));
            if (_options.TokenCleanupBatchSize < 1) throw new ArgumentException("Token cleanup batch size interval must be at least 1");

            _persistedGrantDbContext = persistedGrantDbContext ?? throw new ArgumentNullException(nameof(persistedGrantDbContext));
            _logger = logger ?? throw new ArgumentNullException(nameof(logger));

            _operationalStoreNotification = operationalStoreNotification;
        }

        /// 
        /// Method to clear expired persisted grants.
        /// 
        /// 
        public async Task RemoveExpiredGrantsAsync()
        {
            try
            {
                _logger.LogTrace("Querying for expired grants to remove");

                await RemoveGrantsAsync();
                await RemoveDeviceCodesAsync();
            }
            catch (Exception ex)
            {
                _logger.LogError("Exception removing expired grants: {exception}", ex.Message);
            }
        }

        /// 
        /// Removes the stale persisted grants.
        /// 
        /// 
        protected virtual async Task RemoveGrantsAsync()
        {
            var found = Int32.MaxValue;
            
            while (found >= _options.TokenCleanupBatchSize)
            {
                var expiredGrants = await _persistedGrantDbContext.PersistedGrants
                    .Where(x => x.Expiration < DateTime.UtcNow)
                    .OrderBy(x => x.Expiration)
                    .Take(_options.TokenCleanupBatchSize)
                    .ToArrayAsync();

                found = expiredGrants.Length;
                _logger.LogInformation("Removing {grantCount} grants", found);

                if (found > 0)
                {
                    _persistedGrantDbContext.PersistedGrants.RemoveRange(expiredGrants);
                    await SaveChangesAsync();

                    if (_operationalStoreNotification != null)
                    {
                        await _operationalStoreNotification.PersistedGrantsRemovedAsync(expiredGrants);
                    }
                }
            }
        }


        /// 
        /// Removes the stale device codes.
        /// 
        /// 
        protected virtual async Task RemoveDeviceCodesAsync()
        {
            var found = Int32.MaxValue;

            while (found >= _options.TokenCleanupBatchSize)
            {
                var expiredCodes = await _persistedGrantDbContext.DeviceFlowCodes
                    .Where(x => x.Expiration < DateTime.UtcNow)
                    .OrderBy(x => x.Expiration)
                    .Take(_options.TokenCleanupBatchSize)
                    .ToArrayAsync();

                found = expiredCodes.Length;
                _logger.LogInformation("Removing {deviceCodeCount} device flow codes", found);

                if (found > 0)
                {
                    _persistedGrantDbContext.DeviceFlowCodes.RemoveRange(expiredCodes);
                    await SaveChangesAsync();

                    if (_operationalStoreNotification != null)
                    {
                        await _operationalStoreNotification.DeviceCodesRemovedAsync(expiredCodes);
                    }
                }
            }
        }

        private async Task SaveChangesAsync()
        {
            var count = 3;

            while (count > 0)
            {
                try
                {
                    await _persistedGrantDbContext.SaveChangesAsync();
                    return;
                }
                catch (DbUpdateConcurrencyException ex)
                {
                    count--;

                    // we get this if/when someone else already deleted the records
                    // we want to essentially ignore this, and keep working
                    _logger.LogDebug("Concurrency exception removing expired grants: {exception}", ex.Message);

                    foreach (var entry in ex.Entries)
                    {
                        // mark this entry as not attached anymore so we don't try to re-delete
                        entry.State = EntityState.Detached;
                    }
                }
            }

            _logger.LogDebug("Too many concurrency exceptions. Exiting.");
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/DatabaseProviderBuilder.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// Helper methods to initialize DbContextOptions for the specified database provider and context.
/// 
public class DatabaseProviderBuilder
{
    public static DbContextOptions BuildInMemory(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseInMemoryDatabase(name);
        return builder.Options;
    }

    public static DbContextOptions BuildSqlite(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseSqlite($"Filename=./Test.IdentityServer8.EntityFramework-3.1.0.{name}.db");
        return builder.Options;
    }

    public static DbContextOptions BuildLocalDb(string name) where T : DbContext
    {
        var builder = new DbContextOptionsBuilder();
        builder.UseSqlServer(
            $@"Data Source=(LocalDb)\MSSQLLocalDB;database=Test.IdentityServer8.EntityFramework-3.1.0.{name};trusted_connection=yes;");
        return builder.Options;
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/DatabaseProviderFixture.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// xUnit ClassFixture for creating and deleting integration test databases.
/// 
/// DbContext of Type T
public class DatabaseProviderFixture : IDisposable where T : DbContext
{
    public object StoreOptions;
    public List> Options;

    public void Dispose()
    {
        if (Options != null) // null check since fixtures are created even when tests are skipped
        {
            foreach (var option in Options.ToList())
            {
                using (var context = (T)Activator.CreateInstance(typeof(T), option, StoreOptions))
                {
                    context.Database.EnsureDeleted();
                }
            }
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/DbContexts/ClientDbContextTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.DbContexts;
using Microsoft.EntityFrameworkCore;
using System.Linq;
using IdentityServer8.EntityFramework.Entities;
using IdentityServer8.EntityFramework.Options;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.DbContexts;

public class ClientDbContextTests : IntegrationTest
{
    public ClientDbContextTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new ConfigurationDbContext(options, StoreOptions))
                context.Database.EnsureCreated();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public void CanAddAndDeleteClientScopes(DbContextOptions options)
    {
        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            db.Clients.Add(new Client
            {
                ClientId = "test-client-scopes",
                ClientName = "Test Client"
            });

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            // explicit include due to lack of EF Core lazy loading
            var client = db.Clients.Include(x => x.AllowedScopes).First();

            client.AllowedScopes.Add(new ClientScope
            {
                Scope = "test"
            });

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            var client = db.Clients.Include(x => x.AllowedScopes).First();
            var scope = client.AllowedScopes.First();

            client.AllowedScopes.Remove(scope);

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            var client = db.Clients.Include(x => x.AllowedScopes).First();

            Assert.Empty(client.AllowedScopes);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public void CanAddAndDeleteClientRedirectUri(DbContextOptions options)
    {
        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            db.Clients.Add(new Client
            {
                ClientId = "test-client",
                ClientName = "Test Client"
            });

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            var client = db.Clients.Include(x => x.RedirectUris).First();

            client.RedirectUris.Add(new ClientRedirectUri
            {
                RedirectUri = "https://redirect-uri-1"
            });

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            var client = db.Clients.Include(x => x.RedirectUris).First();
            var redirectUri = client.RedirectUris.First();

            client.RedirectUris.Remove(redirectUri);

            db.SaveChanges();
        }

        using (var db = new ConfigurationDbContext(options, StoreOptions))
        {
            var client = db.Clients.Include(x => x.RedirectUris).First();

            Assert.Empty(client.RedirectUris);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/FakeLogger.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.Extensions.Logging;

namespace IdentityServer8.EntityFramework.IntegrationTests;

public class FakeLogger : FakeLogger, ILogger
{
    public static ILogger Create()
    {
        return new FakeLogger();
    }
}

public class FakeLogger : ILogger, IDisposable
{
    public IDisposable BeginScope(TState state)
    {
        return this;
    }

    public void Dispose()
    {
    }

    public bool IsEnabled(LogLevel logLevel)
    {
        return false;
    }

    public void Log(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func formatter)
    {
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/IdentityServer8.EntityFramework.IntegrationTests.csproj
================================================


  

    ../../../../key.snk
    true
    true
  


  
    
    
    
  

  
    
    
    
    
    
      runtime; build; native; contentfiles; analyzers; buildtransitive
      all
    
    
    
    
  


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/IntegrationTest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using System.Runtime.InteropServices;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests;

/// 
/// Base class for integration tests, responsible for initializing test database providers & an xUnit class fixture
/// 
/// The type of the class.
/// The type of the database context.
/// The type of the store option.
/// 
public class IntegrationTest : IClassFixture>
    where TDbContext : DbContext
{
    public static readonly TheoryData> TestDatabaseProviders;
    protected readonly TStoreOption StoreOptions = Activator.CreateInstance();

    static IntegrationTest()
    {
        var config = new ConfigurationBuilder()
            .AddEnvironmentVariables()
            .Build();

        if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
        {
            Console.WriteLine($"Running Local Tests for {typeof(TClass).Name}");

            TestDatabaseProviders = new TheoryData>
            {
                DatabaseProviderBuilder.BuildInMemory(typeof(TClass).Name),
                //DatabaseProviderBuilder.BuildSqlite(typeof(TClass).Name),
                //DatabaseProviderBuilder.BuildLocalDb(typeof(TClass).Name)
            };
        }
        else
        {
            TestDatabaseProviders = new TheoryData>
            {
                DatabaseProviderBuilder.BuildInMemory(typeof(TClass).Name),
                DatabaseProviderBuilder.BuildSqlite(typeof(TClass).Name)
            };
            Console.WriteLine("Skipping DB integration tests on non-Windows");
        }
    }

    protected IntegrationTest(DatabaseProviderFixture fixture)
    {
        fixture.Options = TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList();
        fixture.StoreOptions = StoreOptions;
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/Stores/ClientStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Stores;
using IdentityServer8.Models;
using Microsoft.EntityFrameworkCore;
using Xunit;
using Xunit.Sdk;

namespace IdentityServer8.EntityFramework.IntegrationTests.Stores;

public class ClientStoreTests : IntegrationTest
{
    public ClientStoreTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions) y)).ToList())
        {
            using (var context = new ConfigurationDbContext(options, StoreOptions))
            {
                context.Database.EnsureCreated();
            }
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindClientByIdAsync_WhenClientDoesNotExist_ExpectNull(DbContextOptions options)
    {
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ClientStore(context, FakeLogger.Create());
            var client = await store.FindClientByIdAsync(Guid.NewGuid().ToString());
            client.Should().BeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindClientByIdAsync_WhenClientExists_ExpectClientRetured(DbContextOptions options)
    {
        var testClient = new Client
        {
            ClientId = "test_client",
            ClientName = "Test Client"
        };

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.Clients.Add(testClient.ToEntity());
            context.SaveChanges();
        }

        Client client;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ClientStore(context, FakeLogger.Create());
            client = await store.FindClientByIdAsync(testClient.ClientId);
        }

        client.Should().NotBeNull();
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindClientByIdAsync_WhenClientExistsWithCollections_ExpectClientReturnedCollections(DbContextOptions options)
    {
        var testClient = new Client
        {
            ClientId = "properties_test_client",
            ClientName = "Properties Test Client",
            AllowedCorsOrigins = {"https://localhost"},
            AllowedGrantTypes = GrantTypes.HybridAndClientCredentials,
            AllowedScopes = {"openid", "profile", "api1"},
            Claims = {new ClientClaim("test", "value")},
            ClientSecrets = {new Secret("secret".Sha256())},
            IdentityProviderRestrictions = {"AD"},
            PostLogoutRedirectUris = {"https://locahost/signout-callback"},
            Properties = {{"foo1", "bar1"}, {"foo2", "bar2"},},
            RedirectUris = {"https://locahost/signin"}
        };

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.Clients.Add(testClient.ToEntity());
            context.SaveChanges();
        }

        Client client;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ClientStore(context, FakeLogger.Create());
            client = await store.FindClientByIdAsync(testClient.ClientId);
        }

        client.Should().BeEquivalentTo(testClient);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindClientByIdAsync_WhenClientsExistWithManyCollections_ExpectClientReturnedInUnderFiveSeconds(DbContextOptions options)
    {
        var testClient = new Client
        {
            ClientId = "test_client_with_uris",
            ClientName = "Test client with URIs",
            AllowedScopes = {"openid", "profile", "api1"},
            AllowedGrantTypes = GrantTypes.CodeAndClientCredentials
        };

        for (int i = 0; i < 50; i++)
        {
            testClient.RedirectUris.Add($"https://localhost/{i}");
            testClient.PostLogoutRedirectUris.Add($"https://localhost/{i}");
            testClient.AllowedCorsOrigins.Add($"https://localhost:{i}");
        }

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.Clients.Add(testClient.ToEntity());

            for (int i = 0; i < 50; i++)
            {
                context.Clients.Add(new Client
                {
                    ClientId = testClient.ClientId + i,
                    ClientName = testClient.ClientName,
                    AllowedScopes = testClient.AllowedScopes,
                    AllowedGrantTypes = testClient.AllowedGrantTypes,
                    RedirectUris = testClient.RedirectUris,
                    PostLogoutRedirectUris = testClient.PostLogoutRedirectUris,
                    AllowedCorsOrigins = testClient.AllowedCorsOrigins,
                }.ToEntity());
            }

            context.SaveChanges();
        }
        
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ClientStore(context, FakeLogger.Create());

            const int timeout = 5000;
            var task = Task.Run(() => store.FindClientByIdAsync(testClient.ClientId));

            if (await Task.WhenAny(task, Task.Delay(timeout)) == task)
            {
                var client = await task;
                client.Should().BeEquivalentTo(testClient);
            }
            else
            {
                throw new TestTimeoutException(timeout);
            }
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/Stores/DeviceFlowStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Entities;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Stores;
using IdentityServer8.Models;
using IdentityServer8.Stores.Serialization;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.InMemory.Infrastructure.Internal;
using System.Security.Claims;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.Stores;

public class DeviceFlowStoreTests : IntegrationTest
{
    private readonly IPersistentGrantSerializer serializer = new PersistentGrantSerializer();

    public DeviceFlowStoreTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new PersistedGrantDbContext(options, StoreOptions))
                context.Database.EnsureCreated();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task StoreDeviceAuthorizationAsync_WhenSuccessful_ExpectDeviceCodeAndUserCodeStored(DbContextOptions options)
    {
        var deviceCode = Guid.NewGuid().ToString();
        var userCode = Guid.NewGuid().ToString();
        var data = new DeviceCode
        {
            ClientId = Guid.NewGuid().ToString(),
            CreationTime = DateTime.UtcNow,
            Lifetime = 300
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            await store.StoreDeviceAuthorizationAsync(deviceCode, userCode, data);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundDeviceFlowCodes = context.DeviceFlowCodes.FirstOrDefault(x => x.DeviceCode == deviceCode);

            foundDeviceFlowCodes.Should().NotBeNull();
            foundDeviceFlowCodes?.DeviceCode.Should().Be(deviceCode);
            foundDeviceFlowCodes?.UserCode.Should().Be(userCode);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task StoreDeviceAuthorizationAsync_WhenSuccessful_ExpectDataStored(DbContextOptions options)
    {
        var deviceCode = Guid.NewGuid().ToString();
        var userCode = Guid.NewGuid().ToString();
        var data = new DeviceCode
        {
            ClientId = Guid.NewGuid().ToString(),
            CreationTime = DateTime.UtcNow,
            Lifetime = 300
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            await store.StoreDeviceAuthorizationAsync(deviceCode, userCode, data);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundDeviceFlowCodes = context.DeviceFlowCodes.FirstOrDefault(x => x.DeviceCode == deviceCode);

            foundDeviceFlowCodes.Should().NotBeNull();
            var deserializedData = new PersistentGrantSerializer().Deserialize(foundDeviceFlowCodes?.Data);

            deserializedData.CreationTime.Should().BeCloseTo(data.CreationTime, TimeSpan.FromMilliseconds(100));
            deserializedData.ClientId.Should().Be(data.ClientId);
            deserializedData.Lifetime.Should().Be(data.Lifetime);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task StoreDeviceAuthorizationAsync_WhenUserCodeAlreadyExists_ExpectException(DbContextOptions options)
    {
        var existingUserCode = $"user_{Guid.NewGuid().ToString()}";
        var deviceCodeData = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] { "openid", "api1" },
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true,
            Subject = new ClaimsPrincipal(new ClaimsIdentity(
                new List { new Claim(JwtClaimTypes.Subject, $"sub_{Guid.NewGuid().ToString()}") }))
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = $"device_{Guid.NewGuid().ToString()}",
                UserCode = existingUserCode,
                ClientId = deviceCodeData.ClientId,
                SubjectId = deviceCodeData.Subject.FindFirst(JwtClaimTypes.Subject).Value,
                CreationTime = deviceCodeData.CreationTime,
                Expiration = deviceCodeData.CreationTime.AddSeconds(deviceCodeData.Lifetime),
                Data = serializer.Serialize(deviceCodeData)
            });
            context.SaveChanges();
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());

            // skip odd behaviour of in-memory provider
            if (options.Extensions.All(x => x.GetType() != typeof(InMemoryOptionsExtension)))
            {
                await Assert.ThrowsAsync(() =>
                    store.StoreDeviceAuthorizationAsync($"device_{Guid.NewGuid().ToString()}", existingUserCode, deviceCodeData));
            }
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task StoreDeviceAuthorizationAsync_WhenDeviceCodeAlreadyExists_ExpectException(DbContextOptions options)
    {
        var existingDeviceCode = $"device_{Guid.NewGuid().ToString()}";
        var deviceCodeData = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] { "openid", "api1" },
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true,
            Subject = new ClaimsPrincipal(new ClaimsIdentity(
                new List { new Claim(JwtClaimTypes.Subject, $"sub_{Guid.NewGuid().ToString()}") }))
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = existingDeviceCode,
                UserCode = $"user_{Guid.NewGuid().ToString()}",
                ClientId = deviceCodeData.ClientId,
                SubjectId = deviceCodeData.Subject.FindFirst(JwtClaimTypes.Subject).Value,
                CreationTime = deviceCodeData.CreationTime,
                Expiration = deviceCodeData.CreationTime.AddSeconds(deviceCodeData.Lifetime),
                Data = serializer.Serialize(deviceCodeData)
            });
            context.SaveChanges();
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());

            // skip odd behaviour of in-memory provider
            if (options.Extensions.All(x => x.GetType() != typeof(InMemoryOptionsExtension)))
            {
                await Assert.ThrowsAsync(() =>
                    store.StoreDeviceAuthorizationAsync(existingDeviceCode, $"user_{Guid.NewGuid().ToString()}", deviceCodeData));
            }
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindByUserCodeAsync_WhenUserCodeExists_ExpectDataRetrievedCorrectly(DbContextOptions options)
    {
        var testDeviceCode = $"device_{Guid.NewGuid().ToString()}";
        var testUserCode = $"user_{Guid.NewGuid().ToString()}";

        var expectedSubject = $"sub_{Guid.NewGuid().ToString()}";
        var expectedDeviceCodeData = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] { "openid", "api1" },
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true,
            Subject = new ClaimsPrincipal(new ClaimsIdentity(new List { new Claim(JwtClaimTypes.Subject, expectedSubject) }))
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = testDeviceCode,
                UserCode = testUserCode,
                ClientId = expectedDeviceCodeData.ClientId,
                SubjectId = expectedDeviceCodeData.Subject.FindFirst(JwtClaimTypes.Subject).Value,
                CreationTime = expectedDeviceCodeData.CreationTime,
                Expiration = expectedDeviceCodeData.CreationTime.AddSeconds(expectedDeviceCodeData.Lifetime),
                Data = serializer.Serialize(expectedDeviceCodeData)
            });
            context.SaveChanges();
        }

        DeviceCode code;
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            code = await store.FindByUserCodeAsync(testUserCode);
        }
        
        code.Should().BeEquivalentTo(expectedDeviceCodeData, 
            assertionOptions => assertionOptions.Excluding(x=> x.Subject));

        code.Subject.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject && x.Value == expectedSubject).Should().NotBeNull();
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindByUserCodeAsync_WhenUserCodeDoesNotExist_ExpectNull(DbContextOptions options)
    {
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            var code = await store.FindByUserCodeAsync($"user_{Guid.NewGuid().ToString()}");
            code.Should().BeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindByDeviceCodeAsync_WhenDeviceCodeExists_ExpectDataRetrievedCorrectly(DbContextOptions options)
    {
        var testDeviceCode = $"device_{Guid.NewGuid().ToString()}";
        var testUserCode = $"user_{Guid.NewGuid().ToString()}";

        var expectedSubject = $"sub_{Guid.NewGuid().ToString()}";
        var expectedDeviceCodeData = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] { "openid", "api1" },
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true,
            Subject = new ClaimsPrincipal(new ClaimsIdentity(new List { new Claim(JwtClaimTypes.Subject, expectedSubject) }))
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = testDeviceCode,
                UserCode = testUserCode,
                ClientId = expectedDeviceCodeData.ClientId,
                SubjectId = expectedDeviceCodeData.Subject.FindFirst(JwtClaimTypes.Subject).Value,
                CreationTime = expectedDeviceCodeData.CreationTime,
                Expiration = expectedDeviceCodeData.CreationTime.AddSeconds(expectedDeviceCodeData.Lifetime),
                Data = serializer.Serialize(expectedDeviceCodeData)
            });
            context.SaveChanges();
        }

        DeviceCode code;
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            code = await store.FindByDeviceCodeAsync(testDeviceCode);
        }

        code.Should().BeEquivalentTo(expectedDeviceCodeData,
            assertionOptions => assertionOptions.Excluding(x => x.Subject));

        code.Subject.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject && x.Value == expectedSubject).Should().NotBeNull();
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindByDeviceCodeAsync_WhenDeviceCodeDoesNotExist_ExpectNull(DbContextOptions options)
    {
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            var code = await store.FindByDeviceCodeAsync($"device_{Guid.NewGuid().ToString()}");
            code.Should().BeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task UpdateByUserCodeAsync_WhenDeviceCodeAuthorized_ExpectSubjectAndDataUpdated(DbContextOptions options)
    {
        var testDeviceCode = $"device_{Guid.NewGuid().ToString()}";
        var testUserCode = $"user_{Guid.NewGuid().ToString()}";

        var expectedSubject = $"sub_{Guid.NewGuid().ToString()}";
        var unauthorizedDeviceCode = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] {"openid", "api1"},
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = testDeviceCode,
                UserCode = testUserCode,
                ClientId = unauthorizedDeviceCode.ClientId,
                CreationTime = unauthorizedDeviceCode.CreationTime,
                Expiration = unauthorizedDeviceCode.CreationTime.AddSeconds(unauthorizedDeviceCode.Lifetime),
                Data = serializer.Serialize(unauthorizedDeviceCode)
            });
            context.SaveChanges();
        }

        var authorizedDeviceCode = new DeviceCode
        {
            ClientId = unauthorizedDeviceCode.ClientId,
            RequestedScopes = unauthorizedDeviceCode.RequestedScopes,
            AuthorizedScopes = unauthorizedDeviceCode.RequestedScopes,
            Subject = new ClaimsPrincipal(new ClaimsIdentity(new List { new Claim(JwtClaimTypes.Subject, expectedSubject) })),
            IsAuthorized = true,
            IsOpenId = true,
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            await store.UpdateByUserCodeAsync(testUserCode, authorizedDeviceCode);
        }

        DeviceFlowCodes updatedCodes;
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            updatedCodes = context.DeviceFlowCodes.Single(x => x.UserCode == testUserCode);
        }

        // should be unchanged
        updatedCodes.DeviceCode.Should().Be(testDeviceCode);
        updatedCodes.ClientId.Should().Be(unauthorizedDeviceCode.ClientId);
        updatedCodes.CreationTime.Should().Be(unauthorizedDeviceCode.CreationTime);
        updatedCodes.Expiration.Should().Be(unauthorizedDeviceCode.CreationTime.AddSeconds(authorizedDeviceCode.Lifetime));

        // should be changed
        var parsedCode = serializer.Deserialize(updatedCodes.Data);
        parsedCode.Should().BeEquivalentTo(authorizedDeviceCode, assertionOptions => assertionOptions.Excluding(x => x.Subject));
        parsedCode.Subject.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.Subject && x.Value == expectedSubject).Should().NotBeNull();
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveByDeviceCodeAsync_WhenDeviceCodeExists_ExpectDeviceCodeDeleted(DbContextOptions options)
    {
        var testDeviceCode = $"device_{Guid.NewGuid().ToString()}";
        var testUserCode = $"user_{Guid.NewGuid().ToString()}";

        var existingDeviceCode = new DeviceCode
        {
            ClientId = "device_flow",
            RequestedScopes = new[] { "openid", "api1" },
            CreationTime = new DateTime(2018, 10, 19, 16, 14, 29),
            Lifetime = 300,
            IsOpenId = true
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(new DeviceFlowCodes
            {
                DeviceCode = testDeviceCode,
                UserCode = testUserCode,
                ClientId = existingDeviceCode.ClientId,
                CreationTime = existingDeviceCode.CreationTime,
                Expiration = existingDeviceCode.CreationTime.AddSeconds(existingDeviceCode.Lifetime),
                Data = serializer.Serialize(existingDeviceCode)
            });
            context.SaveChanges();
        }
        
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            await store.RemoveByDeviceCodeAsync(testDeviceCode);
        }
        
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.FirstOrDefault(x => x.UserCode == testUserCode).Should().BeNull();
        }
    }
    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveByDeviceCodeAsync_WhenDeviceCodeDoesNotExists_ExpectSuccess(DbContextOptions options)
    {
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new DeviceFlowStore(context, new PersistentGrantSerializer(), FakeLogger.Create());
            await store.RemoveByDeviceCodeAsync($"device_{Guid.NewGuid().ToString()}");
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/Stores/PersistedGrantStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Stores;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Microsoft.EntityFrameworkCore;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.Stores;

public class PersistedGrantStoreTests : IntegrationTest
{
    public PersistedGrantStoreTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new PersistedGrantDbContext(options, StoreOptions))
                context.Database.EnsureCreated();
        }
    }

    private static PersistedGrant CreateTestObject(string sub = null, string clientId = null, string sid = null, string type = null)
    {
        return new PersistedGrant
        {
            Key = Guid.NewGuid().ToString(),
            Type = type ?? "authorization_code",
            ClientId = clientId ?? Guid.NewGuid().ToString(),
            SubjectId = sub ?? Guid.NewGuid().ToString(),
            SessionId = sid ?? Guid.NewGuid().ToString(),
            CreationTime = new DateTime(2016, 08, 01),
            Expiration = new DateTime(2016, 08, 31),
            Data = Guid.NewGuid().ToString()
        };
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task StoreAsync_WhenPersistedGrantStored_ExpectSuccess(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            await store.StoreAsync(persistedGrant);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.NotNull(foundGrant);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task GetAsync_WithKeyAndPersistedGrantExists_ExpectPersistedGrantReturned(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }

        PersistedGrant foundPersistedGrant;
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            foundPersistedGrant = await store.GetAsync(persistedGrant.Key);
        }

        Assert.NotNull(foundPersistedGrant);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task GetAllAsync_WithSubAndTypeAndPersistedGrantExists_ExpectPersistedGrantReturned(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }

        IList foundPersistedGrants;
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            foundPersistedGrants = (await store.GetAllAsync(new PersistedGrantFilter { SubjectId = persistedGrant.SubjectId })).ToList();
        }

        Assert.NotNull(foundPersistedGrants);
        Assert.NotEmpty(foundPersistedGrants);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task GetAllAsync_Should_Filter(DbContextOptions options)
    {
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s1", type: "t1").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s1", type: "t2").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s2", type: "t1").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s2", type: "t2").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s1", type: "t1").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s1", type: "t2").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s2", type: "t1").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s2", type: "t2").ToEntity());
            context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c3", sid: "s3", type: "t3").ToEntity());
            context.PersistedGrants.Add(CreateTestObject().ToEntity());
            context.SaveChanges();
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1"
            })).ToList().Count.Should().Be(9);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2"
            })).ToList().Count.Should().Be(0);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1"
            })).ToList().Count.Should().Be(4);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c2"
            })).ToList().Count.Should().Be(4);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c3"
            })).ToList().Count.Should().Be(1);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c4"
            })).ToList().Count.Should().Be(0);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1",
                SessionId = "s1"
            })).ToList().Count.Should().Be(2);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c3",
                SessionId = "s1"
            })).ToList().Count.Should().Be(0);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1",
                SessionId = "s1",
                Type = "t1"
            })).ToList().Count.Should().Be(1);
            (await store.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1",
                SessionId = "s1",
                Type = "t3"
            })).ToList().Count.Should().Be(0);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveAsync_WhenKeyOfExistingReceived_ExpectGrantDeleted(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }
        
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            await store.RemoveAsync(persistedGrant.Key);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.Null(foundGrant);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveAllAsync_WhenSubIdAndClientIdOfExistingReceived_ExpectGrantDeleted(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            await store.RemoveAllAsync(new PersistedGrantFilter { 
                SubjectId = persistedGrant.SubjectId, 
                ClientId = persistedGrant.ClientId 
            });
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.Null(foundGrant);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveAllAsync_WhenSubIdClientIdAndTypeOfExistingReceived_ExpectGrantDeleted(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            await store.RemoveAllAsync(new PersistedGrantFilter { 
                SubjectId = persistedGrant.SubjectId, 
                ClientId = persistedGrant.ClientId, 
                Type = persistedGrant.Type });
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.Null(foundGrant);
        }
    }


    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveAllAsync_Should_Filter(DbContextOptions options)
    {
        void PopulateDb()
        {
            using (var context = new PersistedGrantDbContext(options, StoreOptions))
            {
                context.PersistedGrants.RemoveRange(context.PersistedGrants.ToArray());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s1", type: "t1").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s1", type: "t2").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s2", type: "t1").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c1", sid: "s2", type: "t2").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s1", type: "t1").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s1", type: "t2").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s2", type: "t1").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c2", sid: "s2", type: "t2").ToEntity());
                context.PersistedGrants.Add(CreateTestObject(sub: "sub1", clientId: "c3", sid: "s3", type: "t3").ToEntity());
                context.PersistedGrants.Add(CreateTestObject().ToEntity());
                context.SaveChanges();
            }
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1"
            });
            context.PersistedGrants.Count().Should().Be(1);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2"
            });
            context.PersistedGrants.Count().Should().Be(10);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1", ClientId = "c1"
            });
            context.PersistedGrants.Count().Should().Be(6);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c2"
            });
            context.PersistedGrants.Count().Should().Be(6);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c3"
            });
            context.PersistedGrants.Count().Should().Be(9);
        }


        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c4"
            });
            context.PersistedGrants.Count().Should().Be(10);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1", 
                SessionId = "s1"
            });
            context.PersistedGrants.Count().Should().Be(8);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c3",
                SessionId = "s1"
            });
            context.PersistedGrants.Count().Should().Be(10);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1",
                SessionId = "s1", 
                Type = "t1"
            });
            context.PersistedGrants.Count().Should().Be(9);
        }

        PopulateDb();
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());

            await store.RemoveAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "c1",
                SessionId = "s1",
                Type = "t3"
            });
            context.PersistedGrants.Count().Should().Be(10);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task Store_should_create_new_record_if_key_does_not_exist(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.Null(foundGrant);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            await store.StoreAsync(persistedGrant);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.NotNull(foundGrant);
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task Store_should_update_record_if_key_already_exists(DbContextOptions options)
    {
        var persistedGrant = CreateTestObject();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(persistedGrant.ToEntity());
            context.SaveChanges();
        }

        var newDate = persistedGrant.Expiration.Value.AddHours(1);
        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var store = new PersistedGrantStore(context, FakeLogger.Create());
            persistedGrant.Expiration = newDate;
            await store.StoreAsync(persistedGrant);
        }

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            var foundGrant = context.PersistedGrants.FirstOrDefault(x => x.Key == persistedGrant.Key);
            Assert.NotNull(foundGrant);
            Assert.Equal(newDate, persistedGrant.Expiration);
        }
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/Stores/ResourceStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityModel;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Stores;
using IdentityServer8.Models;
using Microsoft.EntityFrameworkCore;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.Stores;

public class ScopeStoreTests : IntegrationTest
{
    public ScopeStoreTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new ConfigurationDbContext(options, StoreOptions))
                context.Database.EnsureCreated();
        }
    }

    private static IdentityResource CreateIdentityTestResource()
    {
        return new IdentityResource()
        {
            Name = Guid.NewGuid().ToString(),
            DisplayName = Guid.NewGuid().ToString(),
            Description = Guid.NewGuid().ToString(),
            ShowInDiscoveryDocument = true,
            UserClaims = 
            {
                JwtClaimTypes.Subject,
                JwtClaimTypes.Name,
            }
        };
    }

    private static ApiResource CreateApiResourceTestResource()
    {
        return new ApiResource()
        {
            Name = Guid.NewGuid().ToString(),
            ApiSecrets = new List { new Secret("secret".ToSha256()) },
            Scopes = { Guid.NewGuid().ToString() },
            UserClaims =
            {
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
            }
        };
    }
    
    private static ApiScope CreateApiScopeTestResource()
    {
        return new ApiScope()
        {
            Name = Guid.NewGuid().ToString(),
            UserClaims =
            {
                Guid.NewGuid().ToString(),
                Guid.NewGuid().ToString(),
            }
        };
    }


    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiResourcesByNameAsync_WhenResourceExists_ExpectResourceAndCollectionsReturned(DbContextOptions options)
    {
        var resource = CreateApiResourceTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.ApiResources.Add(resource.ToEntity());
            context.SaveChanges();
        }

        ApiResource foundResource;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
        }

        Assert.NotNull(foundResource);
        Assert.True(foundResource.Name == resource.Name);

        Assert.NotNull(foundResource.UserClaims);
        Assert.NotEmpty(foundResource.UserClaims);
        Assert.NotNull(foundResource.ApiSecrets);
        Assert.NotEmpty(foundResource.ApiSecrets);
        Assert.NotNull(foundResource.Scopes);
        Assert.NotEmpty(foundResource.Scopes);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiResourcesByNameAsync_WhenResourcesExist_ExpectOnlyResourcesRequestedReturned(DbContextOptions options)
    {
        var resource = CreateApiResourceTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.ApiResources.Add(resource.ToEntity());
            context.ApiResources.Add(CreateApiResourceTestResource().ToEntity());
            context.SaveChanges();
        }

        ApiResource foundResource;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            foundResource = (await store.FindApiResourcesByNameAsync(new[] { resource.Name })).SingleOrDefault();
        }

        Assert.NotNull(foundResource);
        Assert.True(foundResource.Name == resource.Name);

        Assert.NotNull(foundResource.UserClaims);
        Assert.NotEmpty(foundResource.UserClaims);
        Assert.NotNull(foundResource.ApiSecrets);
        Assert.NotEmpty(foundResource.ApiSecrets);
        Assert.NotNull(foundResource.Scopes);
        Assert.NotEmpty(foundResource.Scopes);
    }




    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiResourcesByScopeNameAsync_WhenResourcesExist_ExpectResourcesReturned(DbContextOptions options)
    {
        var testApiResource = CreateApiResourceTestResource();
        var testApiScope = CreateApiScopeTestResource();
        testApiResource.Scopes.Add(testApiScope.Name);

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.ApiResources.Add(testApiResource.ToEntity());
            context.ApiScopes.Add(testApiScope.ToEntity());
            context.SaveChanges();
        }

        IEnumerable resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = await store.FindApiResourcesByScopeNameAsync(new List
            {
                testApiScope.Name
            });
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        Assert.NotNull(resources.Single(x => x.Name == testApiResource.Name));
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiResourcesByScopeNameAsync_WhenResourcesExist_ExpectOnlyResourcesRequestedReturned(DbContextOptions options)
    {
        var testIdentityResource = CreateIdentityTestResource();
        var testApiResource = CreateApiResourceTestResource();
        var testApiScope = CreateApiScopeTestResource();
        testApiResource.Scopes.Add(testApiScope.Name);

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.IdentityResources.Add(testIdentityResource.ToEntity());
            context.ApiResources.Add(testApiResource.ToEntity());
            context.ApiScopes.Add(testApiScope.ToEntity());
            context.IdentityResources.Add(CreateIdentityTestResource().ToEntity());
            context.ApiResources.Add(CreateApiResourceTestResource().ToEntity());
            context.ApiScopes.Add(CreateApiScopeTestResource().ToEntity());
            context.SaveChanges();
        }

        IEnumerable resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = await store.FindApiResourcesByScopeNameAsync(new[] { testApiScope.Name });
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        Assert.NotNull(resources.Single(x => x.Name == testApiResource.Name));
    }




    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindIdentityResourcesByScopeNameAsync_WhenResourceExists_ExpectResourceAndCollectionsReturned(DbContextOptions options)
    {
        var resource = CreateIdentityTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.IdentityResources.Add(resource.ToEntity());
            context.SaveChanges();
        }

        IList resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = (await store.FindIdentityResourcesByScopeNameAsync(new List
            {
                resource.Name
            })).ToList();
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        var foundScope = resources.Single();

        Assert.Equal(resource.Name, foundScope.Name);
        Assert.NotNull(foundScope.UserClaims);
        Assert.NotEmpty(foundScope.UserClaims);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindIdentityResourcesByScopeNameAsync_WhenResourcesExist_ExpectOnlyRequestedReturned(DbContextOptions options)
    {
        var resource = CreateIdentityTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.IdentityResources.Add(resource.ToEntity());
            context.IdentityResources.Add(CreateIdentityTestResource().ToEntity());
            context.SaveChanges();
        }

        IList resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = (await store.FindIdentityResourcesByScopeNameAsync(new List
            {
                resource.Name
            })).ToList();
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        Assert.NotNull(resources.Single(x => x.Name == resource.Name));
    }



    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiScopesByNameAsync_WhenResourceExists_ExpectResourceAndCollectionsReturned(DbContextOptions options)
    {
        var resource = CreateApiScopeTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.ApiScopes.Add(resource.ToEntity());
            context.SaveChanges();
        }

        IList resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = (await store.FindApiScopesByNameAsync(new List
            {
                resource.Name
            })).ToList();
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        var foundScope = resources.Single();

        Assert.Equal(resource.Name, foundScope.Name);
        Assert.NotNull(foundScope.UserClaims);
        Assert.NotEmpty(foundScope.UserClaims);
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task FindApiScopesByNameAsync_WhenResourcesExist_ExpectOnlyRequestedReturned(DbContextOptions options)
    {
        var resource = CreateApiScopeTestResource();

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.ApiScopes.Add(resource.ToEntity());
            context.ApiScopes.Add(CreateApiScopeTestResource().ToEntity());
            context.SaveChanges();
        }

        IList resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = (await store.FindApiScopesByNameAsync(new List
            {
                resource.Name
            })).ToList();
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources);
        Assert.NotNull(resources.Single(x => x.Name == resource.Name));
    }




    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task GetAllResources_WhenAllResourcesRequested_ExpectAllResourcesIncludingHidden(DbContextOptions options)
    {
        var visibleIdentityResource = CreateIdentityTestResource();
        var visibleApiResource = CreateApiResourceTestResource();
        var visibleApiScope = CreateApiScopeTestResource();
        var hiddenIdentityResource = new IdentityResource { Name = Guid.NewGuid().ToString(), ShowInDiscoveryDocument = false };
        var hiddenApiResource = new ApiResource
        {
            Name = Guid.NewGuid().ToString(),
            Scopes = { Guid.NewGuid().ToString() },
            ShowInDiscoveryDocument = false
        };
        var hiddenApiScope = new ApiScope
        {
            Name = Guid.NewGuid().ToString(),
            ShowInDiscoveryDocument = false
        };

        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            context.IdentityResources.Add(visibleIdentityResource.ToEntity());
            context.ApiResources.Add(visibleApiResource.ToEntity());
            context.ApiScopes.Add(visibleApiScope.ToEntity());

            context.IdentityResources.Add(hiddenIdentityResource.ToEntity());
            context.ApiResources.Add(hiddenApiResource.ToEntity());
            context.ApiScopes.Add(hiddenApiScope.ToEntity());
            
            context.SaveChanges();
        }

        Resources resources;
        using (var context = new ConfigurationDbContext(options, StoreOptions))
        {
            var store = new ResourceStore(context, FakeLogger.Create());
            resources = await store.GetAllResourcesAsync();
        }

        Assert.NotNull(resources);
        Assert.NotEmpty(resources.IdentityResources);
        Assert.NotEmpty(resources.ApiResources);
        Assert.NotEmpty(resources.ApiScopes);

        Assert.Contains(resources.IdentityResources, x => x.Name == visibleIdentityResource.Name);
        Assert.Contains(resources.IdentityResources, x => x.Name == hiddenIdentityResource.Name);

        Assert.Contains(resources.ApiResources, x => x.Name == visibleApiResource.Name);
        Assert.Contains(resources.ApiResources, x => x.Name == hiddenApiResource.Name);

        Assert.Contains(resources.ApiScopes, x => x.Name == visibleApiScope.Name);
        Assert.Contains(resources.ApiScopes, x => x.Name == hiddenApiScope.Name);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/IntegrationTests/TokenCleanup/TokenCleanupTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.EntityFramework.DbContexts;
using IdentityServer8.EntityFramework.Entities;
using IdentityServer8.EntityFramework.Interfaces;
using IdentityServer8.EntityFramework.Options;
using IdentityServer8.EntityFramework.Stores;
using IdentityServer8.Stores;
using IdentityServer8.Test;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer8.EntityFramework.IntegrationTests.TokenCleanup;

public class TokenCleanupTests : IntegrationTest
{


    public TokenCleanupTests(DatabaseProviderFixture fixture) : base(fixture)
    {
        foreach (var options in TestDatabaseProviders.SelectMany(x => x.Select(y => (DbContextOptions)y)).ToList())
        {
            using (var context = new PersistedGrantDbContext(options, StoreOptions))
            {
                context.Database.EnsureCreated();
            }
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveExpiredGrantsAsync_WhenExpiredGrantsExist_ExpectExpiredGrantsRemoved(DbContextOptions options)
    {
        var expiredGrant = new PersistedGrant
        {
            Key = Guid.NewGuid().ToString(),
            ClientId = "app1",
            Type = "reference",
            SubjectId = "123",
            Expiration = DateTime.UtcNow.AddDays(-3),
            Data = "{!}"
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(expiredGrant);
            context.SaveChanges();
        }

        await CreateSut(options).RemoveExpiredGrantsAsync();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.FirstOrDefault(x => x.Key == expiredGrant.Key).Should().BeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveExpiredGrantsAsync_WhenValidGrantsExist_ExpectValidGrantsInDb(DbContextOptions options)
    {
        var validGrant = new PersistedGrant
        {
            Key = Guid.NewGuid().ToString(),
            ClientId = "app1",
            Type = "reference",
            SubjectId = "123",
            Expiration = DateTime.UtcNow.AddDays(3),
            Data = "{!}"
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.Add(validGrant);
            context.SaveChanges();
        }

        await CreateSut(options).RemoveExpiredGrantsAsync();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.PersistedGrants.FirstOrDefault(x => x.Key == validGrant.Key).Should().NotBeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveExpiredGrantsAsync_WhenExpiredDeviceGrantsExist_ExpectExpiredDeviceGrantsRemoved(DbContextOptions options)
    {
        var expiredGrant = new DeviceFlowCodes
        {
            DeviceCode = Guid.NewGuid().ToString(),
            UserCode = Guid.NewGuid().ToString(),
            ClientId = "app1",
            SubjectId = "123",
            CreationTime = DateTime.UtcNow.AddDays(-4),
            Expiration = DateTime.UtcNow.AddDays(-3),
            Data = "{!}"
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(expiredGrant);
            context.SaveChanges();
        }

        await CreateSut(options).RemoveExpiredGrantsAsync();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.FirstOrDefault(x => x.DeviceCode == expiredGrant.DeviceCode).Should().BeNull();
        }
    }

    [Theory, MemberData(nameof(TestDatabaseProviders))]
    public async Task RemoveExpiredGrantsAsync_WhenValidDeviceGrantsExist_ExpectValidDeviceGrantsInDb(DbContextOptions options)
    {
        var validGrant = new DeviceFlowCodes
        {
            DeviceCode = Guid.NewGuid().ToString(),
            UserCode = "2468",
            ClientId = "app1",
            SubjectId = "123",
            CreationTime = DateTime.UtcNow.AddDays(-4),
            Expiration = DateTime.UtcNow.AddDays(3),
            Data = "{!}"
        };

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.Add(validGrant);
            context.SaveChanges();
        }

        await CreateSut(options).RemoveExpiredGrantsAsync();

        using (var context = new PersistedGrantDbContext(options, StoreOptions))
        {
            context.DeviceFlowCodes.FirstOrDefault(x => x.DeviceCode == validGrant.DeviceCode).Should().NotBeNull();
        }
    }

    private EntityFramework.TokenCleanupService CreateSut(DbContextOptions options)
    {
        IServiceCollection services = new ServiceCollection();
        services.AddIdentityServer()
            .AddTestUsers(new List())
            .AddInMemoryClients(new List())
            .AddInMemoryIdentityResources(new List())
            .AddInMemoryApiResources(new List());

        services.AddScoped(_ =>
            new PersistedGrantDbContext(options, StoreOptions));
        services.AddTransient();
        services.AddTransient();
        
        services.AddTransient();
        services.AddSingleton(StoreOptions);

        return services.BuildServiceProvider().GetRequiredService();
        //return new EntityFramework.TokenCleanupService(
        //    services.BuildServiceProvider(),
        //    new NullLogger(),
        //    StoreOptions);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/UnitTests/IdentityServer8.EntityFramework.UnitTests.csproj
================================================


  
    ../../../../key.snk
    true
    true
  

  
    
  

  
    
    
    
    
    
      runtime; build; native; contentfiles; analyzers; buildtransitive
      all
    
    
  




================================================
FILE: src/EntityFramework.Storage/test/UnitTests/Mappers/ApiResourceMappersTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using FluentAssertions;
using IdentityServer8.EntityFramework.Mappers;
using Xunit;
using ApiResource = IdentityServer8.Models.ApiResource;

namespace IdentityServer8.EntityFramework.UnitTests.Mappers;

public class ApiResourceMappersTests
{
    [Fact]
    public void AutomapperConfigurationIsValid()
    {
        ApiResourceMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }

    [Fact]
    public void Can_Map()
    {
        var model = new ApiResource();
        var mappedEntity = model.ToEntity();
        var mappedModel = mappedEntity.ToModel();

        Assert.NotNull(mappedModel);
        Assert.NotNull(mappedEntity);
    }

    [Fact]
    public void Properties_Map()
    {
        var model = new ApiResource()
        {
           Description = "description",
           DisplayName = "displayname",
           Name = "foo",
           Scopes = { "foo1", "foo2" },
           Enabled = false
        };


        var mappedEntity = model.ToEntity();

        mappedEntity.Scopes.Count.Should().Be(2);
        var foo1 = mappedEntity.Scopes.FirstOrDefault(x => x.Scope == "foo1");
        foo1.Should().NotBeNull();
        var foo2 = mappedEntity.Scopes.FirstOrDefault(x => x.Scope == "foo2");
        foo2.Should().NotBeNull();
        

        var mappedModel = mappedEntity.ToModel();
        
        mappedModel.Description.Should().Be("description");
        mappedModel.DisplayName.Should().Be("displayname");
        mappedModel.Enabled.Should().BeFalse();
        mappedModel.Name.Should().Be("foo");
    }

    [Fact]
    public void missing_values_should_use_defaults()
    {
        var entity = new IdentityServer8.EntityFramework.Entities.ApiResource
        {
            Secrets = new System.Collections.Generic.List
            {
                new Entities.ApiResourceSecret
                {
                }
            }
        };

        var def = new ApiResource
        {
            ApiSecrets = { new Models.Secret("foo") }
        };

        var model = entity.ToModel();
        model.ApiSecrets.First().Type.Should().Be(def.ApiSecrets.First().Type);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/UnitTests/Mappers/ClientMappersTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using FluentAssertions;
using IdentityServer8.EntityFramework.Mappers;
using Xunit;
using Client = IdentityServer8.Models.Client;

namespace IdentityServer8.EntityFramework.UnitTests.Mappers;

public class ClientMappersTests
{
    [Fact]
    public void AutomapperConfigurationIsValid()
    {
        ClientMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }

    [Fact]
    public void Can_Map()
    {
        var model = new Client();
        var mappedEntity = model.ToEntity();
        var mappedModel = mappedEntity.ToModel();

        Assert.NotNull(mappedModel);
        Assert.NotNull(mappedEntity);
    }

    [Fact]
    public void Properties_Map()
    {
        var model = new Client()
        {
            Properties =
            {
                {"foo1", "bar1"},
                {"foo2", "bar2"},
            }
        };


        var mappedEntity = model.ToEntity();

        mappedEntity.Properties.Count.Should().Be(2);
        var foo1 = mappedEntity.Properties.FirstOrDefault(x => x.Key == "foo1");
        foo1.Should().NotBeNull();
        foo1.Value.Should().Be("bar1");
        var foo2 = mappedEntity.Properties.FirstOrDefault(x => x.Key == "foo2");
        foo2.Should().NotBeNull();
        foo2.Value.Should().Be("bar2");



        var mappedModel = mappedEntity.ToModel();

        mappedModel.Properties.Count.Should().Be(2);
        mappedModel.Properties.ContainsKey("foo1").Should().BeTrue();
        mappedModel.Properties.ContainsKey("foo2").Should().BeTrue();
        mappedModel.Properties["foo1"].Should().Be("bar1");
        mappedModel.Properties["foo2"].Should().Be("bar2");
    }

    [Fact]
    public void duplicates_properties_in_db_map()
    {
        var entity = new IdentityServer8.EntityFramework.Entities.Client
        {
            Properties = new System.Collections.Generic.List()
            {
                new Entities.ClientProperty{Key = "foo1", Value = "bar1"},
                new Entities.ClientProperty{Key = "foo1", Value = "bar2"},
            }
        };

        Action modelAction = () => entity.ToModel();
        modelAction.Should().Throw();
    }

    [Fact]
    public void missing_values_should_use_defaults()
    {
        var entity = new IdentityServer8.EntityFramework.Entities.Client
        {
            ClientSecrets = new System.Collections.Generic.List
            {
                new Entities.ClientSecret
                {
                }
            }
        };

        var def = new Client
        {
            ClientSecrets = { new Models.Secret("foo") }
        };

        var model = entity.ToModel();
        model.ProtocolType.Should().Be(def.ProtocolType);
        model.ClientSecrets.First().Type.Should().Be(def.ClientSecrets.First().Type);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/UnitTests/Mappers/IdentityResourcesMappersTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer8.EntityFramework.UnitTests.Mappers;

public class IdentityResourcesMappersTests
{
    [Fact]
    public void IdentityResourceAutomapperConfigurationIsValid()
    {
        IdentityResourceMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }

    [Fact]
    public void CanMapIdentityResources()
    {
        var model = new IdentityResource();
        var mappedEntity = model.ToEntity();
        var mappedModel = mappedEntity.ToModel();

        Assert.NotNull(mappedModel);
        Assert.NotNull(mappedEntity);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/UnitTests/Mappers/PersistedGrantMappersTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer8.EntityFramework.UnitTests.Mappers;

public class PersistedGrantMappersTests
{
    [Fact]
    public void PersistedGrantAutomapperConfigurationIsValid()
    {
        PersistedGrantMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }

    [Fact]
    public void CanMap()
    {
        var model = new PersistedGrant()
        {
            ConsumedTime = new System.DateTime(2020, 02, 03, 4, 5, 6)
        };
        
        var mappedEntity = model.ToEntity();
        mappedEntity.ConsumedTime.Value.Should().Be(new System.DateTime(2020, 02, 03, 4, 5, 6));
        
        var mappedModel = mappedEntity.ToModel();
        mappedModel.ConsumedTime.Value.Should().Be(new System.DateTime(2020, 02, 03, 4, 5, 6));

        Assert.NotNull(mappedModel);
        Assert.NotNull(mappedEntity);
    }
}


================================================
FILE: src/EntityFramework.Storage/test/UnitTests/Mappers/ScopeMappersTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using FluentAssertions;
using IdentityServer8.EntityFramework.Mappers;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer8.EntityFramework.UnitTests.Mappers;

public class ScopesMappersTests
{
    [Fact]
    public void ScopeAutomapperConfigurationIsValid()
    {
        ScopeMappers.Mapper.ConfigurationProvider.AssertConfigurationIsValid();
    }

    [Fact]
    public void CanMapScope()
    {
        var model = new ApiScope();
        var mappedEntity = model.ToEntity();
        var mappedModel = mappedEntity.ToModel();

        Assert.NotNull(mappedModel);
        Assert.NotNull(mappedEntity);
    }

    [Fact]
    public void Properties_Map()
    {
        var model = new ApiScope()
        {
            Description = "description",
            DisplayName = "displayname",
            Name = "foo",
            UserClaims = { "c1", "c2" },
            Properties = {
                { "x", "xx" },
                { "y", "yy" },
           },
            Enabled = false
        };


        var mappedEntity = model.ToEntity();
        mappedEntity.Description.Should().Be("description");
        mappedEntity.DisplayName.Should().Be("displayname");
        mappedEntity.Name.Should().Be("foo");

        mappedEntity.UserClaims.Count.Should().Be(2);
        mappedEntity.UserClaims.Select(x => x.Type).Should().BeEquivalentTo(new[] { "c1", "c2" });
        mappedEntity.Properties.Count.Should().Be(2);
        mappedEntity.Properties.Should().Contain(x => x.Key == "x" && x.Value == "xx");
        mappedEntity.Properties.Should().Contain(x => x.Key == "y" && x.Value == "yy");


        var mappedModel = mappedEntity.ToModel();

        mappedModel.Description.Should().Be("description");
        mappedModel.DisplayName.Should().Be("displayname");
        mappedModel.Enabled.Should().BeFalse();
        mappedModel.Name.Should().Be("foo");
        mappedModel.UserClaims.Count.Should().Be(2);
        mappedModel.UserClaims.Should().BeEquivalentTo(new[] { "c1", "c2" });
        mappedModel.Properties.Count.Should().Be(2);
        mappedModel.Properties["x"].Should().Be("xx");
        mappedModel.Properties["y"].Should().Be("yy");
    }
}


================================================
FILE: src/IdentityServer8/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/IdentityServer8/IdentityServer8.sln
================================================
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{5461C61B-B06E-46BA-B206-925B660BE727}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{45C22EDD-91B1-4AEF-8620-77F4E3E7C544}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8", "src\IdentityServer8.csproj", "{407C030E-60E6-41F7-AF43-0AC48EDCC17D}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "host\Host.csproj", "{784B3C88-30FA-415D-B99E-584063064508}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer.UnitTests", "test\IdentityServer.UnitTests\IdentityServer.UnitTests.csproj", "{4291820C-735F-4776-8BC4-6527433BC683}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer.IntegrationTests", "test\IdentityServer.IntegrationTests\IdentityServer.IntegrationTests.csproj", "{94501373-478A-478D-8C17-6AC52E3438CF}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Files", "Solution Files", "{9CB027A4-3509-4E54-B9D7-AC8F2F648AA2}"
	ProjectSection(SolutionItems) = preProject
		..\..\.editorconfig = ..\..\.editorconfig
		..\..\.gitattributes = ..\..\.gitattributes
		..\..\.gitignore = ..\..\.gitignore
		..\..\Directory.Build.props = ..\..\Directory.Build.props
		..\..\Directory.Build.targets = ..\..\Directory.Build.targets
		..\..\Directory.Packages.props = ..\..\Directory.Packages.props
		..\..\global.json = ..\..\global.json
		..\..\IdentityServer8.DotNet.ruleset = ..\..\IdentityServer8.DotNet.ruleset
		..\..\LICENSE = ..\..\LICENSE
		..\..\NuGet.config = ..\..\NuGet.config
		..\..\README.md = ..\..\README.md
		..\..\SECURITY.MD = ..\..\SECURITY.MD
		..\..\SPONSORS.md = ..\..\SPONSORS.md
	EndProjectSection
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Release|Any CPU.Build.0 = Release|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Release|Any CPU.Build.0 = Release|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Release|Any CPU.Build.0 = Release|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{784B3C88-30FA-415D-B99E-584063064508} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{4291820C-735F-4776-8BC4-6527433BC683} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{94501373-478A-478D-8C17-6AC52E3438CF} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {176723F7-4A9B-4F05-A9F3-3BA715E4BDC3}
	EndGlobalSection
EndGlobal


================================================
FILE: src/IdentityServer8/build.cmd
================================================
@echo off
dotnet run --project build -- %*

================================================
FILE: src/IdentityServer8/build.ps1
================================================
$ErrorActionPreference = "Stop";
dotnet run --project build -- $args

================================================
FILE: src/IdentityServer8/build.sh
================================================
#!/usr/bin/env bash
set -euo pipefail
dotnet run --project build -- "$@"

================================================
FILE: src/IdentityServer8/host/Configuration/Clients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class Clients
{
    public static IEnumerable Get()
    {
        var clients = new List();

        clients.AddRange(ClientsConsole.Get());
        clients.AddRange(ClientsWeb.Get());

        return clients;
    }
}


================================================
FILE: src/IdentityServer8/host/Configuration/ClientsConsole.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class ClientsConsole
{
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////
            // Console Client Credentials Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client",
                ClientSecrets = { new Secret("secret".Sha256()) },
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes =
                {
                    "resource1.scope1", "resource2.scope1", IdentityServerConstants.LocalApi.ScopeName
                }
            },

            ///////////////////////////////////////////
            // Console Structured Scope Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "parameterized.client",
                ClientSecrets = { new Secret("secret".Sha256()) },
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "transaction" }
            },

            ///////////////////////////////////////////
            // X509 mTLS Client
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mtls",
                ClientSecrets =
                {
                    // new Secret(@"CN=mtls.test, OU=ROO\ballen@roo, O=mkcert development certificate", "mtls.test")
                    // {
                    //     Type = SecretTypes.X509CertificateName
                    // },
                    new Secret("5D9E9B6B333CD42C99D1DE6175CC0F3EF99DDF68", "mtls.test")
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateThumbprint
                    },
                },
                AccessTokenType = AccessTokenType.Jwt,
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Client Credentials Flow with client JWT assertion
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.jwt",
                ClientSecrets =
                {
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value =
                            "MIIEgTCCAumgAwIBAgIQDMMu7l/umJhfEbzJMpcttzANBgkqhkiG9w0BAQsFADCBkzEeMBwGA1UEChMVbWtjZXJ0IGRldmVsb3BtZW50IENBMTQwMgYDVQQLDCtkb21pbmlja0Bkb21icDE2LmZyaXR6LmJveCAoRG9taW5pY2sgQmFpZXIpMTswOQYDVQQDDDJta2NlcnQgZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTAeFw0xOTA2MDEwMDAwMDBaFw0zMDAxMDMxMjM0MDdaMHAxJzAlBgNVBAoTHm1rY2VydCBkZXZlbG9wbWVudCBjZXJ0aWZpY2F0ZTE0MDIGA1UECwwrZG9taW5pY2tAZG9tYnAxNi5mcml0ei5ib3ggKERvbWluaWNrIEJhaWVyKTEPMA0GA1UEAxMGY2xpZW50MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvNtpipaS8k1zA6w0Aoy8U4l+8zM4jHhhblExf3PULrMR6RauxniTki8p+P8CsZT4V8A4qo+JwsgpLIHrVQrbt9DEhHfBKzxwHqt+GoHt7byTfTtp8A/5nLhYc/5CW4HiR194gVx5+HAlvt+BriMTb1czvTf+H20dj41yUPsN7nMdyRLF+uXapQYMLYnq2BJIDq83mqGwojHk7d+N6GwoO95jlyas7KSoj8/FvfbaqkRNx0446hqPOzFHKc8er8K5VrLp6tVjh8ZJyY0F0dKgx6yWITsL54ctbj/cCyfuGjWEMbS2XXgc+x/xQMnmpfhK1qQAUn9jg5EzF9n6mQomOwIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwIGCCsGAQUFBwMBMAwGA1UdEwEB/wQCMAAwHwYDVR0jBBgwFoAUEMUlw41YsKZQVls3pEG6CrJk4O8wEQYDVR0RBAowCIIGY2xpZW50MA0GCSqGSIb3DQEBCwUAA4IBgQC0TjNY4Q3Wmw7ggamDImV6HUng3WbYGLYbbL2e3myBrjIxGd1Bi8ZyOu8qeUMIRAbZt2YsSX5S8kx0biaVg2zC+aO5eHhEWMwKB66huInXFjI4wtxZ22r+33fg1R0cLuEUePhftOWrbL0MS4YXVyn9HUMWO4WptG9PJdxNw1UbEB8nw3FkVOdAC9RGqiqalSK+E2UT/kUbTIQ1gPSdQ3nh52mre0H/T9+IRqiozJtNK/CQg4NuEV7rUXHnp7Fmigp6RIJ4TCozglspL341y0rV8M7npU1FYZC2UKNr4ed+GOO1n/sF3LbXDlPXwne99CVVn85wjDaevoR7Md0y2KwE9EggLYcViXNehx4YVv/BjfgqxW8NxiKAxP6kPOZE0XdBrZj2rmcDcGOXCzzYpcduKhFyTOpA0K5RNGC3j1KOUjPVlOtLvjASP7udBEYNfH3mgqXAgqNDOEKi2jG9LITv2IyGUsXhTAsKNJ6A6qiDBzDrvPAYDvsfabPq6tRTwjA="
                    },
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value =
                            "{'e':'AQAB','kid':'ZzAjSnraU3bkWGnnAqLapYGpTyNfLbjbzgAPbbW2GEA','kty':'RSA','n':'wWwQFtSzeRjjerpEM5Rmqz_DsNaZ9S1Bw6UbZkDLowuuTCjBWUax0vBMMxdy6XjEEK4Oq9lKMvx9JzjmeJf1knoqSNrox3Ka0rnxXpNAz6sATvme8p9mTXyp0cX4lF4U2J54xa2_S9NF5QWvpXvBeC4GAJx7QaSw4zrUkrc6XyaAiFnLhQEwKJCwUw4NOqIuYvYp_IXhw-5Ti_icDlZS-282PcccnBeOcX7vc21pozibIdmZJKqXNsL1Ibx5Nkx1F1jLnekJAmdaACDjYRLL_6n3W4wUp19UvzB1lGtXcJKLLkqB6YDiZNu16OSiSprfmrRXvYmvD8m6Fnl5aetgKw'}"
                    }
                },
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Custom Grant Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client.custom",
                ClientSecrets = { new Secret("secret".Sha256()) },
                AllowedGrantTypes = { "custom", "custom.nosubject" },
                AllowedScopes = { "resource1.scope1", "resource2.scope1" }
            },

            ///////////////////////////////////////////
            // Console Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient",
                ClientSecrets = { new Secret("secret".Sha256()) },
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    "custom.profile",
                    "resource1.scope1",
                    "resource2.scope1"
                },
                
                RefreshTokenUsage = TokenUsage.OneTimeOnly,
                AbsoluteRefreshTokenLifetime = 3600 * 24,
                SlidingRefreshTokenLifetime = 10,
                RefreshTokenExpiration = TokenExpiration.Sliding
            },

            ///////////////////////////////////////////
            // Console Public Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.public",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1",
                    "resource2.scope1"
                }
            },

            ///////////////////////////////////////////
            // Console with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "console.pkce",
                ClientName = "Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = { "http://127.0.0.1" },
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1",
                    "resource2.scope1"
                }
            },
            ///////////////////////////////////////////
            // WinConsole with PKCE Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "winconsole",
                ClientName = "Windows Console with PKCE Sample",
                RequireClientSecret = false,
                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,
                RedirectUris = { "sample-windows-client://callback" },
                RequireConsent = false,
                AllowOfflineAccess = true,
                AllowedIdentityTokenSigningAlgorithms = { "ES256" },
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1",
                    "resource2.scope1"
                }
            },


            ///////////////////////////////////////////
            // Introspection Client Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.reference",
                ClientSecrets = { new Secret("secret".Sha256()) },
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowedScopes = { "resource1.scope1", "resource2.scope1", "scope3" },
                AccessTokenType = AccessTokenType.Reference
            },

            ///////////////////////////////////////////
            // Device Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "device",
                ClientName = "Device Flow Client",
                AllowedGrantTypes = GrantTypes.DeviceFlow,
                RequireClientSecret = false,
                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Profile,
                    IdentityServerConstants.StandardScopes.Email,
                    "resource1.scope1",
                    "resource2.scope1"
                }
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/host/Configuration/ClientsWeb.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public static class ClientsWeb
{
    static string[] allowedScopes = 
    {
        IdentityServerConstants.StandardScopes.OpenId,
        IdentityServerConstants.StandardScopes.Profile,
        IdentityServerConstants.StandardScopes.Email,
        "resource1.scope1", 
        "resource2.scope1",
        "transaction"
    };
    
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////
            // JS OIDC Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "js_oidc",
                ClientName = "JavaScript OIDC Client",
                ClientUri = "http://identityserver8.io",
                
                AllowedGrantTypes = GrantTypes.Code,
                RequireClientSecret = false,
                
                RedirectUris = 
                {
                    "https://localhost:44300/index.html",
                    "https://localhost:44300/callback.html",
                    "https://localhost:44300/silent.html",
                    "https://localhost:44300/popup.html"
                },

                PostLogoutRedirectUris = { "https://localhost:44300/index.html" },
                AllowedCorsOrigins = { "https://localhost:44300" },

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Automatic Token Management Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.tokenmanagement",
                
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Code,
                RequirePkce = true,

                AccessTokenLifetime = 75,

                RedirectUris = { "https://localhost:44301/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44301/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44301/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Code Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.code",
                ClientName = "MVC Code Flow",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                RequireConsent = true,
                AllowedGrantTypes = GrantTypes.Code,

                RedirectUris = { "https://localhost:44302/signin-oidc" },
                FrontChannelLogoutUri = "https://localhost:44302/signout-oidc",
                PostLogoutRedirectUris = { "https://localhost:44302/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            },
            
            ///////////////////////////////////////////
            // MVC Hybrid Flow Sample (Back Channel logout)
            //////////////////////////////////////////
            new Client
            {
                ClientId = "mvc.hybrid.backchannel",
                ClientName = "MVC Hybrid (with BackChannel logout)",
                ClientUri = "http://identityserver8.io",

                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Hybrid,
                RequirePkce = false,

                RedirectUris = { "https://localhost:44303/signin-oidc" },
                BackChannelLogoutUri = "https://localhost:44303/logout",
                PostLogoutRedirectUris = { "https://localhost:44303/signout-callback-oidc" },

                AllowOfflineAccess = true,

                AllowedScopes = allowedScopes
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/host/Configuration/Resources.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Configuration;

public class Resources
{
    // identity resources represent identity data about a user that can be requested via the scope parameter (OpenID Connect)
    public static readonly IEnumerable IdentityResources =
        new[]
        {
            // some standard scopes from the OIDC spec
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email(),

            // custom identity resource with some consolidated claims
            new IdentityResource("custom.profile", new[] { JwtClaimTypes.Name, JwtClaimTypes.Email, "location", JwtClaimTypes.Address })
        };

    // API scopes represent values that describe scope of access and can be requested by the scope parameter (OAuth)
    public static readonly IEnumerable ApiScopes =
        new[]
        {
            // local API scope
            new ApiScope(LocalApi.ScopeName),

            // resource specific scopes
            new ApiScope("resource1.scope1"),
            new ApiScope("resource2.scope1"), 
            
            // a scope without resource association
            new ApiScope("scope3"),
            
            // a scope shared by multiple resources
            new ApiScope("shared.scope"),

            // a parameterized scope
            new ApiScope("transaction", "Transaction")
            {
                Description = "Some Transaction"
            }
        };

    // API resources are more formal representation of a resource with processing rules and their scopes (if any)
    public static readonly IEnumerable ApiResources = 
        new[]
        {
            new ApiResource("resource1", "Resource 1")
            {
                ApiSecrets = { new Secret("secret".Sha256()) },

                Scopes = { "resource1.scope1", "shared.scope" }
            },
            
            new ApiResource("resource2", "Resource 2")
            {
                ApiSecrets =
                {
                    new Secret("secret".Sha256())
                },

                // additional claims to put into access token
                UserClaims =
                {
                    JwtClaimTypes.Name,
                    JwtClaimTypes.Email
                },

                Scopes = { "resource2.scope1", "shared.scope" }
            }
        };
}


================================================
FILE: src/IdentityServer8/host/Extensions/ExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

public class ExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var credential = context.Request.Raw.Get("custom_credential");

        if (credential != null)
        {
            context.Result = new GrantValidationResult(subject: "818727", authenticationMethod: "custom");
        }
        else
        {
            // custom error message
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid custom credential");
        }

        return Task.CompletedTask;
    }

    public string GrantType
    {
        get { return "custom"; }
    }
}


================================================
FILE: src/IdentityServer8/host/Extensions/HostProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

public class HostProfileService : TestUserProfileService
{
    public HostProfileService(TestUserStore users, ILogger logger) : base(users, logger)
    {
    }

    public override async Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        await base.GetProfileDataAsync(context);

        var transaction = context.RequestedResources.ParsedScopes.FirstOrDefault(x => x.ParsedName == "transaction");
        if (transaction?.ParsedParameter != null)
        {
            context.IssuedClaims.Add(new Claim("transaction_id", transaction.ParsedParameter));
        }
    }
}


================================================
FILE: src/IdentityServer8/host/Extensions/NoSubjectExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

public class NoSubjectExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var credential = context.Request.Raw.Get("custom_credential");

        if (credential != null)
        {
            context.Result = new GrantValidationResult();
        }
        else
        {
            // custom error message
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid custom credential");
        }

        return Task.CompletedTask;
    }

    public string GrantType
    {
        get { return "custom.nosubject"; }
    }
}


================================================
FILE: src/IdentityServer8/host/Extensions/ParameterizedScopeParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

public class ParameterizedScopeParser : DefaultScopeParser
{
    public ParameterizedScopeParser(ILogger logger) : base(logger)
    {
    }

    public override void ParseScopeValue(ParseScopeContext scopeContext)
    {
        const string transactionScopeName = "transaction";
        const string separator = ":";
        const string transactionScopePrefix = transactionScopeName + separator;

        var scopeValue = scopeContext.RawValue;

        if (scopeValue.StartsWith(transactionScopePrefix))
        {
            // we get in here with a scope like "transaction:something"
            var parts = scopeValue.Split(separator, StringSplitOptions.RemoveEmptyEntries);
            if (parts.Length == 2)
            {
                scopeContext.SetParsedValues(transactionScopeName, parts[1]);
            }
            else
            {
                scopeContext.SetError("transaction scope missing transaction parameter value");
            }
        }
        else if (scopeValue != transactionScopeName)
        {
            // we get in here with a scope not like "transaction"
            base.ParseScopeValue(scopeContext);
        }
        else
        {
            // we get in here with a scope exactly "transaction", which is to say we're ignoring it 
            // and not including it in the results
            scopeContext.SetIgnore();
        }
    }
}


================================================
FILE: src/IdentityServer8/host/Extensions/ParameterizedScopeTokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

public class ParameterizedScopeTokenRequestValidator : ICustomTokenRequestValidator
{
    public Task ValidateAsync(CustomTokenRequestValidationContext context)
    {
        var transaction = context.Result.ValidatedRequest.ValidatedResources.ParsedScopes.FirstOrDefault(x => x.ParsedName == "transaction");
        if (transaction?.ParsedParameter != null)
        {
            context.Result.ValidatedRequest.ClientClaims.Add(new Claim(transaction.ParsedName, transaction.ParsedParameter));
        }

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/host/Extensions/SameSiteHandlingExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Extensions;

// copied from https://devblogs.microsoft.com/aspnet/upcoming-samesite-cookie-changes-in-asp-net-and-asp-net-core/
public static class SameSiteHandlingExtensions
{
    public static IServiceCollection AddSameSiteCookiePolicy(this IServiceCollection services)
    {
        services.Configure(options =>
        {
            options.MinimumSameSitePolicy = SameSiteMode.Unspecified;
            options.OnAppendCookie = cookieContext => 
                CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
            options.OnDeleteCookie = cookieContext => 
                CheckSameSite(cookieContext.Context, cookieContext.CookieOptions);
        });

        return services;
    }
    
    private static void CheckSameSite(HttpContext httpContext, CookieOptions options)
    {
        if (options.SameSite == SameSiteMode.None)
        {
            var userAgent = httpContext.Request.Headers["User-Agent"].ToString();
            if (!httpContext.Request.IsHttps || DisallowsSameSiteNone(userAgent))
            {
                // For .NET Core < 3.1 set SameSite = (SameSiteMode)(-1)
                options.SameSite = SameSiteMode.Unspecified;
            }
        }
    }

    private static bool DisallowsSameSiteNone(string userAgent)
    {
        // Cover all iOS based browsers here. This includes:
        // - Safari on iOS 12 for iPhone, iPod Touch, iPad
        // - WkWebview on iOS 12 for iPhone, iPod Touch, iPad
        // - Chrome on iOS 12 for iPhone, iPod Touch, iPad
        // All of which are broken by SameSite=None, because they use the iOS networking stack
        if (userAgent.Contains("CPU iPhone OS 12") || userAgent.Contains("iPad; CPU OS 12"))
        {
            return true;
        }

        // Cover Mac OS X based browsers that use the Mac OS networking stack. This includes:
        // - Safari on Mac OS X.
        // This does not include:
        // - Chrome on Mac OS X
        // Because they do not use the Mac OS networking stack.
        if (userAgent.Contains("Macintosh; Intel Mac OS X 10_14") && 
            userAgent.Contains("Version/") && userAgent.Contains("Safari"))
        {
            return true;
        }

        // Cover Chrome 50-69, because some versions are broken by SameSite=None, 
        // and none in this range require it.
        // Note: this covers some pre-Chromium Edge versions, 
        // but pre-Chromium Edge does not require SameSite=None.
        if (userAgent.Contains("Chrome/5") || userAgent.Contains("Chrome/6"))
        {
            return true;
        }

        return false;
    }
}


================================================
FILE: src/IdentityServer8/host/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Services;
global using IdentityServer8.Stores;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using IdentityServerHost.Configuration;
global using IdentityServerHost.Extensions;
global using IdentityServerHost.Quickstart.UI;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authentication.Certificate;
global using Microsoft.AspNetCore.Authorization;
global using Microsoft.AspNetCore.HttpOverrides;
global using Microsoft.AspNetCore.Mvc;
global using Microsoft.AspNetCore.Mvc.Filters;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Options;
global using Microsoft.IdentityModel.Logging;
global using Microsoft.IdentityModel.Tokens;
global using Newtonsoft.Json;
global using Serilog;
global using Serilog.Events;
global using Serilog.Sinks.SystemConsole.Themes;
global using System.ComponentModel.DataAnnotations;
global using System.Diagnostics;
global using System.Security.Claims;
global using System.Security.Cryptography.X509Certificates;
global using System.Text;
global using static IdentityServer8.IdentityServerConstants;
global using ILogger = Microsoft.Extensions.Logging.ILogger;
global using ClaimValueTypes = System.Security.Claims.ClaimValueTypes;


================================================
FILE: src/IdentityServer8/host/Host.csproj
================================================




  
    
  

  
    
  

  
    
    
    

    
    
    
    
    
  


================================================
FILE: src/IdentityServer8/host/LocalApiController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost;

[Route("localApi")]
[Authorize(LocalApi.PolicyName)]
public class LocalApiController : ControllerBase
{
    public IActionResult Get()
    {
        var claims = from c in User.Claims select new { c.Type, c.Value };
        return new JsonResult(claims);
    }
}


================================================
FILE: src/IdentityServer8/host/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost;

public class Program
{
    public static int Main(string[] args)
    {
        Console.Title = "IdentityServer8";
        Activity.DefaultIdFormat = ActivityIdFormat.W3C;

        Log.Logger = new LoggerConfiguration()
            .MinimumLevel.Debug()
            .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.Hosting.Lifetime", LogEventLevel.Information)
            .MinimumLevel.Override("System", LogEventLevel.Warning)
            .MinimumLevel.Override("Microsoft.AspNetCore.Authentication", LogEventLevel.Information)
            .Enrich.FromLogContext()
            //.WriteTo.File(@"IdentityServer8_log.txt")
            // uncomment to write to Azure diagnostics stream
            //.WriteTo.File(
            //    @"D:\home\LogFiles\Application\identityserver.txt",
            //    fileSizeLimitBytes: 1_000_000,
            //    rollOnFileSizeLimit: true,
            //    shared: true,
            //    flushToDiskInterval: TimeSpan.FromSeconds(1))
            .WriteTo.Console(outputTemplate: "[{Timestamp:HH:mm:ss} {Level}] {SourceContext}{NewLine}{Message:lj}{NewLine}{Exception}{NewLine}", theme: AnsiConsoleTheme.Code)
            .CreateLogger();

        try
        {
            Log.Information("Starting host...");
            CreateHostBuilder(args).Build().Run();
            return 0;
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Host terminated unexpectedly.");
            return 1;
        }
        finally
        {
            Log.CloseAndFlush();
        }
    }

    public static IHostBuilder CreateHostBuilder(string[] args) =>
        Host.CreateDefaultBuilder(args)
            .UseSerilog()
            .ConfigureWebHostDefaults(webBuilder =>
            {
                webBuilder.UseStartup();
            });
}


================================================
FILE: src/IdentityServer8/host/Properties/launchSettings.json
================================================
{
  "profiles": {
    "Host": {
      "commandName": "Project",
      "launchBrowser": true,
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001;http://localhost:5000"
    },
    "Host (proxy)": {
      "commandName": "Project",
      "launchBrowser": true,
      "launchUrl": "https://identityserver.local",
      "environmentVariables": {
        "ASPNETCORE_ENVIRONMENT": "Development"
      },
      "applicationUrl": "https://localhost:5001;http://localhost:5000"
    }
  }
}

================================================
FILE: src/IdentityServer8/host/Quickstart/Account/AccountController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller implements a typical login/logout/provision workflow for local and external accounts.
/// The login service encapsulates the interactions with the user data store. This data store is in-memory only and cannot be used for production!
/// The interaction service provides a way for the UI to communicate with identityserver for validation and context retrieval
/// 
[SecurityHeaders]
[AllowAnonymous]
public class AccountController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly IAuthenticationSchemeProvider _schemeProvider;
    private readonly IEventService _events;

    public AccountController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IAuthenticationSchemeProvider schemeProvider,
        IEventService events,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _schemeProvider = schemeProvider;
        _events = events;
    }

    /// 
    /// Entry point into the login workflow
    /// 
    [HttpGet]
    public async Task Login(string returnUrl)
    {
        // build a model so we know what to show on the login page
        var vm = await BuildLoginViewModelAsync(returnUrl);

        if (vm.IsExternalLoginOnly)
        {
            // we only have one option for logging in and it's an external provider
            return returnUrl.IsAllowedRedirect() ? RedirectToAction("Challenge", "External", new { scheme = vm.ExternalLoginScheme, returnUrl = returnUrl.SanitizeForRedirect() }) : Forbid();
        }

        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Login(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (ModelState.IsValid)
        {
            // validate username/password against in-memory store
            if (_users.ValidateCredentials(model.Username, model.Password))
            {
                var user = _users.FindByUsername(model.Username);
                await _events.RaiseAsync(new UserLoginSuccessEvent(user.Username, user.SubjectId, user.Username, clientId: context?.Client.ClientId));

                // only set explicit expiration here if user chooses "remember me". 
                // otherwise we rely upon expiration configured in cookie middleware.
                AuthenticationProperties props = null;
                if (AccountOptions.AllowRememberLogin && model.RememberLogin)
                {
                    props = new AuthenticationProperties
                    {
                        IsPersistent = true,
                        ExpiresUtc = DateTimeOffset.UtcNow.Add(AccountOptions.RememberMeLoginDuration)
                    };
                };

                // issue authentication cookie with subject ID and username
                var isuser = new IdentityServerUser(user.SubjectId)
                {
                    DisplayName = user.Username
                };

                await HttpContext.SignInAsync(isuser, props);

                if (context != null)
                {
                    if (context.IsNativeClient())
                    {
                        // The client is native, so this change in how to
                        // return the response is for better UX for the end user.
                        return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                    }

                    // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }

                // request for a local page
                if (Url.IsLocalUrl(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
                }
                else if (string.IsNullOrEmpty(model.ReturnUrl))
                {
                    return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
                }
                else
                {
                    // user might have clicked on a malicious link - should be logged
                    throw new Exception("invalid return URL");
                }
            }

            await _events.RaiseAsync(new UserLoginFailureEvent(model.Username, "invalid credentials", clientId: context?.Client.ClientId));
            ModelState.AddModelError(string.Empty, AccountOptions.InvalidCredentialsErrorMessage);
        }

        // something went wrong, show form with error
        var vm = await BuildLoginViewModelAsync(model);
        return View(vm);
    }

    /// 
    /// Handle postback from username/password login
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task LoginCancel(LoginInputModel model)
    {
        // check if we are in the context of an authorization request
        var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);

        if (context != null)
        {
            // if the user cancels, send a result back into IdentityServer as if they 
            // denied the consent (even if this client does not require consent).
            // this will send back an access denied OIDC error response to the client.
            await _interaction.DenyAuthorizationAsync(context, AuthorizationError.AccessDenied);

            // we can trust model.ReturnUrl since GetAuthorizationContextAsync returned non-null
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return model.ReturnUrl.IsAllowedRedirect() ? this.LoadingPage("Redirect", model.ReturnUrl.SanitizeForRedirect()) : Forbid();
            }

            return model.ReturnUrl.IsAllowedRedirect() ? Redirect(model.ReturnUrl.SanitizeForRedirect()) : Forbid();
        }
        else
        {
            // since we don't have a valid context, then we just go back to the home page
            return model.ReturnUrl.IsAllowedRedirect() ? Redirect("~/") : Forbid();
        }

    }

    /// 
    /// Show logout page
    /// 
    [HttpGet]
    public async Task Logout(string logoutId)
    {
        // build a model so the logout page knows what to display
        var vm = await BuildLogoutViewModelAsync(logoutId);

        if (vm.ShowLogoutPrompt == false)
        {
            // if the request for logout was properly authenticated from IdentityServer, then
            // we don't need to show the prompt and can just log the user out directly.
            return await Logout(vm);
        }

        return View(vm);
    }

    /// 
    /// Handle logout page postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Logout(LogoutInputModel model)
    {
        // build a model so the logged out page knows what to display
        var vm = await BuildLoggedOutViewModelAsync(model.LogoutId);

        if (User?.Identity.IsAuthenticated == true)
        {
            // delete local authentication cookie
            await HttpContext.SignOutAsync();

            // raise the logout event
            await _events.RaiseAsync(new UserLogoutSuccessEvent(User.GetSubjectId(), User.GetDisplayName()));
        }

        // check if we need to trigger sign-out at an upstream identity provider
        if (vm.TriggerExternalSignout)
        {
            // build a return URL so the upstream provider will redirect back
            // to us after the user has logged out. this allows us to then
            // complete our single sign-out processing.
            string url = Url.Action("Logout", new { logoutId = vm.LogoutId });

            // this triggers a redirect to the external provider for sign-out
            return SignOut(new AuthenticationProperties { RedirectUri = url }, vm.ExternalAuthenticationScheme);
        }

        return View("LoggedOut", vm);
    }

    [HttpGet]
    public IActionResult AccessDenied()
    {
        return View();
    }


    /*****************************************/
    /* helper APIs for the AccountController */
    /*****************************************/
    private async Task BuildLoginViewModelAsync(string returnUrl)
    {
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (context?.IdP != null && await _schemeProvider.GetSchemeAsync(context.IdP) != null)
        {
            var local = context.IdP == IdentityServer8.IdentityServerConstants.LocalIdentityProvider;

            // this is meant to short circuit the UI and only trigger the one external IdP
            var vm = new LoginViewModel
            {
                EnableLocalLogin = local,
                ReturnUrl = returnUrl,
                Username = context?.LoginHint,
            };

            if (!local)
            {
                vm.ExternalProviders = new[] { new ExternalProvider { AuthenticationScheme = context.IdP } };
            }

            return vm;
        }

        var schemes = await _schemeProvider.GetAllSchemesAsync();

        var providers = schemes
            .Where(x => x.DisplayName != null)
            .Select(x => new ExternalProvider
            {
                DisplayName = x.DisplayName ?? x.Name,
                AuthenticationScheme = x.Name
            }).ToList();

        var allowLocal = true;
        if (context?.Client.ClientId != null)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(context.Client.ClientId);
            if (client != null)
            {
                allowLocal = client.EnableLocalLogin;

                if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
                {
                    providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
                }
            }
        }

        return new LoginViewModel
        {
            AllowRememberLogin = AccountOptions.AllowRememberLogin,
            EnableLocalLogin = allowLocal && AccountOptions.AllowLocalLogin,
            ReturnUrl = returnUrl,
            Username = context?.LoginHint,
            ExternalProviders = providers.ToArray()
        };
    }

    private async Task BuildLoginViewModelAsync(LoginInputModel model)
    {
        var vm = await BuildLoginViewModelAsync(model.ReturnUrl);
        vm.Username = model.Username;
        vm.RememberLogin = model.RememberLogin;
        return vm;
    }

    private async Task BuildLogoutViewModelAsync(string logoutId)
    {
        var vm = new LogoutViewModel { LogoutId = logoutId, ShowLogoutPrompt = AccountOptions.ShowLogoutPrompt };

        if (User?.Identity.IsAuthenticated != true)
        {
            // if the user is not authenticated, then just show logged out page
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        var context = await _interaction.GetLogoutContextAsync(logoutId);
        if (context?.ShowSignoutPrompt == false)
        {
            // it's safe to automatically sign-out
            vm.ShowLogoutPrompt = false;
            return vm;
        }

        // show the logout prompt. this prevents attacks where the user
        // is automatically signed out by another malicious web page.
        return vm;
    }

    private async Task BuildLoggedOutViewModelAsync(string logoutId)
    {
        // get context information (client name, post logout redirect URI and iframe for federated signout)
        var logout = await _interaction.GetLogoutContextAsync(logoutId);

        var vm = new LoggedOutViewModel
        {
            AutomaticRedirectAfterSignOut = AccountOptions.AutomaticRedirectAfterSignOut,
            PostLogoutRedirectUri = logout?.PostLogoutRedirectUri,
            ClientName = string.IsNullOrEmpty(logout?.ClientName) ? logout?.ClientId : logout?.ClientName,
            SignOutIframeUrl = logout?.SignOutIFrameUrl,
            LogoutId = logoutId
        };

        if (User?.Identity.IsAuthenticated == true)
        {
            var idp = User.FindFirst(JwtClaimTypes.IdentityProvider)?.Value;
            if (idp != null && idp != IdentityServer8.IdentityServerConstants.LocalIdentityProvider)
            {
                var providerSupportsSignout = await HttpContext.GetSchemeSupportsSignOutAsync(idp);
                if (providerSupportsSignout)
                {
                    if (vm.LogoutId == null)
                    {
                        // if there's no current logout context, we need to create one
                        // this captures necessary info from the current logged in user
                        // before we signout and redirect away to the external IdP for signout
                        vm.LogoutId = await _interaction.CreateLogoutContextAsync();
                    }

                    vm.ExternalAuthenticationScheme = idp;
                }
            }
        }

        return vm;
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/AccountOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class AccountOptions
{
    public static bool AllowLocalLogin = true;
    public static bool AllowRememberLogin = true;
    public static TimeSpan RememberMeLoginDuration = TimeSpan.FromDays(30);

    public static bool ShowLogoutPrompt = true;
    public static bool AutomaticRedirectAfterSignOut = false;

    public static string InvalidCredentialsErrorMessage = "Invalid username or password";
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/ExternalController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class ExternalController : Controller
{
    private readonly TestUserStore _users;
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clientStore;
    private readonly ILogger _logger;
    private readonly IEventService _events;

    public ExternalController(
        IIdentityServerInteractionService interaction,
        IClientStore clientStore,
        IEventService events,
        ILogger logger,
        TestUserStore users = null)
    {
        // if the TestUserStore is not in DI, then we'll just use the global users collection
        // this is where you would plug in your own custom identity management library (e.g. ASP.NET Identity)
        _users = users ?? new TestUserStore(TestUsers.Users);

        _interaction = interaction;
        _clientStore = clientStore;
        _logger = logger;
        _events = events;
    }

    /// 
    /// initiate roundtrip to external authentication provider
    /// 
    [HttpGet]
    public IActionResult Challenge(string scheme, string returnUrl)
    {
        if (string.IsNullOrEmpty(returnUrl)) returnUrl = "~/";

        // validate returnUrl - either it is a valid OIDC URL or back to a local page
        if (Url.IsLocalUrl(returnUrl) == false && _interaction.IsValidReturnUrl(returnUrl) == false)
        {
            // user might have clicked on a malicious link - should be logged
            throw new Exception("invalid return URL");
        }
        
        // start challenge and roundtrip the return URL and scheme 
        var props = new AuthenticationProperties
        {
            RedirectUri = Url.Action(nameof(Callback)), 
            Items =
            {
                { "returnUrl", returnUrl }, 
                { "scheme", scheme },
            }
        };

        return Challenge(props, scheme);
        
    }

    /// 
    /// Post processing of external authentication
    /// 
    [HttpGet]
    public async Task Callback()
    {
        // read external identity from the temporary cookie
        var result = await HttpContext.AuthenticateAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);
        if (result?.Succeeded != true)
        {
            throw new Exception("External authentication error");
        }

        if (_logger.IsEnabled(LogLevel.Debug))
        {
            var externalClaims = result.Principal.Claims.Select(c => $"{c.Type}: {c.Value}");
            _logger.LogDebug("External claims: {@claims}", externalClaims);
        }

        // lookup our user and external provider info
        var (user, provider, providerUserId, claims) = FindUserFromExternalProvider(result);
        if (user == null)
        {
            // this might be where you might initiate a custom workflow for user registration
            // in this sample we don't show how that would be done, as our sample implementation
            // simply auto-provisions new external user
            user = AutoProvisionUser(provider, providerUserId, claims);
        }

        // this allows us to collect any additional claims or properties
        // for the specific protocols used and store them in the local auth cookie.
        // this is typically used to store data needed for signout from those protocols.
        var additionalLocalClaims = new List();
        var localSignInProps = new AuthenticationProperties();
        ProcessLoginCallback(result, additionalLocalClaims, localSignInProps);
        
        // issue authentication cookie for user
        var isuser = new IdentityServerUser(user.SubjectId)
        {
            DisplayName = user.Username,
            IdentityProvider = provider,
            AdditionalClaims = additionalLocalClaims
        };

        await HttpContext.SignInAsync(isuser, localSignInProps);

        // delete temporary cookie used during external authentication
        await HttpContext.SignOutAsync(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        // retrieve return URL
        var returnUrl = result.Properties.Items["returnUrl"] ?? "~/";

        // check if external login is in the context of an OIDC request
        var context = await _interaction.GetAuthorizationContextAsync(returnUrl);
        await _events.RaiseAsync(new UserLoginSuccessEvent(provider, providerUserId, user.SubjectId, user.Username, true, context?.Client.ClientId));

        if (context != null)
        {
            if (context.IsNativeClient())
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", returnUrl);
            }
        }

        return Redirect(returnUrl);
    }

    private (TestUser user, string provider, string providerUserId, IEnumerable claims) FindUserFromExternalProvider(AuthenticateResult result)
    {
        var externalUser = result.Principal;

        // try to determine the unique id of the external user (issued by the provider)
        // the most common claim type for that are the sub claim and the NameIdentifier
        // depending on the external provider, some other claim type might be used
        var userIdClaim = externalUser.FindFirst(JwtClaimTypes.Subject) ??
                          externalUser.FindFirst(ClaimTypes.NameIdentifier) ??
                          throw new Exception("Unknown userid");

        // remove the user id claim so we don't include it as an extra claim if/when we provision the user
        var claims = externalUser.Claims.ToList();
        claims.Remove(userIdClaim);

        var provider = result.Properties.Items["scheme"];
        var providerUserId = userIdClaim.Value;

        // find external user
        var user = _users.FindByExternalProvider(provider, providerUserId);

        return (user, provider, providerUserId, claims);
    }

    private TestUser AutoProvisionUser(string provider, string providerUserId, IEnumerable claims)
    {
        var user = _users.AutoProvisionUser(provider, providerUserId, claims.ToList());
        return user;
    }

    // if the external login is OIDC-based, there are certain things we need to preserve to make logout work
    // this will be different for WS-Fed, SAML2p or other protocols
    private void ProcessLoginCallback(AuthenticateResult externalResult, List localClaims, AuthenticationProperties localSignInProps)
    {
        // if the external system sent a session id claim, copy it over
        // so we can use it for single sign-out
        var sid = externalResult.Principal.Claims.FirstOrDefault(x => x.Type == JwtClaimTypes.SessionId);
        if (sid != null)
        {
            localClaims.Add(new Claim(JwtClaimTypes.SessionId, sid.Value));
        }

        // if the external provider issued an id_token, we'll keep it for signout
        var idToken = externalResult.Properties.GetTokenValue("id_token");
        if (idToken != null)
        {
            localSignInProps.StoreTokens(new[] { new AuthenticationToken { Name = "id_token", Value = idToken } });
        }
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/ExternalProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ExternalProvider
{
    public string DisplayName { get; set; }
    public string AuthenticationScheme { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/LoggedOutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoggedOutViewModel
{
    public string PostLogoutRedirectUri { get; set; }
    public string ClientName { get; set; }
    public string SignOutIframeUrl { get; set; }

    public bool AutomaticRedirectAfterSignOut { get; set; }

    public string LogoutId { get; set; }
    public bool TriggerExternalSignout => ExternalAuthenticationScheme != null;
    public string ExternalAuthenticationScheme { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/LoginInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginInputModel
{
    [Required]
    public string Username { get; set; }
    [Required]
    public string Password { get; set; }
    public bool RememberLogin { get; set; }
    public string ReturnUrl { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/LoginViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LoginViewModel : LoginInputModel
{
    public bool AllowRememberLogin { get; set; } = true;
    public bool EnableLocalLogin { get; set; } = true;

    public IEnumerable ExternalProviders { get; set; } = Enumerable.Empty();
    public IEnumerable VisibleExternalProviders => ExternalProviders.Where(x => !String.IsNullOrWhiteSpace(x.DisplayName));

    public bool IsExternalLoginOnly => EnableLocalLogin == false && ExternalProviders?.Count() == 1;
    public string ExternalLoginScheme => IsExternalLoginOnly ? ExternalProviders?.SingleOrDefault()?.AuthenticationScheme : null;
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/LogoutInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutInputModel
{
    public string LogoutId { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/LogoutViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class LogoutViewModel : LogoutInputModel
{
    public bool ShowLogoutPrompt { get; set; } = true;
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Account/RedirectViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class RedirectViewModel
{
    public string RedirectUrl { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ConsentController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This controller processes the consent UI
/// 
[SecurityHeaders]
[Authorize]
public class ConsentController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public ConsentController(
        IIdentityServerInteractionService interaction,
        IEventService events,
        ILogger logger)
    {
        _interaction = interaction;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Shows the consent screen
    /// 
    /// 
    /// 
    [HttpGet]
    public async Task Index(string returnUrl)
    {
        var vm = await BuildViewModelAsync(returnUrl);
        if (vm != null)
        {
            return View("Index", vm);
        }

        return View("Error");
    }

    /// 
    /// Handles the consent screen postback
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Index(ConsentInputModel model)
    {
        var result = await ProcessConsent(model);

        if (result.IsRedirect)
        {
            var context = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
            if (context?.IsNativeClient() == true)
            {
                // The client is native, so this change in how to
                // return the response is for better UX for the end user.
                return this.LoadingPage("Redirect", result.RedirectUri);
            }
            return result.RedirectUri.IsAllowedRedirect() ? Redirect(result.RedirectUri.SanitizeForRedirect()) : Forbid();
        }

        if (result.HasValidationError)
        {
            ModelState.AddModelError(string.Empty, result.ValidationError);
        }

        if (result.ShowView)
        {
            return View("Index", result.ViewModel);
        }

        return View("Error");
    }

    /*****************************************/
    /* helper APIs for the ConsentController */
    /*****************************************/
    private async Task ProcessConsent(ConsentInputModel model)
    {
        var result = new ProcessConsentResult();

        // validate return url is still valid
        var request = await _interaction.GetAuthorizationContextAsync(model.ReturnUrl);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model?.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model?.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.GrantConsentAsync(request, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.ReturnUrl, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string returnUrl, ConsentInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(returnUrl);
        if (request != null)
        {
            return CreateConsentViewModel(model, returnUrl, request);
        }
        else
        {
            _logger.LogError("No consent request matching request: {0}", returnUrl.SanitizeForLog());
        }

        return null;
    }

    private ConsentViewModel CreateConsentViewModel(
        ConsentInputModel model, string returnUrl,
        AuthorizationRequest request)
    {
        var vm = new ConsentViewModel
        {
            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),
            Description = model?.Description,

            ReturnUrl = returnUrl,

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach(var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        var displayName = apiScope.DisplayName ?? apiScope.Name;
        if (!String.IsNullOrWhiteSpace(parsedScopeValue.ParsedParameter))
        {
            displayName += ":" + parsedScopeValue.ParsedParameter;
        }

        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            DisplayName = displayName,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }

    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ConsentInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentInputModel
{
    public string Button { get; set; }
    public IEnumerable ScopesConsented { get; set; }
    public bool RememberConsent { get; set; }
    public string ReturnUrl { get; set; }
    public string Description { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ConsentOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentOptions
{
    public static bool EnableOfflineAccess = true;
    public static string OfflineAccessDisplayName = "Offline Access";
    public static string OfflineAccessDescription = "Access to your applications and resources, even when you are offline";

    public static readonly string MustChooseOneErrorMessage = "You must pick at least one permission";
    public static readonly string InvalidSelectionErrorMessage = "Invalid selection";
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ConsentViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ConsentViewModel : ConsentInputModel
{
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public bool AllowRememberConsent { get; set; }

    public IEnumerable IdentityScopes { get; set; }
    public IEnumerable ApiScopes { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ProcessConsentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ProcessConsentResult
{
    public bool IsRedirect => RedirectUri != null;
    public string RedirectUri { get; set; }
    public Client Client { get; set; }

    public bool ShowView => ViewModel != null;
    public ConsentViewModel ViewModel { get; set; }

    public bool HasValidationError => ValidationError != null;
    public string ValidationError { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Consent/ScopeViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ScopeViewModel
{
    public string Value { get; set; }
    public string DisplayName { get; set; }
    public string Description { get; set; }
    public bool Emphasize { get; set; }
    public bool Required { get; set; }
    public bool Checked { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Device/DeviceAuthorizationInputModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationInputModel : ConsentInputModel
{
    public string UserCode { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Device/DeviceAuthorizationViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DeviceAuthorizationViewModel : ConsentViewModel
{
    public string UserCode { get; set; }
    public bool ConfirmUserCode { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Device/DeviceController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[Authorize]
[SecurityHeaders]
public class DeviceController : Controller
{
    private readonly IDeviceFlowInteractionService _interaction;
    private readonly IEventService _events;
    private readonly IOptions _options;
    private readonly ILogger _logger;

    public DeviceController(
        IDeviceFlowInteractionService interaction,
        IEventService eventService,
        IOptions options,
        ILogger logger)
    {
        _interaction = interaction;
        _events = eventService;
        _options = options;
        _logger = logger;
    }

    [HttpGet]
    public async Task Index()
    {
        string userCodeParamName = _options.Value.UserInteraction.DeviceVerificationUserCodeParameter;
        string userCode = Request.Query[userCodeParamName];
        if (string.IsNullOrWhiteSpace(userCode)) return View("UserCodeCapture");

        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        vm.ConfirmUserCode = true;
        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task UserCodeCapture(string userCode)
    {
        var vm = await BuildViewModelAsync(userCode);
        if (vm == null) return View("Error");

        return View("UserCodeConfirmation", vm);
    }

    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Callback(DeviceAuthorizationInputModel model)
    {
        if (model == null) throw new ArgumentNullException(nameof(model));

        var result = await ProcessConsent(model);
        if (result.HasValidationError) return View("Error");

        return View("Success");
    }

    private async Task ProcessConsent(DeviceAuthorizationInputModel model)
    {
        var result = new ProcessConsentResult();

        var request = await _interaction.GetAuthorizationContextAsync(model.UserCode);
        if (request == null) return result;

        ConsentResponse grantedConsent = null;

        // user clicked 'no' - send back the standard 'access_denied' response
        if (model.Button == "no")
        {
            grantedConsent = new ConsentResponse { Error = AuthorizationError.AccessDenied };

            // emit event
            await _events.RaiseAsync(new ConsentDeniedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues));
        }
        // user clicked 'yes' - validate the data
        else if (model.Button == "yes")
        {
            // if the user consented to some scope, build the response model
            if (model.ScopesConsented != null && model.ScopesConsented.Any())
            {
                var scopes = model.ScopesConsented;
                if (ConsentOptions.EnableOfflineAccess == false)
                {
                    scopes = scopes.Where(x => x != IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess);
                }

                grantedConsent = new ConsentResponse
                {
                    RememberConsent = model.RememberConsent,
                    ScopesValuesConsented = scopes.ToArray(),
                    Description = model.Description
                };

                // emit event
                await _events.RaiseAsync(new ConsentGrantedEvent(User.GetSubjectId(), request.Client.ClientId, request.ValidatedResources.RawScopeValues, grantedConsent.ScopesValuesConsented, grantedConsent.RememberConsent));
            }
            else
            {
                result.ValidationError = ConsentOptions.MustChooseOneErrorMessage;
            }
        }
        else
        {
            result.ValidationError = ConsentOptions.InvalidSelectionErrorMessage;
        }

        if (grantedConsent != null)
        {
            // communicate outcome of consent back to identityserver
            await _interaction.HandleRequestAsync(model.UserCode, grantedConsent);

            // indicate that's it ok to redirect back to authorization endpoint
            result.RedirectUri = model.ReturnUrl;
            result.Client = request.Client;
        }
        else
        {
            // we need to redisplay the consent UI
            result.ViewModel = await BuildViewModelAsync(model.UserCode, model);
        }

        return result;
    }

    private async Task BuildViewModelAsync(string userCode, DeviceAuthorizationInputModel model = null)
    {
        var request = await _interaction.GetAuthorizationContextAsync(userCode);
        if (request != null)
        {
            return CreateConsentViewModel(userCode, model, request);
        }

        return null;
    }

    private DeviceAuthorizationViewModel CreateConsentViewModel(string userCode, DeviceAuthorizationInputModel model, DeviceFlowAuthorizationRequest request)
    {
        var vm = new DeviceAuthorizationViewModel
        {
            UserCode = userCode,
            Description = model?.Description,

            RememberConsent = model?.RememberConsent ?? true,
            ScopesConsented = model?.ScopesConsented ?? Enumerable.Empty(),

            ClientName = request.Client.ClientName ?? request.Client.ClientId,
            ClientUrl = request.Client.ClientUri,
            ClientLogoUrl = request.Client.LogoUri,
            AllowRememberConsent = request.Client.AllowRememberConsent
        };

        vm.IdentityScopes = request.ValidatedResources.Resources.IdentityResources.Select(x => CreateScopeViewModel(x, vm.ScopesConsented.Contains(x.Name) || model == null)).ToArray();

        var apiScopes = new List();
        foreach (var parsedScope in request.ValidatedResources.ParsedScopes)
        {
            var apiScope = request.ValidatedResources.Resources.FindApiScope(parsedScope.ParsedName);
            if (apiScope != null)
            {
                var scopeVm = CreateScopeViewModel(parsedScope, apiScope, vm.ScopesConsented.Contains(parsedScope.RawValue) || model == null);
                apiScopes.Add(scopeVm);
            }
        }
        if (ConsentOptions.EnableOfflineAccess && request.ValidatedResources.Resources.OfflineAccess)
        {
            apiScopes.Add(GetOfflineAccessScope(vm.ScopesConsented.Contains(IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess) || model == null));
        }
        vm.ApiScopes = apiScopes;

        return vm;
    }

    private ScopeViewModel CreateScopeViewModel(IdentityResource identity, bool check)
    {
        return new ScopeViewModel
        {
            Value = identity.Name,
            DisplayName = identity.DisplayName ?? identity.Name,
            Description = identity.Description,
            Emphasize = identity.Emphasize,
            Required = identity.Required,
            Checked = check || identity.Required
        };
    }

    public ScopeViewModel CreateScopeViewModel(ParsedScopeValue parsedScopeValue, ApiScope apiScope, bool check)
    {
        return new ScopeViewModel
        {
            Value = parsedScopeValue.RawValue,
            // todo: use the parsed scope value in the display?
            DisplayName = apiScope.DisplayName ?? apiScope.Name,
            Description = apiScope.Description,
            Emphasize = apiScope.Emphasize,
            Required = apiScope.Required,
            Checked = check || apiScope.Required
        };
    }
    private ScopeViewModel GetOfflineAccessScope(bool check)
    {
        return new ScopeViewModel
        {
            Value = IdentityServer8.IdentityServerConstants.StandardScopes.OfflineAccess,
            DisplayName = ConsentOptions.OfflineAccessDisplayName,
            Description = ConsentOptions.OfflineAccessDescription,
            Emphasize = true,
            Checked = check
        };
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Diagnostics/DiagnosticsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[Authorize]
public class DiagnosticsController : Controller
{
    public async Task Index()
    {
        var localAddresses = new string[] { "127.0.0.1", "::1", HttpContext.Connection.LocalIpAddress.ToString() };
        if (!localAddresses.Contains(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return NotFound();
        }

        var model = new DiagnosticsViewModel(await HttpContext.AuthenticateAsync());
        return View(model);
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Diagnostics/DiagnosticsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class DiagnosticsViewModel
{
    public DiagnosticsViewModel(AuthenticateResult result)
    {
        AuthenticateResult = result;

        if (result.Properties.Items.ContainsKey("client_list"))
        {
            var encoded = result.Properties.Items["client_list"];
            var bytes = Base64Url.Decode(encoded);
            var value = Encoding.UTF8.GetString(bytes);

            Clients = JsonConvert.DeserializeObject(value);
        }
    }

    public AuthenticateResult AuthenticateResult { get; }
    public IEnumerable Clients { get; } = new List();
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public static class Extensions
{
    /// 
    /// Checks if the redirect URI is for a native client.
    /// 
    /// 
    public static bool IsNativeClient(this AuthorizationRequest context)
    {
        return !context.RedirectUri.StartsWith("https", StringComparison.Ordinal)
           && !context.RedirectUri.StartsWith("http", StringComparison.Ordinal);
    }

    public static IActionResult LoadingPage(this Controller controller, string viewName, string redirectUri)
    {
        controller.HttpContext.Response.StatusCode = 200;
        controller.HttpContext.Response.Headers["Location"] = "";
        
        return controller.View(viewName, new RedirectViewModel { RedirectUrl = redirectUri });
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Grants/GrantsController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

/// 
/// This sample controller allows a user to revoke grants given to clients
/// 
[SecurityHeaders]
[Authorize]
public class GrantsController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IClientStore _clients;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;

    public GrantsController(IIdentityServerInteractionService interaction,
        IClientStore clients,
        IResourceStore resources,
        IEventService events)
    {
        _interaction = interaction;
        _clients = clients;
        _resources = resources;
        _events = events;
    }

    /// 
    /// Show list of grants
    /// 
    [HttpGet]
    public async Task Index()
    {
        return View("Index", await BuildViewModelAsync());
    }

    /// 
    /// Handle postback to revoke a client
    /// 
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task Revoke(string clientId)
    {
        await _interaction.RevokeUserConsentAsync(clientId);
        await _events.RaiseAsync(new GrantsRevokedEvent(User.GetSubjectId(), clientId));

        return RedirectToAction("Index");
    }

    private async Task BuildViewModelAsync()
    {
        var grants = await _interaction.GetAllUserGrantsAsync();

        var list = new List();
        foreach(var grant in grants)
        {
            var client = await _clients.FindClientByIdAsync(grant.ClientId);
            if (client != null)
            {
                var resources = await _resources.FindResourcesByScopeAsync(grant.Scopes);

                var item = new GrantViewModel()
                {
                    ClientId = client.ClientId,
                    ClientName = client.ClientName ?? client.ClientId,
                    ClientLogoUrl = client.LogoUri,
                    ClientUrl = client.ClientUri,
                    Description = grant.Description,
                    Created = grant.CreationTime,
                    Expires = grant.Expiration,
                    IdentityGrantNames = resources.IdentityResources.Select(x => x.DisplayName ?? x.Name).ToArray(),
                    ApiGrantNames = resources.ApiScopes.Select(x => x.DisplayName ?? x.Name).ToArray()
                };

                list.Add(item);
            }
        }

        return new GrantsViewModel
        {
            Grants = list
        };
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Grants/GrantsViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class GrantsViewModel
{
    public IEnumerable Grants { get; set; }
}

public class GrantViewModel
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string ClientUrl { get; set; }
    public string ClientLogoUrl { get; set; }
    public string Description { get; set; }
    public DateTime Created { get; set; }
    public DateTime? Expires { get; set; }
    public IEnumerable IdentityGrantNames { get; set; }
    public IEnumerable ApiGrantNames { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Home/ErrorViewModel.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class ErrorViewModel
{
    public ErrorViewModel()
    {
    }

    public ErrorViewModel(string error)
    {
        Error = new ErrorMessage { Error = error };
    }

    public ErrorMessage Error { get; set; }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/Home/HomeController.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

[SecurityHeaders]
[AllowAnonymous]
public class HomeController : Controller
{
    private readonly IIdentityServerInteractionService _interaction;
    private readonly IWebHostEnvironment _environment;
    private readonly ILogger _logger;

    public HomeController(IIdentityServerInteractionService interaction, IWebHostEnvironment environment, ILogger logger)
    {
        _interaction = interaction;
        _environment = environment;
        _logger = logger;
    }

    public IActionResult Index()
    {
        if (_environment.IsDevelopment())
        {
            // only show in development
            return View();
        }

        _logger.LogInformation("Homepage is disabled in production. Returning 404.");
        return NotFound();
    }

    /// 
    /// Shows the error page
    /// 
    public async Task Error(string errorId)
    {
        var vm = new ErrorViewModel();

        // retrieve error details from identityserver
        var message = await _interaction.GetErrorContextAsync(errorId);
        if (message != null)
        {
            vm.Error = message;

            if (!_environment.IsDevelopment())
            {
                // only show in development
                message.ErrorDescription = null;
            }
        }

        return View("Error", vm);
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/SecurityHeadersAttribute.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServerHost.Quickstart.UI;

public class SecurityHeadersAttribute : ActionFilterAttribute
{
    public override void OnResultExecuting(ResultExecutingContext context)
    {
        var result = context.Result;
        if (result is ViewResult)
        {
            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Content-Type-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Type-Options", "nosniff");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Frame-Options
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
            {
                context.HttpContext.Response.Headers.Append("X-Frame-Options", "SAMEORIGIN");
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Security-Policy
            var csp = "default-src 'self'; object-src 'none'; frame-ancestors 'none'; sandbox allow-forms allow-same-origin allow-scripts; base-uri 'self';";
            // also consider adding upgrade-insecure-requests once you have HTTPS in place for production
            //csp += "upgrade-insecure-requests;";
            // also an example if you need client images to be displayed from twitter
            // csp += "img-src 'self' https://pbs.twimg.com;";

            // once for standards compliant browsers
            if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Content-Security-Policy", csp);
            }
            // and once again for IE
            if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
            {
                context.HttpContext.Response.Headers.Append("X-Content-Security-Policy", csp);
            }

            // https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Referrer-Policy
            var referrer_policy = "no-referrer";
            if (!context.HttpContext.Response.Headers.ContainsKey("Referrer-Policy"))
            {
                context.HttpContext.Response.Headers.Append("Referrer-Policy", referrer_policy);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/host/Quickstart/TestUsers.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServerHost.Quickstart.UI;

public class TestUsers
{
    public static List Users
    {
        get
        {
            var address = new
            {
                street_address = "One Hacker Way",
                locality = "Heidelberg",
                postal_code = 69118,
                country = "Germany"
            };
            
            return new List
            {
                new TestUser
                {
                    SubjectId = "818727",
                    Username = "alice",
                    Password = "alice",
                    Claims =
                    {
                        new Claim(JwtClaimTypes.Name, "Alice Smith"),
                        new Claim(JwtClaimTypes.GivenName, "Alice"),
                        new Claim(JwtClaimTypes.FamilyName, "Smith"),
                        new Claim(JwtClaimTypes.Email, "AliceSmith@email.com"),
                        new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                        new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                        new Claim(JwtClaimTypes.Address, JsonSerializer.Serialize(address), IdentityServerConstants.ClaimValueTypes.Json)
                    }
                },
                new TestUser
                {
                    SubjectId = "88421113",
                    Username = "bob",
                    Password = "bob",
                    Claims =
                    {
                        new Claim(JwtClaimTypes.Name, "Bob Smith"),
                        new Claim(JwtClaimTypes.GivenName, "Bob"),
                        new Claim(JwtClaimTypes.FamilyName, "Smith"),
                        new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                        new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                        new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                        new Claim(JwtClaimTypes.Address, JsonSerializer.Serialize(address), IdentityServerConstants.ClaimValueTypes.Json)
                    }
                }
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/host/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Resources = IdentityServerHost.Configuration.Resources;
using IdentityServerHost.Extensions;

namespace IdentityServerHost;

public class Startup
{
    private readonly IConfiguration _config;

    public Startup(IConfiguration config)
    {
        _config = config;

        IdentityModelEventSource.ShowPII = true;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddControllersWithViews();
        
        // cookie policy to deal with temporary browser incompatibilities
        services.AddSameSiteCookiePolicy();

        var builder = services.AddIdentityServer(options =>
            {
                options.Events.RaiseSuccessEvents = true;
                options.Events.RaiseFailureEvents = true;
                options.Events.RaiseErrorEvents = true;
                options.Events.RaiseInformationEvents = true;

                options.EmitScopesAsSpaceDelimitedStringInJwt = true;

                options.MutualTls.Enabled = true;
                options.MutualTls.DomainName = "mtls";
                //options.MutualTls.AlwaysEmitConfirmationClaim = true;
            })
            .AddInMemoryClients(Clients.Get())
            .AddInMemoryIdentityResources(Resources.IdentityResources)
            .AddInMemoryApiScopes(Resources.ApiScopes)
            .AddInMemoryApiResources(Resources.ApiResources)
            .AddSigningCredential()
            .AddExtensionGrantValidator()
            .AddExtensionGrantValidator()
            .AddJwtBearerClientAuthentication()
            .AddAppAuthRedirectUriValidator()
            .AddTestUsers(TestUsers.Users)
            .AddProfileService()
            .AddCustomTokenRequestValidator()
            .AddScopeParser()
            .AddMutualTlsSecretValidators();

        // use this for persisted grants store
        // var migrationsAssembly = typeof(Startup).GetTypeInfo().Assembly.GetName().Name;
        // const string connectionString = "DataSource=identityserver.db";
        // builder.AddOperationalStore(options =>
        // {
        //     options.ConfigureDbContext = b => b.UseSqlite(connectionString,
        //         sql => sql.MigrationsAssembly(migrationsAssembly));
        // });
            

        services.AddExternalIdentityProviders();

        services.AddAuthentication()
            .AddCertificate(options =>
            {
                options.AllowedCertificateTypes = CertificateTypes.All;
                options.RevocationMode = X509RevocationMode.NoCheck;
            });
        
        services.AddCertificateForwardingForNginx();
        
        services.AddLocalApiAuthentication(principal =>
        {
            principal.Identities.First().AddClaim(new Claim("additional_claim", "additional_value"));

            return Task.FromResult(principal);
        });
    }

    public void Configure(IApplicationBuilder app)
    {
        // use this for persisted grants store
        // app.InitializePersistedGrantsStore();
        
        app.UseForwardedHeaders(new ForwardedHeadersOptions
        {
            ForwardedHeaders = ForwardedHeaders.XForwardedFor | ForwardedHeaders.XForwardedProto
        });

        app.UseCertificateForwarding();
        app.UseCookiePolicy();
        
        app.UseSerilogRequestLogging();

        app.UseDeveloperExceptionPage();
        app.UseStaticFiles();

        app.UseRouting();
        app.UseIdentityServer();

        app.UseAuthorization();

        app.UseEndpoints(endpoints =>
        {
            endpoints.MapDefaultControllerRoute();
        });
    }
}

public static class BuilderExtensions
{
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder)
    {
        // create random RS256 key
        //builder.AddDeveloperSigningCredential();

        // use an RSA-based certificate with RS256
        var rsaCert = new X509Certificate2("./keys/identityserver.test.rsa.p12", "changeit");
        builder.AddSigningCredential(rsaCert, "RS256");

        // ...and PS256
        builder.AddSigningCredential(rsaCert, "PS256");

        // or manually extract ECDSA key from certificate (directly using the certificate is not support by Microsoft right now)
        var ecCert = new X509Certificate2("./keys/identityserver.test.ecdsa.p12", "changeit");
        var key = new ECDsaSecurityKey(ecCert.GetECDsaPrivateKey())
        {
            KeyId = CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex)
        };

        return builder.AddSigningCredential(
            key,
            IdentityServerConstants.ECDsaSigningAlgorithm.ES256);
    }

    // use this for persisted grants store
    // public static void InitializePersistedGrantsStore(this IApplicationBuilder app)
    // {
    //     using (var serviceScope = app.ApplicationServices.GetService().CreateScope())
    //     {
    //         serviceScope.ServiceProvider.GetRequiredService().Database.Migrate();
    //     }
    // }
}

public static class ServiceExtensions
{
    public static IServiceCollection AddExternalIdentityProviders(this IServiceCollection services)
    {
        // configures the OpenIdConnect handlers to persist the state parameter into the server-side IDistributedCache.
        services.AddOidcStateDataFormatterCache("aad", "demoidsrv");

        services.AddAuthentication()
            .AddOpenIdConnect("Google", "Google", options =>
             {
                 options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                 options.ForwardSignOut = IdentityServerConstants.DefaultCookieAuthenticationScheme;

                 options.Authority = "https://accounts.google.com/";
                 options.ClientId = "708996912208-9m4dkjb5hscn7cjrn5u0r4tbgkbj1fko.apps.googleusercontent.com";

                 options.CallbackPath = "/signin-google";
                 options.Scope.Add("email");
             })
            .AddOpenIdConnect("demoidsrv", "IdentityServer", options =>
            {
                options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                options.SignOutScheme = IdentityServerConstants.SignoutScheme;

                options.Authority = "https://demo.identityserver8.io/";
                options.ClientId = "login";
                options.ResponseType = "id_token";
                options.SaveTokens = true;
                options.CallbackPath = "/signin-idsrv";
                options.SignedOutCallbackPath = "/signout-callback-idsrv";
                options.RemoteSignOutPath = "/signout-idsrv";

                options.TokenValidationParameters = new TokenValidationParameters
                {
                    NameClaimType = "name",
                    RoleClaimType = "role"
                };
            })
            .AddOpenIdConnect("aad", "Azure AD", options =>
            {
                options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                options.SignOutScheme = IdentityServerConstants.SignoutScheme;

                options.Authority = "https://login.windows.net/4ca9cb4c-5e5f-4be9-b700-c532992a3705";
                options.ClientId = "96e3c53e-01cb-4244-b658-a42164cb67a9";
                options.ResponseType = "id_token";
                options.CallbackPath = "/signin-aad";
                options.SignedOutCallbackPath = "/signout-callback-aad";
                options.RemoteSignOutPath = "/signout-aad";
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    NameClaimType = "name",
                    RoleClaimType = "role"
                };
            })
            .AddOpenIdConnect("adfs", "ADFS", options =>
            {
                options.SignInScheme = IdentityServerConstants.ExternalCookieAuthenticationScheme;
                options.SignOutScheme = IdentityServerConstants.SignoutScheme;

                options.Authority = "https://adfs.leastprivilege.vm/adfs";
                options.ClientId = "c0ea8d99-f1e7-43b0-a100-7dee3f2e5c3c";
                options.ResponseType = "id_token";

                options.CallbackPath = "/signin-adfs";
                options.SignedOutCallbackPath = "/signout-callback-adfs";
                options.RemoteSignOutPath = "/signout-adfs";
                options.TokenValidationParameters = new TokenValidationParameters
                {
                    NameClaimType = "name",
                    RoleClaimType = "role"
                };
            });

        return services;
    }

    public static void AddCertificateForwardingForNginx(this IServiceCollection services)
    {
        services.AddCertificateForwarding(options =>
        {
            options.CertificateHeader = "X-SSL-CERT";

            options.HeaderConverter = (headerValue) =>
            {
                X509Certificate2 clientCertificate = null;

                if(!string.IsNullOrWhiteSpace(headerValue))
                {
                    byte[] bytes = Encoding.UTF8.GetBytes(Uri.UnescapeDataString(headerValue));
                    clientCertificate = new X509Certificate2(bytes);
                }

                return clientCertificate;
            };
        });
    }
}


================================================
FILE: src/IdentityServer8/host/Views/Account/AccessDenied.cshtml
================================================


    
    
    
        
    Access Denied
    
        
    You do not have access to that resource.
    
    
    

    

================================================
FILE: src/IdentityServer8/host/Views/Account/LoggedOut.cshtml
================================================
@model LoggedOutViewModel

@{ 
    // set this so the layout rendering sees an anonymous user
    ViewData["signed-out"] = true;
}


    
    
    
        Logout
        You are now logged out
    
    

    @if (Model.PostLogoutRedirectUri != null)
    {
        
    
            Click here to return to the
            @Model.ClientName application.
        
    
    }

    @if (Model.SignOutIframeUrl != null)
    {
        
    }

    

@section scripts
{
    @if (Model.AutomaticRedirectAfterSignOut)
    {
        
    }
}


================================================
FILE: src/IdentityServer8/host/Views/Account/Login.cshtml
================================================
@model LoginViewModel



================================================
FILE: src/IdentityServer8/host/Views/Account/Logout.cshtml
================================================
@model LogoutViewModel


    
    
    
        
    Logout
    
        
    Would you like to logout of IdentityServer?
    
    
    

    
    
        
        
    
            
        
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Consent/Index.cshtml
================================================
@model ConsentViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Device/Success.cshtml
================================================


    
    
    
        
    Success
    
        
    You have successfully authorized the device
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Device/UserCodeCapture.cshtml
================================================
@model string


    
    
    
        
    User Code
    
        
    Please enter the code displayed on your device.
    
    
    

    

    
    
        
    
            
    
                
    
                    
                    
                
    

                
            
    
        
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Device/UserCodeConfirmation.cshtml
================================================
@model DeviceAuthorizationViewModel


    
    
    
        @if (Model.ClientLogoUrl != null)
        {
            
        }
        
    
            @Model.ClientName
            is requesting your permission
        
    
        @if (Model.ConfirmUserCode)
        {
            
    Please confirm that the authorization request quotes the code: @Model.UserCode.
    
        }
        
    Uncheck the permissions you do not wish to grant.
    
    
    

    
    
        
    
            
        
    
    
    

    
    
        
        
    
            
    
                @if (Model.IdentityScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Personal Information
                            
    
                            
      
                                @foreach (var scope in Model.IdentityScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                @if (Model.ApiScopes.Any())
                {
                    
    
                        
    
                            
    
                                
                                Application Access
                            
    
                            
      
                                @foreach (var scope in Model.ApiScopes)
                                {
                                    
                                }
                            
    
                        
    
                    
    
                }

                
    
                    
    
                        
    
                            
                            Description
                        
    
                        
    
                            
                        
    
                    
    
                
    

                @if (Model.AllowRememberConsent)
                {
                    
    
                        
    
                            
                            
                        
    
                    
    
                }
            
    
        
    

        
    
            
    
                
                
            
    
            
    
                @if (Model.ClientUrl != null)
                {
                    
                        
                        @Model.ClientName
                    
                }
            
    
        
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Diagnostics/Index.cshtml
================================================
@model DiagnosticsViewModel


    
    
    
        
    Authentication Cookie
    
    
    

    
    
        
    
            
    
                
    
                    
    Claims
    
                
    
                
    
                    
    
                        @foreach (var claim in Model.AuthenticateResult.Principal.Claims)
                        {
                            
    @claim.Type
    
                            
    @claim.Value
    
                        }
                    
    
                
    
            
    
        
    
        
        
    
            
    
                
    
                    
    Properties
    
                
    
                
    
                    
    
                        @foreach (var prop in Model.AuthenticateResult.Properties.Items)
                        {
                            
    @prop.Key
    
                            
    @prop.Value
    
                        }
                        @if (Model.Clients.Any())
                        {
                            
    Clients
    
                            
    
                            @{
                                var clients = Model.Clients.ToArray();
                                for(var i = 0; i < clients.Length; i++)
                                {
                                    @clients[i]
                                    if (i < clients.Length - 1)
                                    {
                                        , 
                                    }
                                }
                            }
                            
    
                        }
                    
    
                
    
            
    
        
    
    
    

    






================================================
FILE: src/IdentityServer8/host/Views/Grants/Index.cshtml
================================================
@model GrantsViewModel


    
    
    
        
    Client Application Permissions
    
        
    Below is the list of applications you have given permission to and the resources they have access to.
    
    
    

    @if (Model.Grants.Any() == false)
    {
        
    
            
    
                
    
                    You have not given access to any applications
                
    
            
    
        
    
    }
    else
    {
        foreach (var grant in Model.Grants)
        {
            
    
                
    
                    
    
                        
    
                            @if (grant.ClientLogoUrl != null)
                            {
                                
                            }
                            @grant.ClientName
                        
    

                        
    
                            
    
                                
                                
                            
    
                        
    
                    
    
                
    
                
                
      
                    @if (grant.Description != null)
                    {
                        
    • 
                             @grant.Description
                        
      •    
                    }
                    
    • 
                         @grant.Created.ToString("yyyy-MM-dd")
                    
      • 
                    @if (grant.Expires.HasValue)
                    {
                        
    • 
                             @grant.Expires.Value.ToString("yyyy-MM-dd")
                        
      • 
                    }
                    @if (grant.IdentityGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.IdentityGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                    @if (grant.ApiGrantNames.Any())
                    {
                        
    • 
                            
                            
        
                                @foreach (var name in grant.ApiGrantNames)
                                {
                                    
      • @name
        • 
                                }
                            
      
                        
      • 
                    }
                
    
            
    
        }
    }

    

================================================
FILE: src/IdentityServer8/host/Views/Home/Index.cshtml
================================================
@using System.Diagnostics
@using System.Reflection

@{
    var version = typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.GetCustomAttribute()?.InformationalVersion.Split('+').First();
}


    
    
    
        
        Welcome to IdentityServer8
        (version @version)
    
    

    

    


================================================
FILE: src/IdentityServer8/host/Views/Shared/Error.cshtml
================================================
@model ErrorViewModel

@{
    var error = Model?.Error?.Error;
    var errorDescription = Model?.Error?.ErrorDescription;
    var request_id = Model?.Error?.RequestId;
}


    
    
    
        
    Error
    
    
    

    
    
        
    
            
    
                Sorry, there was an error

                @if (error != null)
                {
                    
                        
                            : @error
                        
                    

                    if (errorDescription != null)
                    {
                        
    @errorDescription
    
                    }
                }
            
    

            @if (request_id != null)
            {
                
    Request Id: @request_id
    
            }
        
    
    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Shared/Redirect.cshtml
================================================
@model RedirectViewModel
@using Microsoft.Extensions.DependencyInjection;

    
    
    
        
    You are now being returned to the application
    
        
    Once complete, you may close this tab.
    
    
    

    





================================================
FILE: src/IdentityServer8/host/Views/Shared/_Layout.cshtml
================================================



    
    
    

    IdentityServer8
    
    
    
    
    
    


    
   
    
    
        @RenderBody()
    
    

    
    

    @RenderSection("scripts", required: false)




================================================
FILE: src/IdentityServer8/host/Views/Shared/_Nav.cshtml
================================================
@using IdentityServer8.Extensions

@{
    string name = null;
    if (!true.Equals(ViewData["signed-out"]))
    {
        name = Context.User?.GetDisplayName();
    }
}


    
    

    


================================================
FILE: src/IdentityServer8/host/Views/Shared/_ScopeListItem.cshtml
================================================
@model ScopeViewModel


  • 
    
    @if (Model.Required)
    {
        (required)
    }
    @if (Model.Description != null)
    {
        
    
            
        
    
    }

    • 

================================================
FILE: src/IdentityServer8/host/Views/Shared/_ValidationSummary.cshtml
================================================
@if (ViewContext.ModelState.IsValid == false)
{
    
    
        Error
        
    
    
    
}

================================================
FILE: src/IdentityServer8/host/Views/_ViewImports.cshtml
================================================
@using IdentityServerHost.Quickstart.UI
@addTagHelper *, Microsoft.AspNetCore.Mvc.TagHelpers


================================================
FILE: src/IdentityServer8/host/Views/_ViewStart.cshtml
================================================
@{
    Layout = "_Layout";
}


================================================
FILE: src/IdentityServer8/host/appsettings.json
================================================
{
  "ApiScopes": [
    {
      "Name": "IdentityServerApi"
    },
    {
      "Name": "resource1.scope1"
    },
    {
      "Name": "resource2.scope1"
    },
    {
      "Name": "scope3"
    },
    {
      "Name": "shared.scope"
    },
    {
      "Name": "transaction",
      "DisplayName": "Transaction",
      "Description": "A transaction"
    }
  ],
  
  "ApiResources": [
    {
      "Name": "resource1",
      "DisplayName": "Resource #1",

      "Scopes": [
        "resource1.scope1",
        "shared.scope"
      ]
    },
    {
      "Name": "resource2",
      "DisplayName": "Resource #2",
      
      "UserClaims": [
        "name",
        "email"
      ],

      "Scopes": [
        "resource2.scope1",
        "shared.scope"
      ]
    }
  ],
  
  "Clients": [
    {
      "ClientId": "machine_client",
      "ClientSecrets": [ { "Value": "K7gNU3sdo+OL0wNhqoVWhr3g6s1xYv72ol/pe/Unols=" } ],
      "AllowedGrantTypes": [ "client_credentials" ],
      "AllowedScopes": [ "resource1.scope1", "resource1.scope2" ],
      "Properties": { "foo": "bar" },
      "Claims": [
        {
          "type": "c1",
          "value": "c1value"
        },
        {
          "type": "c2",
          "value": "c2value"
        }
      ]
    },
    {
      "ClientId": "interactive_client",
      "ClientSecrets": [ { "Value": "K7gNU3sdo+OL0wNhqoVWhr3g6s1xYv72ol/pe/Unols=" } ],
      "AllowedGrantTypes": [ "authorization_code", "client_credentials" ],
      "AllowedScopes": [ "openid", "profile", "resource1.scope1", "resource1.scope2" ]
    }
  ]
}

================================================
FILE: src/IdentityServer8/host/compilerconfig.json
================================================
[
  {
    "outputFile": "wwwroot/css/site.css",
    "inputFile": "wwwroot/css/site.scss"
  }
]

================================================
FILE: src/IdentityServer8/host/compilerconfig.json.defaults
================================================
{
  "compilers": {
    "less": {
      "autoPrefix": "",
      "cssComb": "none",
      "ieCompat": true,
      "strictMath": false,
      "strictUnits": false,
      "relativeUrls": true,
      "rootPath": "",
      "sourceMapRoot": "",
      "sourceMapBasePath": "",
      "sourceMap": false
    },
    "sass": {
      "autoPrefix": "",
      "includePath": "",
      "indentType": "space",
      "indentWidth": 2,
      "outputStyle": "nested",
      "Precision": 5,
      "relativeUrls": true,
      "sourceMapRoot": "",
      "lineFeed": "",
      "sourceMap": false
    },
    "stylus": {
      "sourceMap": false
    },
    "babel": {
      "sourceMap": false
    },
    "coffeescript": {
      "bare": false,
      "runtimeMode": "node",
      "sourceMap": false
    },
    "handlebars": {
      "root": "",
      "noBOM": false,
      "name": "",
      "namespace": "",
      "knownHelpersOnly": false,
      "forcePartial": false,
      "knownHelpers": [],
      "commonjs": "",
      "amd": false,
      "sourceMap": false
    }
  },
  "minifiers": {
    "css": {
      "enabled": true,
      "termSemicolons": true,
      "gzip": false
    },
    "javascript": {
      "enabled": true,
      "termSemicolons": true,
      "gzip": false
    }
  }
}

================================================
FILE: src/IdentityServer8/host/libman.json
================================================
{
  "version": "1.0",
  "defaultProvider": "cdnjs",
  "libraries": [
    {
      "provider": "jsdelivr",
      "library": "jquery@3.7.1",
      "destination": "wwwroot/lib/jquery/"
    },
    {
      "provider": "jsdelivr",
      "library": "bootstrap@5.3.2",
      "destination": "wwwroot/lib/bootstrap/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation@1.20.0",
      "destination": "wwwroot/lib/jquery-validation/"
    },
    {
      "provider": "jsdelivr",
      "library": "jquery-validation-unobtrusive@4.0.0",
      "destination": "wwwroot/lib/jquery-validation-unobtrusive/"
    }
  ]
}

================================================
FILE: src/IdentityServer8/host/wwwroot/css/site.css
================================================
.body-container {
  margin-top: 60px;
  padding-bottom: 40px; }

.welcome-page li {
  list-style: none;
  padding: 4px; }

.logged-out-page iframe {
  display: none;
  width: 0;
  height: 0; }

.grants-page .card {
  margin-top: 20px;
  border-bottom: 1px solid lightgray; }
  .grants-page .card .card-title {
    font-size: 120%;
    font-weight: bold; }
    .grants-page .card .card-title img {
      width: 100px;
      height: 100px; }
  .grants-page .card label {
    font-weight: bold; }


================================================
FILE: src/IdentityServer8/host/wwwroot/css/site.scss
================================================
.body-container {
    margin-top: 60px;
    padding-bottom:40px;
}

.welcome-page {
    li {
        list-style: none;
        padding: 4px;
    }
}

.logged-out-page {
    iframe {
        display: none;
        width: 0;
        height: 0;
    }
}

.grants-page {
    .card {
        margin-top: 20px;
        border-bottom: 1px solid lightgray;

        .card-title {
            img {
                width: 100px;
                height: 100px;
            }

            font-size: 120%;
            font-weight: bold;
        }

        label {
            font-weight: bold;
        }
    }
}




================================================
FILE: src/IdentityServer8/host/wwwroot/js/signin-redirect.js
================================================
//window.location.href = document.querySelector("meta[http-equiv=refresh]").getAttribute("data-url");


================================================
FILE: src/IdentityServer8/host/wwwroot/js/signout-redirect.js
================================================
window.addEventListener("load", function () {
    var a = document.querySelector("a.PostLogoutRedirectUri");
    if (a) {
        window.location = a.href;
    }
});


================================================
FILE: src/IdentityServer8/src/Configuration/CryptoHelper.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Configuration;

/// 
/// Crypto helper
/// 
public static class CryptoHelper
{
    /// 
    /// Creates a new RSA security key.
    /// 
    /// 
    public static RsaSecurityKey CreateRsaSecurityKey(int keySize = 2048)
    {
        return new RsaSecurityKey(RSA.Create(keySize))
        {
            KeyId = CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex)
        };
    }

    /// 
    /// Creates a new ECDSA security key.
    /// 
    /// The name of the curve as defined in
    /// https://tools.ietf.org/html/rfc7518#section-6.2.1.1.
    /// 
    public static ECDsaSecurityKey CreateECDsaSecurityKey(string curve = JsonWebKeyECTypes.P256)
    {
        return new ECDsaSecurityKey(ECDsa.Create(GetCurveFromCrvValue(curve)))
        {
            KeyId = CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex)
        };
    }

    /// 
    /// Creates an RSA security key.
    /// 
    /// The parameters.
    /// The identifier.
    /// 
    public static RsaSecurityKey CreateRsaSecurityKey(RSAParameters parameters, string id)
    {
        var key = new RsaSecurityKey(parameters)
        {
            KeyId = id
        };

        return key;
    }

    /// 
    /// Creates the hash for the various hash claims (e.g. c_hash, at_hash or s_hash).
    /// 
    /// The value to hash.
    /// The token signing algorithm
    /// 
    public static string CreateHashClaimValue(string value, string tokenSigningAlgorithm)
    {
        using (var sha = GetHashAlgorithmForSigningAlgorithm(tokenSigningAlgorithm))
        {
            var hash = sha.ComputeHash(Encoding.ASCII.GetBytes(value));
            var size = (sha.HashSize / 8) / 2;

            var leftPart = new byte[size];
            Array.Copy(hash, leftPart, size);

            return Base64Url.Encode(leftPart);
        }
    }

    /// 
    /// Returns the matching hashing algorithm for a token signing algorithm
    /// 
    /// The signing algorithm
    /// 
    public static HashAlgorithm GetHashAlgorithmForSigningAlgorithm(string signingAlgorithm)
    {
        var signingAlgorithmBits = int.Parse(signingAlgorithm.Substring(signingAlgorithm.Length - 3));

        return signingAlgorithmBits switch
        {
            256 => SHA256.Create(),
            384 => SHA384.Create(),
            512 => SHA512.Create(),
            _ => throw new InvalidOperationException($"Invalid signing algorithm: {signingAlgorithm}"),
        };
    }

    /// 
    /// Returns the matching named curve for RFC 7518 crv value
    /// 
    internal static ECCurve GetCurveFromCrvValue(string crv)
    {
        return crv switch
        {
            JsonWebKeyECTypes.P256 => ECCurve.NamedCurves.nistP256,
            JsonWebKeyECTypes.P384 => ECCurve.NamedCurves.nistP384,
            JsonWebKeyECTypes.P521 => ECCurve.NamedCurves.nistP521,
            _ => throw new InvalidOperationException($"Unsupported curve type of {crv}"),
        };
    }

    /// 
    /// Return the matching RFC 7518 crv value for curve
    /// 
    internal static string GetCrvValueFromCurve(ECCurve curve)
    {
        return curve.Oid.Value switch
        {
            Constants.CurveOids.P256 => JsonWebKeyECTypes.P256,
            Constants.CurveOids.P384 => JsonWebKeyECTypes.P384,
            Constants.CurveOids.P521 => JsonWebKeyECTypes.P521,
            _ => throw new InvalidOperationException($"Unsupported curve type of {curve.Oid.Value} - {curve.Oid.FriendlyName}"),
        };
    }

    internal static bool IsValidCurveForAlgorithm(ECDsaSecurityKey key, string algorithm)
    {
        var parameters = key.ECDsa.ExportParameters(false);

        if (algorithm == SecurityAlgorithms.EcdsaSha256 && parameters.Curve.Oid.Value != Constants.CurveOids.P256
            || algorithm == SecurityAlgorithms.EcdsaSha384 && parameters.Curve.Oid.Value != Constants.CurveOids.P384
            || algorithm == SecurityAlgorithms.EcdsaSha512 && parameters.Curve.Oid.Value != Constants.CurveOids.P521)
        {
            return false;
        }

        return true;
    }
    internal static bool IsValidCrvValueForAlgorithm(string crv)
    {
        return crv == JsonWebKeyECTypes.P256 ||
               crv == JsonWebKeyECTypes.P384 ||
               crv == JsonWebKeyECTypes.P521;
    }

    internal static string GetRsaSigningAlgorithmValue(IdentityServerConstants.RsaSigningAlgorithm value)
    {
        return value switch
        {
            IdentityServerConstants.RsaSigningAlgorithm.RS256 => SecurityAlgorithms.RsaSha256,
            IdentityServerConstants.RsaSigningAlgorithm.RS384 => SecurityAlgorithms.RsaSha384,
            IdentityServerConstants.RsaSigningAlgorithm.RS512 => SecurityAlgorithms.RsaSha512,

            IdentityServerConstants.RsaSigningAlgorithm.PS256 => SecurityAlgorithms.RsaSsaPssSha256,
            IdentityServerConstants.RsaSigningAlgorithm.PS384 => SecurityAlgorithms.RsaSsaPssSha384,
            IdentityServerConstants.RsaSigningAlgorithm.PS512 => SecurityAlgorithms.RsaSsaPssSha512,
            _ => throw new ArgumentException("Invalid RSA signing algorithm value", nameof(value)),
        };
    }

    internal static string GetECDsaSigningAlgorithmValue(IdentityServerConstants.ECDsaSigningAlgorithm value)
    {
        return value switch
        {
            IdentityServerConstants.ECDsaSigningAlgorithm.ES256 => SecurityAlgorithms.EcdsaSha256,
            IdentityServerConstants.ECDsaSigningAlgorithm.ES384 => SecurityAlgorithms.EcdsaSha384,
            IdentityServerConstants.ECDsaSigningAlgorithm.ES512 => SecurityAlgorithms.EcdsaSha512,
            _ => throw new ArgumentException("Invalid ECDsa signing algorithm value", nameof(value)),
        };
    }

    internal static X509Certificate2 FindCertificate(string name, StoreLocation location, NameType nameType)
    {
        X509Certificate2 certificate = null;

        if (location == StoreLocation.LocalMachine)
        {
            if (nameType == NameType.SubjectDistinguishedName)
            {
                certificate = X509.LocalMachine.My.SubjectDistinguishedName.Find(name, validOnly: false).FirstOrDefault();
            }
            else if (nameType == NameType.Thumbprint)
            {
                certificate = X509.LocalMachine.My.Thumbprint.Find(name, validOnly: false).FirstOrDefault();
            }
        }
        else
        {
            if (nameType == NameType.SubjectDistinguishedName)
            {
                certificate = X509.CurrentUser.My.SubjectDistinguishedName.Find(name, validOnly: false).FirstOrDefault();
            }
            else if (nameType == NameType.Thumbprint)
            {
                certificate = X509.CurrentUser.My.Thumbprint.Find(name, validOnly: false).FirstOrDefault();
            }
        }

        return certificate;
    }
}

/// 
/// Describes the string so we know what to search for in certificate store
/// 
public enum NameType
{
    /// 
    /// subject distinguished name
    /// 
    SubjectDistinguishedName,

    /// 
    /// thumbprint
    /// 
    Thumbprint
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/BuilderExtensions/Additional.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Builder extension methods for registering additional services 
/// 
public static class IdentityServerBuilderExtensionsAdditional
{
    /// 
    /// Adds the extension grant validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddExtensionGrantValidator(this IIdentityServerBuilder builder)
        where T : class, IExtensionGrantValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a redirect URI validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddRedirectUriValidator(this IIdentityServerBuilder builder)
        where T : class, IRedirectUriValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a an "AppAuth" (OAuth 2.0 for Native Apps) compliant redirect URI validator (does strict validation but also allows http://127.0.0.1 with random port)
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddAppAuthRedirectUriValidator(this IIdentityServerBuilder builder)
    {
        return builder.AddRedirectUriValidator();
    }

    /// 
    /// Adds the resource owner validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddResourceOwnerValidator(this IIdentityServerBuilder builder)
       where T : class, IResourceOwnerPasswordValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the profile service.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddProfileService(this IIdentityServerBuilder builder)
       where T : class, IProfileService
    {
        builder.Services.AddTransient();

        return builder;
    }
    
    /// 
    /// Adds a resource validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddResourceValidator(this IIdentityServerBuilder builder)
        where T : class, IResourceValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a scope parser.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddScopeParser(this IIdentityServerBuilder builder)
        where T : class, IScopeParser
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a client store.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddClientStore(this IIdentityServerBuilder builder)
       where T : class, IClientStore
    {
        builder.Services.TryAddTransient(typeof(T));
        builder.Services.AddTransient>();

        return builder;
    }

    /// 
    /// Adds a resource store.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddResourceStore(this IIdentityServerBuilder builder)
       where T : class, IResourceStore
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a device flow store.
    /// 
    /// 
    /// The builder.
    public static IIdentityServerBuilder AddDeviceFlowStore(this IIdentityServerBuilder builder)
        where T : class, IDeviceFlowStore
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a persisted grant store.
    /// 
    /// The type of the concrete grant store that is registered in DI.
    /// The builder.
    /// The builder.
    public static IIdentityServerBuilder AddPersistedGrantStore(this IIdentityServerBuilder builder)
        where T : class, IPersistedGrantStore
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a CORS policy service.
    /// 
    /// The type of the concrete scope store class that is registered in DI.
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCorsPolicyService(this IIdentityServerBuilder builder)
        where T : class, ICorsPolicyService
    {
        builder.Services.AddTransient();
        return builder;
    }

    /// 
    /// Adds a CORS policy service cache.
    /// 
    /// The type of the concrete CORS policy service that is registered in DI.
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCorsPolicyCache(this IIdentityServerBuilder builder)
        where T : class, ICorsPolicyService
    {
        builder.Services.TryAddTransient(typeof(T));
        builder.Services.AddTransient>();
        return builder;
    }

    /// 
    /// Adds the secret parser.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddSecretParser(this IIdentityServerBuilder builder)
        where T : class, ISecretParser
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the secret validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddSecretValidator(this IIdentityServerBuilder builder)
        where T : class, ISecretValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the client store cache.
    /// 
    /// The type of the concrete client store class that is registered in DI.
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddClientStoreCache(this IIdentityServerBuilder builder)
        where T : IClientStore
    {
        builder.Services.TryAddTransient(typeof(T));
        builder.Services.AddTransient>();
        builder.Services.AddTransient>>();

        return builder;
    }

    /// 
    /// Adds the client store cache.
    /// 
    /// The type of the concrete scope store class that is registered in DI.
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddResourceStoreCache(this IIdentityServerBuilder builder)
        where T : IResourceStore
    {
        builder.Services.TryAddTransient(typeof(T));
        builder.Services.AddTransient>();
        return builder;
    }

    /// 
    /// Adds the authorize interaction response generator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddAuthorizeInteractionResponseGenerator(this IIdentityServerBuilder builder)
        where T : class, IAuthorizeInteractionResponseGenerator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the custom authorize request validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCustomAuthorizeRequestValidator(this IIdentityServerBuilder builder)
       where T : class, ICustomAuthorizeRequestValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the custom authorize request validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCustomTokenRequestValidator(this IIdentityServerBuilder builder)
       where T : class, ICustomTokenRequestValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds support for client authentication using JWT bearer assertions.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddJwtBearerClientAuthentication(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddTransient();
        builder.AddSecretParser();
        builder.AddSecretValidator();

        return builder;
    }

    /// 
    /// Adds a client configuration validator.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddClientConfigurationValidator(this IIdentityServerBuilder builder)
        where T : class, IClientConfigurationValidator
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the X509 secret validators for mutual TLS.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddMutualTlsSecretValidators(this IIdentityServerBuilder builder)
    {
        builder.AddSecretParser();
        builder.AddSecretValidator();
        builder.AddSecretValidator();

        return builder;
    }

    /// 
    /// Adds a custom back-channel logout service.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddBackChannelLogoutService(this IIdentityServerBuilder builder)
        where T : class, IBackChannelLogoutService
    {
        builder.Services.AddTransient();

        return builder;
    }

    // todo: check with later previews of ASP.NET Core if this is still required
    /// 
    /// Adds configuration for the HttpClient used for back-channel logout notifications.
    /// 
    /// The builder.
    /// The configruation callback.
    /// 
    public static IHttpClientBuilder AddBackChannelLogoutHttpClient(this IIdentityServerBuilder builder, Action configureClient = null)
    {
        const string name = IdentityServerConstants.HttpClients.BackChannelLogoutHttpClient;
        IHttpClientBuilder httpBuilder;

        if (configureClient != null)
        {
            httpBuilder = builder.Services.AddHttpClient(name, configureClient);
        }
        else
        {
            httpBuilder = builder.Services.AddHttpClient(name)
                .ConfigureHttpClient(client => {
                    client.Timeout = TimeSpan.FromSeconds(IdentityServerConstants.HttpClients.DefaultTimeoutSeconds);
                });
        }

        builder.Services.AddTransient(s =>
        {
            var httpClientFactory = s.GetRequiredService();
            var httpClient = httpClientFactory.CreateClient(name);
            var loggerFactory = s.GetRequiredService();
            
            return new DefaultBackChannelLogoutHttpClient(httpClient, loggerFactory);
        });

        return httpBuilder;
    }


    // todo: check with later previews of ASP.NET Core if this is still required
    /// 
    /// Adds configuration for the HttpClient used for JWT request_uri requests.
    /// 
    /// The builder.
    /// The configruation callback.
    /// 
    public static IHttpClientBuilder AddJwtRequestUriHttpClient(this IIdentityServerBuilder builder, Action configureClient = null)
    {
        const string name = IdentityServerConstants.HttpClients.JwtRequestUriHttpClient;
        IHttpClientBuilder httpBuilder;

        if (configureClient != null)
        {
            httpBuilder = builder.Services.AddHttpClient(name, configureClient);
        }
        else
        {
            httpBuilder = builder.Services.AddHttpClient(name)
                .ConfigureHttpClient(client => {
                    client.Timeout = TimeSpan.FromSeconds(IdentityServerConstants.HttpClients.DefaultTimeoutSeconds);
                });
        }
        
        builder.Services.AddTransient(s =>
        {
            var httpClientFactory = s.GetRequiredService();
            var httpClient = httpClientFactory.CreateClient(name);
            var loggerFactory = s.GetRequiredService();
            var options = s.GetRequiredService();

            return new DefaultJwtRequestUriHttpClient(httpClient, options, loggerFactory);
        });

        return httpBuilder;
    }

    /// 
    /// Adds a custom authorization request parameter store.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddAuthorizationParametersMessageStore(this IIdentityServerBuilder builder)
        where T : class, IAuthorizationParametersMessageStore
    {
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds a custom user session.
    /// 
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddUserSession(this IIdentityServerBuilder builder)
        where T : class, IUserSession
    {
        // This is added as scoped due to the note regarding the AuthenticateAsync
        // method in the IdentityServer8.Services.DefaultUserSession implementation.
        builder.Services.AddScoped();

        return builder;
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/BuilderExtensions/Core.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Builder extension methods for registering core services
/// 
public static class IdentityServerBuilderExtensionsCore
{
    /// 
    /// Adds the required platform services.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddRequiredPlatformServices(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddSingleton();            
        builder.Services.AddOptions();
        builder.Services.AddSingleton(
            resolver => resolver.GetRequiredService>().Value);
        builder.Services.AddHttpClient();

        return builder;
    }

    /// 
    /// Adds the default cookie handlers and corresponding configuration
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCookieAuthentication(this IIdentityServerBuilder builder)
    {
        builder.Services.AddAuthentication(IdentityServerConstants.DefaultCookieAuthenticationScheme)
            .AddCookie(IdentityServerConstants.DefaultCookieAuthenticationScheme)
            .AddCookie(IdentityServerConstants.ExternalCookieAuthenticationScheme);

        builder.Services.AddSingleton, ConfigureInternalCookieOptions>();
        builder.Services.AddSingleton, PostConfigureInternalCookieOptions>();
        builder.Services.AddTransientDecorator();
        builder.Services.AddTransientDecorator();

        return builder;
    }

    /// 
    /// Adds the default endpoints.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddDefaultEndpoints(this IIdentityServerBuilder builder)
    {
        builder.Services.AddTransient();

        builder.AddEndpoint(EndpointNames.Authorize, ProtocolRoutePaths.AuthorizeCallback.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Authorize, ProtocolRoutePaths.Authorize.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.CheckSession, ProtocolRoutePaths.CheckSession.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.DeviceAuthorization, ProtocolRoutePaths.DeviceAuthorization.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Discovery, ProtocolRoutePaths.DiscoveryWebKeys.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Discovery, ProtocolRoutePaths.DiscoveryConfiguration.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.EndSession, ProtocolRoutePaths.EndSessionCallback.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.EndSession, ProtocolRoutePaths.EndSession.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Introspection, ProtocolRoutePaths.Introspection.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Revocation, ProtocolRoutePaths.Revocation.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.Token, ProtocolRoutePaths.Token.EnsureLeadingSlash());
        builder.AddEndpoint(EndpointNames.UserInfo, ProtocolRoutePaths.UserInfo.EnsureLeadingSlash());

        return builder;
    }

    /// 
    /// Adds the endpoint.
    /// 
    /// 
    /// The builder.
    /// The name.
    /// The path.
    /// 
    public static IIdentityServerBuilder AddEndpoint(this IIdentityServerBuilder builder, string name, PathString path)
        where T : class, IEndpointHandler
    {
        builder.Services.AddTransient();
        builder.Services.AddSingleton(new IdentityServer8.Hosting.Endpoint(name, path, typeof(T)));

        return builder;
    }

    /// 
    /// Adds the core services.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddCoreServices(this IIdentityServerBuilder builder)
    {
        builder.Services.AddTransient();
        builder.Services.AddTransient();
        builder.Services.AddTransient();
        builder.Services.AddTransient();
        builder.Services.AddTransient();

        builder.Services.AddTransient();
        builder.Services.AddTransient();

        builder.Services.AddTransient();
        builder.Services.AddScoped();
        builder.Services.AddTransient(typeof(MessageCookie<>));

        builder.Services.AddCors();
        builder.Services.AddTransientDecorator();

        return builder;
    }

    /// 
    /// Adds the pluggable services.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddPluggableServices(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient, ProtectedDataMessageStore>();
        builder.Services.TryAddTransient, ProtectedDataMessageStore>();
        builder.Services.TryAddTransient, ProtectedDataMessageStore>();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();

        builder.AddJwtRequestUriHttpClient();
        builder.AddBackChannelLogoutHttpClient();

        builder.Services.AddTransient();
        builder.Services.AddTransient();

        builder.Services.TryAddTransient();
        builder.Services.AddDistributedMemoryCache();

        return builder;
    }

    /// 
    /// Adds the validators.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddValidators(this IIdentityServerBuilder builder)
    {
        // core
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();

        // optional
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        
        return builder;
    }

    /// 
    /// Adds the response generators.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddResponseGenerators(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();
        builder.Services.TryAddTransient();

        return builder;
    }

    /// 
    /// Adds the default secret parsers.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddDefaultSecretParsers(this IIdentityServerBuilder builder)
    {
        builder.Services.AddTransient();
        builder.Services.AddTransient();

        return builder;
    }

    /// 
    /// Adds the default secret validators.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddDefaultSecretValidators(this IIdentityServerBuilder builder)
    {
        builder.Services.AddTransient();

        return builder;
    }

    internal static void AddTransientDecorator(this IServiceCollection services)
        where TService : class
        where TImplementation : class, TService
    {
        services.AddDecorator();
        services.AddTransient();
    }

    internal static void AddDecorator(this IServiceCollection services)
    {
        var registration = services.LastOrDefault(x => x.ServiceType == typeof(TService));
        if (registration == null)
        {
            throw new InvalidOperationException("Service type: " + typeof(TService).Name + " not registered.");
        }
        if (services.Any(x => x.ServiceType == typeof(Decorator)))
        {
            throw new InvalidOperationException("Decorator already registered for type: " + typeof(TService).Name + ".");
        }

        services.Remove(registration);

        if (registration.ImplementationInstance != null)
        {
            var type = registration.ImplementationInstance.GetType();
            var innerType = typeof(Decorator<,>).MakeGenericType(typeof(TService), type);
            services.Add(new ServiceDescriptor(typeof(Decorator), innerType, ServiceLifetime.Transient));
            services.Add(new ServiceDescriptor(type, registration.ImplementationInstance));
        }
        else if (registration.ImplementationFactory != null)
        {
            services.Add(new ServiceDescriptor(typeof(Decorator), provider =>
            {
                return new DisposableDecorator((TService)registration.ImplementationFactory(provider));
            }, registration.Lifetime));
        }
        else
        {
            var type = registration.ImplementationType;
            var innerType = typeof(Decorator<,>).MakeGenericType(typeof(TService), registration.ImplementationType);
            services.Add(new ServiceDescriptor(typeof(Decorator), innerType, ServiceLifetime.Transient));
            services.Add(new ServiceDescriptor(type, type, registration.Lifetime));
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/BuilderExtensions/Crypto.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;
using JsonWebKey = Microsoft.IdentityModel.Tokens.JsonWebKey;

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Builder extension methods for registering crypto services
/// 
public static class IdentityServerBuilderExtensionsCrypto
{
    /// 
    /// Sets the signing credential.
    /// 
    /// The builder.
    /// The credential.
    /// 
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder, SigningCredentials credential)
    {
        if (!(credential.Key is AsymmetricSecurityKey
            || credential.Key is IdentityModel.Tokens.JsonWebKey && ((IdentityModel.Tokens.JsonWebKey)credential.Key).HasPrivateKey))
        {
            throw new InvalidOperationException("Signing key is not asymmetric");
        }

        if (!IdentityServerConstants.SupportedSigningAlgorithms.Contains(credential.Algorithm, StringComparer.Ordinal))
        {
            throw new InvalidOperationException($"Signing algorithm {credential.Algorithm} is not supported.");
        }

        if (credential.Key is ECDsaSecurityKey key && !CryptoHelper.IsValidCurveForAlgorithm(key, credential.Algorithm))
        {
            throw new InvalidOperationException("Invalid curve for signing algorithm");
        }

        if (credential.Key is IdentityModel.Tokens.JsonWebKey jsonWebKey)
        {
            if (jsonWebKey.Kty == JsonWebAlgorithmsKeyTypes.EllipticCurve && !CryptoHelper.IsValidCrvValueForAlgorithm(jsonWebKey.Crv))
                throw new InvalidOperationException("Invalid crv value for signing algorithm");
        }

        builder.Services.AddSingleton(new InMemorySigningCredentialsStore(credential));

        var keyInfo = new SecurityKeyInfo
        {
            Key = credential.Key,
            SigningAlgorithm = credential.Algorithm
        };

        builder.Services.AddSingleton(new InMemoryValidationKeysStore(new[] { keyInfo }));

        return builder;
    }

    /// 
    /// Sets the signing credential.
    /// 
    /// The builder.
    /// The certificate.
    /// The signing algorithm (defaults to RS256)
    /// 
    /// 
    /// X509 certificate does not have a private key.
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder, X509Certificate2 certificate, string signingAlgorithm = SecurityAlgorithms.RsaSha256)
    {
        if (certificate == null) throw new ArgumentNullException(nameof(certificate));

        if (!certificate.HasPrivateKey)
        {
            throw new InvalidOperationException("X509 certificate does not have a private key.");
        }

        // add signing algorithm name to key ID to allow using the same key for two different algorithms (e.g. RS256 and PS56);
        var key = new X509SecurityKey(certificate);
        key.KeyId += signingAlgorithm;

        var credential = new SigningCredentials(key, signingAlgorithm);
        return builder.AddSigningCredential(credential);
    }

    /// 
    /// Sets the signing credential.
    /// 
    /// The builder.
    /// The name.
    /// The location.
    /// Name parameter can be either a distinguished name or a thumbprint
    /// The signing algorithm (defaults to RS256)
    /// certificate: '{name}'
    public static IIdentityServerBuilder AddSigningCredential(
        this IIdentityServerBuilder builder,
        string name,
        StoreLocation location = StoreLocation.LocalMachine,
        NameType nameType = NameType.SubjectDistinguishedName,
        string signingAlgorithm = SecurityAlgorithms.RsaSha256)
    {
        var certificate = CryptoHelper.FindCertificate(name, location, nameType);
        if (certificate == null) throw new InvalidOperationException($"certificate: '{name}' not found in certificate store");

        return builder.AddSigningCredential(certificate, signingAlgorithm);
    }

    /// 
    /// Sets the signing credential.
    /// 
    /// The builder.
    /// The key.
    /// The signing algorithm
    /// 
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder, SecurityKey key, string signingAlgorithm)
    {
        var credential = new SigningCredentials(key, signingAlgorithm);
        return builder.AddSigningCredential(credential);
    }

    /// 
    /// Sets an RSA-based signing credential.
    /// 
    /// The builder.
    /// The RSA key.
    /// The signing algorithm
    /// 
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder, RsaSecurityKey key, IdentityServerConstants.RsaSigningAlgorithm signingAlgorithm)
    {
        var credential = new SigningCredentials(key, CryptoHelper.GetRsaSigningAlgorithmValue(signingAlgorithm));
        return builder.AddSigningCredential(credential);
    }

    /// 
    /// Sets an ECDsa-based signing credential.
    /// 
    /// The builder.
    /// The ECDsa key.
    /// The signing algorithm
    /// 
    public static IIdentityServerBuilder AddSigningCredential(this IIdentityServerBuilder builder, ECDsaSecurityKey key, IdentityServerConstants.ECDsaSigningAlgorithm signingAlgorithm)
    {
        var credential = new SigningCredentials(key, CryptoHelper.GetECDsaSigningAlgorithmValue(signingAlgorithm));
        return builder.AddSigningCredential(credential);
    }

    /// 
    /// Sets the temporary signing credential.
    /// 
    /// The builder.
    /// Specifies if the temporary key should be persisted to disk.
    /// The filename.
    /// The signing algorithm (defaults to RS256)
    /// 
    public static IIdentityServerBuilder AddDeveloperSigningCredential(
        this IIdentityServerBuilder builder,
        bool persistKey = true,
        string filename = null,
        IdentityServerConstants.RsaSigningAlgorithm signingAlgorithm = IdentityServerConstants.RsaSigningAlgorithm.RS256)
    {
        if (filename == null)
        {
            filename = Path.Combine(Directory.GetCurrentDirectory(), "tempkey.jwk");
        }

        if (File.Exists(filename))
        {
            var json = File.ReadAllText(filename);
            var jwk = new JsonWebKey(json);

            return builder.AddSigningCredential(jwk, jwk.Alg);
        }
        else
        {
            var key = CryptoHelper.CreateRsaSecurityKey();
            var jwk = JsonWebKeyConverter.ConvertFromRSASecurityKey(key);
            jwk.Alg = signingAlgorithm.ToString();

            if (persistKey)
            {
                File.WriteAllText(filename, JsonConvert.SerializeObject(jwk));
            }

            return builder.AddSigningCredential(key, signingAlgorithm);
        }
    }

    /// 
    /// Adds the validation keys.
    /// 
    /// The builder.
    /// The keys.
    /// 
    public static IIdentityServerBuilder AddValidationKey(this IIdentityServerBuilder builder, params SecurityKeyInfo[] keys)
    {
        builder.Services.AddSingleton(new InMemoryValidationKeysStore(keys));

        return builder;
    }

    /// 
    /// Adds an RSA-based validation key.
    /// 
    /// The builder.
    /// The RSA key
    /// The RSA-based signing algorithm
    /// 
    public static IIdentityServerBuilder AddValidationKey(
        this IIdentityServerBuilder builder,
        RsaSecurityKey key,
        IdentityServerConstants.RsaSigningAlgorithm signingAlgorithm = IdentityServerConstants.RsaSigningAlgorithm.RS256)
    {
        var keyInfo = new SecurityKeyInfo
        {
            Key = key,
            SigningAlgorithm = CryptoHelper.GetRsaSigningAlgorithmValue(signingAlgorithm)
        };

        return builder.AddValidationKey(keyInfo);
    }

    /// 
    /// Adds an ECDSA-based validation key.
    /// 
    /// The builder.
    /// The ECDSA key
    /// The ECDSA-based signing algorithm
    /// 
    public static IIdentityServerBuilder AddValidationKey(
        this IIdentityServerBuilder builder,
        ECDsaSecurityKey key,
        IdentityServerConstants.ECDsaSigningAlgorithm signingAlgorithm = IdentityServerConstants.ECDsaSigningAlgorithm.ES256)
    {
        var keyInfo = new SecurityKeyInfo
        {
            Key = key,
            SigningAlgorithm = CryptoHelper.GetECDsaSigningAlgorithmValue(signingAlgorithm)
        };

        return builder.AddValidationKey(keyInfo);
    }

    /// 
    /// Adds the validation key.
    /// 
    /// The builder.
    /// The certificate.
    /// The signing algorithm
    /// 
    /// 
    public static IIdentityServerBuilder AddValidationKey(
        this IIdentityServerBuilder builder,
        X509Certificate2 certificate,
        string signingAlgorithm = SecurityAlgorithms.RsaSha256)
    {
        if (certificate == null) throw new ArgumentNullException(nameof(certificate));

        // add signing algorithm name to key ID to allow using the same key for two different algorithms (e.g. RS256 and PS56);
        var key = new X509SecurityKey(certificate);
        key.KeyId += signingAlgorithm;
        
        var keyInfo = new SecurityKeyInfo
        {
            Key = key,
            SigningAlgorithm = signingAlgorithm
        };

        return builder.AddValidationKey(keyInfo);
    }

    /// 
    /// Adds the validation key from the certificate store.
    /// 
    /// The builder.
    /// The name.
    /// The location.
    /// Name parameter can be either a distinguished name or a thumbprint
    /// The signing algorithm
    public static IIdentityServerBuilder AddValidationKey(
        this IIdentityServerBuilder builder,
        string name,
        StoreLocation location = StoreLocation.LocalMachine,
        NameType nameType = NameType.SubjectDistinguishedName,
        string signingAlgorithm = SecurityAlgorithms.RsaSha256)
    {
        var certificate = CryptoHelper.FindCertificate(name, location, nameType);
        if (certificate == null) throw new InvalidOperationException($"certificate: '{name}' not found in certificate store");

        return builder.AddValidationKey(certificate, signingAlgorithm);
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/BuilderExtensions/InMemory.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Builder extension methods for registering in-memory services
/// 
public static class IdentityServerBuilderExtensionsInMemory
{
    /// 
    /// Adds the in memory caching.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddInMemoryCaching(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddSingleton();
        builder.Services.TryAddTransient(typeof(ICache<>), typeof(DefaultCache<>));

        return builder;
    }

    /// 
    /// Adds the in memory identity resources.
    /// 
    /// The builder.
    /// The identity resources.
    /// 
    public static IIdentityServerBuilder AddInMemoryIdentityResources(this IIdentityServerBuilder builder, IEnumerable identityResources)
    {
        builder.Services.AddSingleton(identityResources);
        builder.AddResourceStore();

        return builder;
    }

    /// 
    /// Adds the in memory identity resources.
    /// 
    /// The builder.
    /// The configuration section containing the configuration data.
    /// 
    public static IIdentityServerBuilder AddInMemoryIdentityResources(this IIdentityServerBuilder builder, IConfigurationSection section)
    {
        var resources = new List();
        section.Bind(resources);

        return builder.AddInMemoryIdentityResources(resources);
    }

    /// 
    /// Adds the in memory API resources.
    /// 
    /// The builder.
    /// The API resources.
    /// 
    public static IIdentityServerBuilder AddInMemoryApiResources(this IIdentityServerBuilder builder, IEnumerable apiResources)
    {
        builder.Services.AddSingleton(apiResources);
        builder.AddResourceStore();

        return builder;
    }
    
    /// 
    /// Adds the in memory API resources.
    /// 
    /// The builder.
    /// The configuration section containing the configuration data.
    /// 
    public static IIdentityServerBuilder AddInMemoryApiResources(this IIdentityServerBuilder builder, IConfigurationSection section)
    {
        var resources = new List();
        section.Bind(resources);

        return builder.AddInMemoryApiResources(resources);
    }

    /// 
    /// Adds the in memory API scopes.
    /// 
    /// The builder.
    /// The API scopes.
    /// 
    public static IIdentityServerBuilder AddInMemoryApiScopes(this IIdentityServerBuilder builder, IEnumerable apiScopes)
    {
        builder.Services.AddSingleton(apiScopes);
        builder.AddResourceStore();

        return builder;
    }

    /// 
    /// Adds the in memory scopes.
    /// 
    /// The builder.
    /// The configuration section containing the configuration data.
    /// 
    public static IIdentityServerBuilder AddInMemoryApiScopes(this IIdentityServerBuilder builder, IConfigurationSection section)
    {
        var resources = new List();
        section.Bind(resources);

        return builder.AddInMemoryApiScopes(resources);
    }

    /// 
    /// Adds the in memory clients.
    /// 
    /// The builder.
    /// The clients.
    /// 
    public static IIdentityServerBuilder AddInMemoryClients(this IIdentityServerBuilder builder, IEnumerable clients)
    {
        builder.Services.AddSingleton(clients);

        builder.AddClientStore();

        var existingCors = builder.Services.Where(x => x.ServiceType == typeof(ICorsPolicyService)).LastOrDefault();
        if (existingCors != null && 
            existingCors.ImplementationType == typeof(DefaultCorsPolicyService) && 
            existingCors.Lifetime == ServiceLifetime.Transient)
        {
            // if our default is registered, then overwrite with the InMemoryCorsPolicyService
            // otherwise don't overwrite with the InMemoryCorsPolicyService, which uses the custom one registered by the host
            builder.Services.AddTransient();
        }

        return builder;
    }


    /// 
    /// Adds the in memory clients.
    /// 
    /// The builder.
    /// The configuration section containing the configuration data.
    /// 
    public static IIdentityServerBuilder AddInMemoryClients(this IIdentityServerBuilder builder, IConfigurationSection section)
    {
        var clients = new List();
        section.Bind(clients);

        return builder.AddInMemoryClients(clients);
    }


    /// 
    /// Adds the in memory stores.
    /// 
    /// The builder.
    /// 
    public static IIdentityServerBuilder AddInMemoryPersistedGrants(this IIdentityServerBuilder builder)
    {
        builder.Services.TryAddSingleton();
        builder.Services.TryAddSingleton();

        return builder;
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/ConfigureInternalCookieOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

internal class ConfigureInternalCookieOptions : IConfigureNamedOptions
{
    private readonly IdentityServerOptions _idsrv;

    public ConfigureInternalCookieOptions(IdentityServerOptions idsrv)
    {
        _idsrv = idsrv;
    }

    public void Configure(CookieAuthenticationOptions options)
    {
    }

    public void Configure(string name, CookieAuthenticationOptions options)
    {
        if (name == IdentityServerConstants.DefaultCookieAuthenticationScheme)
        {
            options.SlidingExpiration = _idsrv.Authentication.CookieSlidingExpiration;
            options.ExpireTimeSpan = _idsrv.Authentication.CookieLifetime;
            options.Cookie.Name = IdentityServerConstants.DefaultCookieAuthenticationScheme;
            options.Cookie.IsEssential = true;
            options.Cookie.SameSite = _idsrv.Authentication.CookieSameSiteMode;

            options.LoginPath = ExtractLocalUrl(_idsrv.UserInteraction.LoginUrl);
            options.LogoutPath = ExtractLocalUrl(_idsrv.UserInteraction.LogoutUrl);
            if (_idsrv.UserInteraction.LoginReturnUrlParameter != null)
            {
                options.ReturnUrlParameter = _idsrv.UserInteraction.LoginReturnUrlParameter;
            }
        }

        if (name == IdentityServerConstants.ExternalCookieAuthenticationScheme)
        {
            options.Cookie.Name = IdentityServerConstants.ExternalCookieAuthenticationScheme;
            options.Cookie.IsEssential = true;
            // https://github.com/alexhiggins732/IdentityServer8/issues/2595
            // need to set None because iOS 12 safari considers the POST back to the client from the 
            // IdP as not safe, so cookies issued from response (with lax) then should not be honored.
            // so we need to make those cookies issued without same-site, thus the browser will
            // hold onto them and send on the next redirect to the callback page.
            // see: https://brockallen.com/2019/01/11/same-site-cookies-asp-net-core-and-external-authentication-providers/
            options.Cookie.SameSite = _idsrv.Authentication.CookieSameSiteMode;
        }
    }

    private static string ExtractLocalUrl(string url)
    {
        if (url.IsLocalUrl())
        {
            if (url.StartsWith("~/"))
            {
                url = url.Substring(1);
            }

            return url;
        }

        return null;
    }
}

internal class PostConfigureInternalCookieOptions : IPostConfigureOptions
{
    private readonly IdentityServerOptions _idsrv;
    private readonly IOptions _authOptions;
    private readonly ILogger _logger;

    public PostConfigureInternalCookieOptions(
        IdentityServerOptions idsrv,
        IOptions authOptions,
        ILoggerFactory loggerFactory)
    {
        _idsrv = idsrv;
        _authOptions = authOptions;
        _logger = loggerFactory.CreateLogger("IdentityServer8.Startup");
    }

    public void PostConfigure(string name, CookieAuthenticationOptions options)
    {
        var scheme = _idsrv.Authentication.CookieAuthenticationScheme ??
            _authOptions.Value.DefaultAuthenticateScheme ??
            _authOptions.Value.DefaultScheme;

        if (name == scheme)
        {
            _idsrv.UserInteraction.LoginUrl = _idsrv.UserInteraction.LoginUrl ?? options.LoginPath;
            _idsrv.UserInteraction.LoginReturnUrlParameter = _idsrv.UserInteraction.LoginReturnUrlParameter ?? options.ReturnUrlParameter;
            _idsrv.UserInteraction.LogoutUrl = _idsrv.UserInteraction.LogoutUrl ?? options.LogoutPath;

            _logger.LogDebug("Login Url: {url}", _idsrv.UserInteraction.LoginUrl);
            _logger.LogDebug("Login Return Url Parameter: {param}", _idsrv.UserInteraction.LoginReturnUrlParameter);
            _logger.LogDebug("Logout Url: {url}", _idsrv.UserInteraction.LogoutUrl);

            _logger.LogDebug("ConsentUrl Url: {url}", _idsrv.UserInteraction.ConsentUrl);
            _logger.LogDebug("Consent Return Url Parameter: {param}", _idsrv.UserInteraction.ConsentReturnUrlParameter);

            _logger.LogDebug("Error Url: {url}", _idsrv.UserInteraction.ErrorUrl);
            _logger.LogDebug("Error Id Parameter: {param}", _idsrv.UserInteraction.ErrorIdParameter);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/ConfigureOpenIdConnectOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

internal class ConfigureOpenIdConnectOptions : IPostConfigureOptions
{
    private string[] _schemes;
    private readonly IHttpContextAccessor _httpContextAccessor;

    public ConfigureOpenIdConnectOptions(string[] schemes, IHttpContextAccessor httpContextAccessor)
    {
        _schemes = schemes ?? throw new ArgumentNullException(nameof(schemes));
        _httpContextAccessor = httpContextAccessor ?? throw new ArgumentNullException(nameof(httpContextAccessor));
    }

    public void PostConfigure(string name, OpenIdConnectOptions options)
    {
        // no schemes means configure them all
        if (_schemes.Length == 0 || _schemes.Contains(name))
        {
            options.StateDataFormat = new DistributedCacheStateDataFormatter(_httpContextAccessor, name);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Decorator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration.DependencyInjection;

internal class Decorator
{
    public TService Instance { get; set; }

    public Decorator(TService instance)
    {
        Instance = instance;
    }
}

internal class Decorator : Decorator
    where TImpl : class, TService
{
    public Decorator(TImpl instance) : base(instance)
    {
    }
}

internal class DisposableDecorator : Decorator, IDisposable
{
    public DisposableDecorator(TService instance) : base(instance)
    {
    }

    public void Dispose()
    {
        (Instance as IDisposable)?.Dispose();
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/IIdentityServerBuilder.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// IdentityServer builder Interface
/// 
public interface IIdentityServerBuilder
{
    /// 
    /// Gets the services.
    /// 
    /// 
    /// The services.
    /// 
    IServiceCollection Services { get; }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/IdentityServerBuilder.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// IdentityServer helper class for DI configuration
/// 
public class IdentityServerBuilder : IIdentityServerBuilder
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The services.
    /// services
    public IdentityServerBuilder(IServiceCollection services)
    {
        Services = services ?? throw new ArgumentNullException(nameof(services));
    }

    /// 
    /// Gets the services.
    /// 
    /// 
    /// The services.
    /// 
    public IServiceCollection Services { get; }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/IdentityServerServiceCollectionExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// DI extension methods for adding IdentityServer
/// 
public static class IdentityServerServiceCollectionExtensions
{
    /// 
    /// Creates a builder.
    /// 
    /// The services.
    /// 
    public static IIdentityServerBuilder AddIdentityServerBuilder(this IServiceCollection services)
    {
        return new IdentityServerBuilder(services);
    }

    /// 
    /// Adds IdentityServer.
    /// 
    /// The services.
    /// 
    public static IIdentityServerBuilder AddIdentityServer(this IServiceCollection services)
    {
        var builder = services.AddIdentityServerBuilder();

        builder
            .AddRequiredPlatformServices()
            .AddCookieAuthentication()
            .AddCoreServices()
            .AddDefaultEndpoints()
            .AddPluggableServices()
            .AddValidators()
            .AddResponseGenerators()
            .AddDefaultSecretParsers()
            .AddDefaultSecretValidators();

        // provide default in-memory implementation, not suitable for most production scenarios
        builder.AddInMemoryPersistedGrants();

        return builder;
    }

    /// 
    /// Adds IdentityServer.
    /// 
    /// The services.
    /// The setup action.
    /// 
    public static IIdentityServerBuilder AddIdentityServer(this IServiceCollection services, Action setupAction)
    {
        services.Configure(setupAction);
        return services.AddIdentityServer();
    }

    /// 
    /// Adds the IdentityServer.
    /// 
    /// The services.
    /// The configuration.
    /// 
    public static IIdentityServerBuilder AddIdentityServer(this IServiceCollection services, IConfiguration configuration)
    {
        services.Configure(configuration);
        return services.AddIdentityServer();
    }

    /// 
    /// Configures the OpenIdConnect handlers to persist the state parameter into the server-side IDistributedCache.
    /// 
    /// The services.
    /// The schemes to configure. If none provided, then all OpenIdConnect schemes will use the cache.
    public static IServiceCollection AddOidcStateDataFormatterCache(this IServiceCollection services, params string[] schemes)
    {
        services.AddSingleton>(
            svcs => new ConfigureOpenIdConnectOptions(
                schemes,
                svcs.GetRequiredService())
        );

        return services;
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/AuthenticationOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Configures the login and logout views and behavior.
/// 
public class AuthenticationOptions
{
    /// 
    /// Sets the cookie authentication scheme configured by the host used for interactive users. If not set, the scheme will inferred from the host's default authentication scheme.
    /// This setting is typically used when AddPolicyScheme is used in the host as the default scheme.
    /// 
    public string CookieAuthenticationScheme { get; set; }

    /// 
    /// Sets the cookie lifetime (only effective if the IdentityServer-provided cookie handler is used)
    /// 
    public TimeSpan CookieLifetime { get; set; } = Constants.DefaultCookieTimeSpan;

    /// 
    /// Specified if the cookie should be sliding or not (only effective if the built-in cookie middleware is used)
    /// 
    public bool CookieSlidingExpiration { get; set; } = false;
    
    /// 
    /// Specifies the SameSite mode for the internal authentication and temp cookie
    /// 
    public SameSiteMode CookieSameSiteMode { get; set; } = SameSiteMode.None;

    /// 
    /// Indicates if user must be authenticated to accept parameters to end session endpoint. Defaults to false.
    /// 
    /// 
    /// true if required; otherwise, false.
    /// 
    public bool RequireAuthenticatedUserForSignOutMessage { get; set; } = false;

    /// 
    /// Gets or sets the name of the cookie used for the check session endpoint.
    /// 
    public string CheckSessionCookieName { get; set; } = IdentityServerConstants.DefaultCheckSessionCookieName;
    
    /// 
    /// Gets or sets the domain of the cookie used for the check session endpoint. Defaults to null.
    /// 
    public string CheckSessionCookieDomain { get; set; }

    /// 
    /// Gets or sets the SameSite mode of the cookie used for the check session endpoint. Defaults to SameSiteMode.None.
    /// 
    public SameSiteMode CheckSessionCookieSameSiteMode { get; set; } = SameSiteMode.None;

    /// 
    /// If set, will require frame-src CSP headers being emitting on the end session callback endpoint which renders iframes to clients for front-channel signout notification.
    /// 
    public bool RequireCspFrameSrcForSignout { get; set; } = true;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/CachingOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Caching options.
/// 
public class CachingOptions
{
    private static readonly TimeSpan Default = TimeSpan.FromMinutes(15);

    /// 
    /// Gets or sets the client store expiration.
    /// 
    /// 
    /// The client store expiration.
    /// 
    public TimeSpan ClientStoreExpiration { get; set; } = Default;

    /// 
    /// Gets or sets the scope store expiration.
    /// 
    /// 
    /// The scope store expiration.
    /// 
    public TimeSpan ResourceStoreExpiration { get; set; } = Default;

    /// 
    /// Gets or sets the CORS origin expiration.
    /// 
    public TimeSpan CorsExpiration { get; set; } = Default;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/CorsOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options for CORS
/// 
public class CorsOptions
{
    /// 
    /// Gets or sets the name of the cors policy.
    /// 
    /// 
    /// The name of the cors policy.
    /// 
    public string CorsPolicyName { get; set; } = Constants.IdentityServerName;

    /// 
    /// The value to be used in the preflight `Access-Control-Max-Age` response header.
    /// 
    public TimeSpan? PreflightCacheDuration { get; set; }

    /// 
    /// Gets or sets the cors paths.
    /// 
    /// 
    /// The cors paths.
    /// 
    public ICollection CorsPaths { get; set; } = Constants.ProtocolRoutePaths.CorsPaths.Select(x => new PathString(x.EnsureLeadingSlash())).ToList();
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/CspOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options for Content Security Policy
/// 
public class CspOptions
{
    /// 
    /// Gets or sets the minimum CSP level.
    /// 
    public CspLevel Level { get; set; } = CspLevel.Two;

    /// 
    /// Gets or sets a value indicating whether the deprected X-Content-Security-Policy header should be added.
    /// 
    public bool AddDeprecatedHeader { get; set; } = true;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/DeviceFlowOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Configures device flow
/// 
public class DeviceFlowOptions
{
    /// 
    /// Gets or sets the default type of the user code.
    /// 
    /// 
    /// The default type of the user code.
    /// 
    public string DefaultUserCodeType { get; set; } = IdentityServerConstants.UserCodeTypes.Numeric;

    /// 
    /// Gets or sets the polling interval in seconds.
    /// 
    /// 
    /// The interval in seconds.
    /// 
    public int Interval { get; set; } = 5;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/DiscoveryOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options class to configure discovery endpoint
/// 
public class DiscoveryOptions
{
    /// 
    /// Show endpoints
    /// 
    public bool ShowEndpoints { get; set; } = true;

    /// 
    /// Show signing keys
    /// 
    public bool ShowKeySet { get; set; } = true;

    /// 
    /// Show identity scopes
    /// 
    public bool ShowIdentityScopes { get; set; } = true;

    /// 
    /// Show API scopes
    /// 
    public bool ShowApiScopes { get; set; } = true;

    /// 
    /// Show identity claims
    /// 
    public bool ShowClaims { get; set; } = true;

    /// 
    /// Show response types
    /// 
    public bool ShowResponseTypes { get; set; } = true;

    /// 
    /// Show response modes
    /// 
    public bool ShowResponseModes { get; set; } = true;

    /// 
    /// Show standard grant types
    /// 
    public bool ShowGrantTypes { get; set; } = true;

    /// 
    /// Show custom grant types
    /// 
    public bool ShowExtensionGrantTypes { get; set; } = true;

    /// 
    /// Show token endpoint authentication methods
    /// 
    public bool ShowTokenEndpointAuthenticationMethods { get; set; } = true;

    /// 
    /// Turns relative paths that start with ~/ into absolute paths
    /// 
    public bool ExpandRelativePathsInCustomEntries { get; set; } = true;

    /// 
    /// Sets the maxage value of the cache control header (in seconds) of the HTTP response. This gives clients a hint how often they should refresh their cached copy of the discovery document. If set to 0 no-cache headers will be set. Defaults to null, which does not set the header.
    /// 
    /// 
    /// The cache interval in seconds.
    /// 
    public int? ResponseCacheInterval { get; set; } = null;

    /// 
    /// Adds custom entries to the discovery document
    /// 
    public Dictionary CustomEntries { get; set; } = new Dictionary();
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/EndpointOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Configures which endpoints are enabled or disabled.
/// 
public class EndpointsOptions
{
    /// 
    /// Gets or sets a value indicating whether the authorize endpoint is enabled.
    /// 
    /// 
    /// true if the authorize endpoint is enabled; otherwise, false.
    /// 
    public bool EnableAuthorizeEndpoint { get; set; } = true;
    
    /// 
    /// Gets or sets if JWT request_uri processing is enabled on the authorize endpoint. 
    /// 
    public bool EnableJwtRequestUri { get; set; } = false;

    /// 
    /// Gets or sets a value indicating whether the token endpoint is enabled.
    /// 
    /// 
    /// true if the token endpoint is enabled; otherwise, false.
    /// 
    public bool EnableTokenEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the user info endpoint is enabled.
    /// 
    /// 
    /// true if the user info endpoint is enabled; otherwise, false.
    /// 
    public bool EnableUserInfoEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the discovery document endpoint is enabled.
    /// 
    /// 
    /// true if the disdovery document endpoint is enabled; otherwise, false.
    /// 
    public bool EnableDiscoveryEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the end session endpoint is enabled.
    /// 
    /// 
    /// true if the end session endpoint is enabled; otherwise, false.
    /// 
    public bool EnableEndSessionEndpoint { get; set; } = true;
    
    /// 
    /// Gets or sets a value indicating whether the check session endpoint is enabled.
    /// 
    /// 
    /// true if the check session endpoint is enabled; otherwise, false.
    /// 
    public bool EnableCheckSessionEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the token revocation endpoint is enabled.
    /// 
    /// 
    /// true if the token revocation endpoint is enabled; otherwise, false.
    /// 
    public bool EnableTokenRevocationEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the introspection endpoint is enabled.
    /// 
    /// 
    /// true if the introspection endpoint is enabled; otherwise, false.
    /// 
    public bool EnableIntrospectionEndpoint { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether the device authorization endpoint is enabled.
    /// 
    /// 
    /// true if the device authorization endpoint is enabled; otherwise, false.
    /// 
    public bool EnableDeviceAuthorizationEndpoint { get; set; } = true;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/EventsOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Configures events
/// 
public class EventsOptions
{
    /// 
    /// Gets or sets a value indicating whether to raise success events.
    /// 
    /// 
    ///   true if success event should be raised; otherwise, false.
    /// 
    public bool RaiseSuccessEvents { get; set; } = false;

    /// 
    /// Gets or sets a value indicating whether to raise failure events.
    /// 
    /// 
    ///   true if failure events should be raised; otherwise, false.
    /// 
    public bool RaiseFailureEvents { get; set; } = false;

    /// 
    /// Gets or sets a value indicating whether to raise information events.
    /// 
    /// 
    /// true if information events should be raised; otherwise, false.
    /// 
    public bool RaiseInformationEvents { get; set; } = false;

    /// 
    /// Gets or sets a value indicating whether to raise error events.
    /// 
    /// 
    ///   true if error events should be raised; otherwise, false.
    /// 
    public bool RaiseErrorEvents { get; set; } = false;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/IdentityServerOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// The IdentityServerOptions class is the top level container for all configuration settings of IdentityServer.
/// 
public class IdentityServerOptions
{
    /// 
    /// Gets or sets the unique name of this server instance, e.g. https://myissuer.com.
    /// If not set, the issuer name is inferred from the request
    /// 
    /// 
    /// Unique name of this server instance, e.g. https://myissuer.com
    /// 
    public string IssuerUri { get; set; }

    /// 
    /// Set to false to preserve the original casing of the IssuerUri. Defaults to true.
    /// 
    public bool LowerCaseIssuerUri { get; set; } = true;

    /// 
    /// Gets or sets the value for the JWT typ header for access tokens.
    /// 
    /// 
    /// The JWT typ value.
    /// 
    public string AccessTokenJwtType { get; set; } = "at+jwt";

    /// 
    /// Emits an aud claim with the format issuer/resources. That's needed for some older access token validation plumbing. Defaults to false.
    /// 
    public bool EmitStaticAudienceClaim { get; set; } = false;

    /// 
    /// Specifies whether scopes in JWTs are emitted as array or string
    /// 
    public bool EmitScopesAsSpaceDelimitedStringInJwt { get; set; } = false;
    
    /// 
    /// Specifies whether the JWT typ and content-type for JWT secured authorization requests is checked according to IETF spec.
    /// This might break older OIDC conformant request objects.
    /// 
    public bool StrictJarValidation { get; set; } = false;

    /// 
    /// Gets or sets the endpoint configuration.
    /// 
    /// 
    /// The endpoints configuration.
    /// 
    public EndpointsOptions Endpoints { get; set; } = new EndpointsOptions();

    /// 
    /// Gets or sets the discovery endpoint configuration.
    /// 
    /// 
    /// The discovery endpoint configuration.
    /// 
    public DiscoveryOptions Discovery { get; set; } = new DiscoveryOptions();

    /// 
    /// Gets or sets the authentication options.
    /// 
    /// 
    /// The authentication options.
    /// 
    public AuthenticationOptions Authentication { get; set; } = new AuthenticationOptions();

    /// 
    /// Gets or sets the events options.
    /// 
    /// 
    /// The events options.
    /// 
    public EventsOptions Events { get; set; } = new EventsOptions();

    /// 
    /// Gets or sets the max input length restrictions.
    /// 
    /// 
    /// The length restrictions.
    /// 
    public InputLengthRestrictions InputLengthRestrictions { get; set; } = new InputLengthRestrictions();

    /// 
    /// Gets or sets the options for the user interaction.
    /// 
    /// 
    /// The user interaction options.
    /// 
    public UserInteractionOptions UserInteraction { get; set; } = new UserInteractionOptions();

    /// 
    /// Gets or sets the caching options.
    /// 
    /// 
    /// The caching options.
    /// 
    public CachingOptions Caching { get; set; } = new CachingOptions();

    /// 
    /// Gets or sets the cors options.
    /// 
    /// 
    /// The cors options.
    /// 
    public CorsOptions Cors { get; set; } = new CorsOptions();

    /// 
    /// Gets or sets the Content Security Policy options.
    /// 
    public CspOptions Csp { get; set; } = new CspOptions();

    /// 
    /// Gets or sets the validation options.
    /// 
    public ValidationOptions Validation { get; set; } = new ValidationOptions();

    /// 
    /// Gets or sets the device flow options.
    /// 
    public DeviceFlowOptions DeviceFlow { get; set; } = new DeviceFlowOptions();
    
    /// 
    /// Gets or sets the logging options
    /// 
    public LoggingOptions Logging { get; set; } = new LoggingOptions();

    /// 
    /// Gets or sets the mutual TLS options.
    /// 
    public MutualTlsOptions MutualTls { get; set; } = new MutualTlsOptions();
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/InputLengthRestrictions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// 
/// 
public class InputLengthRestrictions
{
    private const int Default = 100;

    /// 
    /// Max length for client_id
    /// 
    public int ClientId { get; set; } = Default;

    /// 
    /// Max length for external client secrets
    /// 
    public int ClientSecret { get; set; } = Default;

    /// 
    /// Max length for scope
    /// 
    public int Scope { get; set; } = 300;

    /// 
    /// Max length for redirect_uri
    /// 
    public int RedirectUri { get; set; } = 400;

    /// 
    /// Max length for nonce
    /// 
    public int Nonce { get; set; } = 300;

    /// 
    /// Max length for ui_locale
    /// 
    public int UiLocale { get; set; } = Default;

    /// 
    /// Max length for login_hint
    /// 
    public int LoginHint { get; set; } = Default;

    /// 
    /// Max length for acr_values
    /// 
    public int AcrValues { get; set; } = 300;

    /// 
    /// Max length for grant_type
    /// 
    public int GrantType { get; set; } = Default;

    /// 
    /// Max length for username
    /// 
    public int UserName { get; set; } = Default;

    /// 
    /// Max length for password
    /// 
    public int Password { get; set; } = Default;

    /// 
    /// Max length for CSP reports
    /// 
    public int CspReport { get; set; } = 2000;

    /// 
    /// Max length for external identity provider name
    /// 
    public int IdentityProvider { get; set; } = Default;

    /// 
    /// Max length for external identity provider errors
    /// 
    public int ExternalError { get; set; } = Default;

    /// 
    /// Max length for authorization codes
    /// 
    public int AuthorizationCode { get; set; } = Default;

    /// 
    /// Max length for device codes
    /// 
    public int DeviceCode { get; set; } = Default;

    /// 
    /// Max length for refresh tokens
    /// 
    public int RefreshToken { get; set; } = Default;

    /// 
    /// Max length for token handles
    /// 
    public int TokenHandle { get; set; } = Default;

    /// 
    /// Max length for JWTs
    /// 
    public int Jwt { get; set; } = 51200;

    /// 
    /// Min length for the code challenge
    /// 
    public int CodeChallengeMinLength { get; } = 43;

    /// 
    /// Max length for the code challenge
    /// 
    public int CodeChallengeMaxLength { get; } = 128;

    /// 
    /// Min length for the code verifier
    /// 
    public int CodeVerifierMinLength { get; } = 43;

    /// 
    /// Max length for the code verifier
    /// 
    public int CodeVerifierMaxLength { get; } = 128;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/LoggingOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options for configuring logging behavior
/// 
public class LoggingOptions
{
    /// 
    /// 
    /// 
    public ICollection TokenRequestSensitiveValuesFilter { get; set; } = 
        new HashSet
        {
            OidcConstants.TokenRequest.ClientSecret,
            OidcConstants.TokenRequest.Password,
            OidcConstants.TokenRequest.ClientAssertion,
            OidcConstants.TokenRequest.RefreshToken,
            OidcConstants.TokenRequest.DeviceCode
        };

    /// 
    /// 
    /// 
    public ICollection AuthorizeRequestSensitiveValuesFilter { get; set; } = 
        new HashSet
        {
            OidcConstants.AuthorizeRequest.IdTokenHint
        };
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/MtlsOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options for Mutual TLS features
/// 
public class MutualTlsOptions
{
    /// 
    /// Specifies if MTLS support should be enabled
    /// 
    public bool Enabled { get; set; }

    /// 
    /// Specifies the name of the authentication handler for X.509 client certificates
    /// 
    public string ClientCertificateAuthenticationScheme { get; set; } = "Certificate";

    /// 
    /// Specifies a separate domain to run the MTLS endpoints on.
    /// If the string does not contain any dots, a subdomain is assumed - e.g. main domain: identityserver.local, MTLS domain: mtls.identityserver.local
    /// If the string contains dots, a completely separate domain is assumend, e.g. main domain: identity.app.com, MTLS domain: mtls.app.com. In this case you must set a static issuer name on the options.
    /// 
    public string DomainName { get; set; }

    /// 
    /// Specifies whether a cnf claim gets emitted for access tokens if a client certificate was present.
    /// Normally the cnf claims only gets emitted if the client used the client certificate for authentication,
    /// setting this to true, will set the claim regardless of the authentication method. (defaults to false).
    /// 
    public bool AlwaysEmitConfirmationClaim { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/UserInteractionOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// Options for aspects of the user interface.
/// 
public class UserInteractionOptions
{
    /// 
    /// Gets or sets the login URL. If a local URL, the value must start with a leading slash.
    /// 
    /// 
    /// The login URL.
    /// 
    public string LoginUrl { get; set; } //= Constants.UIConstants.DefaultRoutePaths.Login.EnsureLeadingSlash();

    /// 
    /// Gets or sets the login return URL parameter.
    /// 
    /// 
    /// The login return URL parameter.
    /// 
    public string LoginReturnUrlParameter { get; set; } //= Constants.UIConstants.DefaultRoutePathParams.Login;

    /// 
    /// Gets or sets the logout URL. If a local URL, the value must start with a leading slash.
    /// 
    /// 
    /// The logout URL.
    /// 
    public string LogoutUrl { get; set; } //= Constants.UIConstants.DefaultRoutePaths.Logout.EnsureLeadingSlash();

    /// 
    /// Gets or sets the logout identifier parameter.
    /// 
    /// 
    /// The logout identifier parameter.
    /// 
    public string LogoutIdParameter { get; set; } = Constants.UIConstants.DefaultRoutePathParams.Logout;

    /// 
    /// Gets or sets the consent URL. If a local URL, the value must start with a leading slash.
    /// 
    /// 
    /// The consent URL.
    /// 
    public string ConsentUrl { get; set; } = Constants.UIConstants.DefaultRoutePaths.Consent.EnsureLeadingSlash();

    /// 
    /// Gets or sets the consent return URL parameter.
    /// 
    /// 
    /// The consent return URL parameter.
    /// 
    public string ConsentReturnUrlParameter { get; set; } = Constants.UIConstants.DefaultRoutePathParams.Consent;

    /// 
    /// Gets or sets the error URL. If a local URL, the value must start with a leading slash.
    /// 
    /// 
    /// The error URL.
    /// 
    public string ErrorUrl { get; set; } = Constants.UIConstants.DefaultRoutePaths.Error.EnsureLeadingSlash();

    /// 
    /// Gets or sets the error identifier parameter.
    /// 
    /// 
    /// The error identifier parameter.
    /// 
    public string ErrorIdParameter { get; set; } = Constants.UIConstants.DefaultRoutePathParams.Error;

    /// 
    /// Gets or sets the custom redirect return URL parameter.
    /// 
    /// 
    /// The custom redirect return URL parameter.
    /// 
    public string CustomRedirectReturnUrlParameter { get; set; } = Constants.UIConstants.DefaultRoutePathParams.Custom;

    /// 
    /// Gets or sets the cookie message threshold. This limits how many cookies are created, and older ones will be purged.
    /// 
    /// 
    /// The cookie message threshold.
    /// 
    public int CookieMessageThreshold { get; set; } = Constants.UIConstants.CookieMessageThreshold;

    /// 
    /// Gets or sets the device verification URL.  If a local URL, the value must start with a leading slash.
    /// 
    /// 
    /// The device verification URL.
    /// 
    public string DeviceVerificationUrl { get; set; } = Constants.UIConstants.DefaultRoutePaths.DeviceVerification;

    /// 
    /// Gets or sets the device verification user code paramater.
    /// 
    /// 
    /// The device verification user code parameter.
    /// 
    public string DeviceVerificationUserCodeParameter { get; set; } = Constants.UIConstants.DefaultRoutePathParams.UserCode;
}


================================================
FILE: src/IdentityServer8/src/Configuration/DependencyInjection/Options/ValidationOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Configuration;

/// 
/// The ValidationOptions contains settings that affect some of the default validation behavior.
/// 
public class ValidationOptions
{
    /// 
    ///  Collection of URI scheme prefixes that should never be used as custom URI schemes in the redirect_uri passed to tha authorize endpoint.
    /// 
    public ICollection InvalidRedirectUriPrefixes { get; } = new HashSet
    {
        "javascript:",
        "file:",
        "data:",
        "mailto:",
        "ftp:",
        "blob:",
        "about:",
        "ssh:",
        "tel:",
        "view-source:",
        "ws:",
        "wss:"
    };
}


================================================
FILE: src/IdentityServer8/src/Configuration/IdentityServerApplicationBuilderExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.AspNetCore.Builder;

/// 
/// Pipeline extension methods for adding IdentityServer
/// 
public static class IdentityServerApplicationBuilderExtensions
{
    /// 
    /// Adds IdentityServer to the pipeline.
    /// 
    /// The application.
    /// The options.
    /// 
    public static IApplicationBuilder UseIdentityServer(this IApplicationBuilder app, IdentityServerMiddlewareOptions options = null)
    {
        app.Validate();

        app.UseMiddleware();

        app.ConfigureCors();

        // it seems ok if we have UseAuthentication more than once in the pipeline --
        // this will just re-run the various callback handlers and the default authN 
        // handler, which just re-assigns the user on the context. claims transformation
        // will run twice, since that's not cached (whereas the authN handler result is)
        // related: https://github.com/aspnet/Security/issues/1399
        if (options == null) options = new IdentityServerMiddlewareOptions();
        options.AuthenticationMiddleware(app);

        app.UseMiddleware();
        app.UseMiddleware();

        return app;
    }

    internal static void Validate(this IApplicationBuilder app)
    {
        var loggerFactory = app.ApplicationServices.GetService(typeof(ILoggerFactory)) as ILoggerFactory;
        if (loggerFactory == null) throw new ArgumentNullException(nameof(loggerFactory));

        var logger = loggerFactory.CreateLogger("IdentityServer8.Startup");
        logger.LogInformation("Starting IdentityServer8 version {version}", typeof(IdentityServer8.Hosting.IdentityServerMiddleware).Assembly.GetCustomAttribute().InformationalVersion);

        var scopeFactory = app.ApplicationServices.GetService();

        using (var scope = scopeFactory.CreateScope())
        {
            var serviceProvider = scope.ServiceProvider;

            TestService(serviceProvider, typeof(IPersistedGrantStore), logger, "No storage mechanism for grants specified. Use the 'AddInMemoryPersistedGrants' extension method to register a development version.");
            TestService(serviceProvider, typeof(IClientStore), logger, "No storage mechanism for clients specified. Use the 'AddInMemoryClients' extension method to register a development version.");
            TestService(serviceProvider, typeof(IResourceStore), logger, "No storage mechanism for resources specified. Use the 'AddInMemoryIdentityResources' or 'AddInMemoryApiResources' extension method to register a development version.");

            var persistedGrants = serviceProvider.GetService(typeof(IPersistedGrantStore));
            if (persistedGrants.GetType().FullName == typeof(InMemoryPersistedGrantStore).FullName)
            {
                logger.LogInformation("You are using the in-memory version of the persisted grant store. This will store consent decisions, authorization codes, refresh and reference tokens in memory only. If you are using any of those features in production, you want to switch to a different store implementation.");
            }

            var options = serviceProvider.GetRequiredService();
            ValidateOptions(options, logger);

            ValidateAsync(serviceProvider, logger).GetAwaiter().GetResult();
        }
    }

    private static async Task ValidateAsync(IServiceProvider services, ILogger logger)
    {
        var options = services.GetRequiredService();
        var schemes = services.GetRequiredService();


        if (await schemes.GetDefaultAuthenticateSchemeAsync() == null && options.Authentication.CookieAuthenticationScheme == null)
        {
            logger.LogWarning("No authentication scheme has been set. Setting either a default authentication scheme or a CookieAuthenticationScheme on IdentityServerOptions is required.");
        }
        else
        {
            AuthenticationScheme authenticationScheme = null;

            if (options.Authentication.CookieAuthenticationScheme != null)
            {
                authenticationScheme = await schemes.GetSchemeAsync(options.Authentication.CookieAuthenticationScheme);
                logger.LogInformation("Using explicitly configured authentication scheme {scheme} for IdentityServer", options.Authentication.CookieAuthenticationScheme);
            }
            else
            {
                authenticationScheme = await schemes.GetDefaultAuthenticateSchemeAsync();
                logger.LogInformation("Using the default authentication scheme {scheme} for IdentityServer", authenticationScheme.Name);
            }

            if (!typeof(IAuthenticationSignInHandler).IsAssignableFrom(authenticationScheme.HandlerType))
            {
                logger.LogInformation("Authentication scheme {scheme} is configured for IdentityServer, but it is not a scheme that supports signin (like cookies). If you support interactive logins via the browser, then a cookie-based scheme should be used.", authenticationScheme.Name);
            }

            logger.LogDebug("Using {scheme} as default ASP.NET Core scheme for authentication", (await schemes.GetDefaultAuthenticateSchemeAsync())?.Name);
            logger.LogDebug("Using {scheme} as default ASP.NET Core scheme for sign-in", (await schemes.GetDefaultSignInSchemeAsync())?.Name);
            logger.LogDebug("Using {scheme} as default ASP.NET Core scheme for sign-out", (await schemes.GetDefaultSignOutSchemeAsync())?.Name);
            logger.LogDebug("Using {scheme} as default ASP.NET Core scheme for challenge", (await schemes.GetDefaultChallengeSchemeAsync())?.Name);
            logger.LogDebug("Using {scheme} as default ASP.NET Core scheme for forbid", (await schemes.GetDefaultForbidSchemeAsync())?.Name);
        }
    }

    private static void ValidateOptions(IdentityServerOptions options, ILogger logger)
    {
        if (options.IssuerUri.IsPresent()) logger.LogDebug("Custom IssuerUri set to {0}", options.IssuerUri);
        
        // todo: perhaps different logging messages?
        //if (options.UserInteraction.LoginUrl.IsMissing()) throw new InvalidOperationException("LoginUrl is not configured");
        //if (options.UserInteraction.LoginReturnUrlParameter.IsMissing()) throw new InvalidOperationException("LoginReturnUrlParameter is not configured");
        //if (options.UserInteraction.LogoutUrl.IsMissing()) throw new InvalidOperationException("LogoutUrl is not configured");
        if (options.UserInteraction.LogoutIdParameter.IsMissing()) throw new InvalidOperationException("LogoutIdParameter is not configured");
        if (options.UserInteraction.ErrorUrl.IsMissing()) throw new InvalidOperationException("ErrorUrl is not configured");
        if (options.UserInteraction.ErrorIdParameter.IsMissing()) throw new InvalidOperationException("ErrorIdParameter is not configured");
        if (options.UserInteraction.ConsentUrl.IsMissing()) throw new InvalidOperationException("ConsentUrl is not configured");
        if (options.UserInteraction.ConsentReturnUrlParameter.IsMissing()) throw new InvalidOperationException("ConsentReturnUrlParameter is not configured");
        if (options.UserInteraction.CustomRedirectReturnUrlParameter.IsMissing()) throw new InvalidOperationException("CustomRedirectReturnUrlParameter is not configured");

        if (options.Authentication.CheckSessionCookieName.IsMissing()) throw new InvalidOperationException("CheckSessionCookieName is not configured");

        if (options.Cors.CorsPolicyName.IsMissing()) throw new InvalidOperationException("CorsPolicyName is not configured");
    }

    internal static object TestService(IServiceProvider serviceProvider, Type service, ILogger logger, string message = null, bool doThrow = true)
    {
        var appService = serviceProvider.GetService(service);

        if (appService == null)
        {
            var error = message ?? $"Required service {service.FullName} is not registered in the DI container. Aborting startup";

            logger.LogCritical(error);

            if (doThrow)
            {
                throw new InvalidOperationException(error);
            }
        }

        return appService;
    }
}


================================================
FILE: src/IdentityServer8/src/Configuration/IdentityServerMiddlewareOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.AspNetCore.Builder;

/// 
/// Options for the IdentityServer middleware
/// 
public class IdentityServerMiddlewareOptions
{
    /// 
    /// Callback to wire up an authentication middleware
    /// 
    public Action AuthenticationMiddleware { get; set; } = (app) => app.UseAuthentication();
}


================================================
FILE: src/IdentityServer8/src/Constants.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

internal static class Constants
{
    public const string IdentityServerName               = "IdentityServer8";
    public const string IdentityServerAuthenticationType = IdentityServerName;
    public const string ExternalAuthenticationMethod     = "external";
    public const string DefaultHashAlgorithm             = "SHA256";

    public static readonly TimeSpan DefaultCookieTimeSpan = TimeSpan.FromHours(10);
    public static readonly TimeSpan DefaultCacheDuration  = TimeSpan.FromMinutes(60);

    public static readonly List SupportedResponseTypes = new List 
    { 
        OidcConstants.ResponseTypes.Code,
        OidcConstants.ResponseTypes.Token,
        OidcConstants.ResponseTypes.IdToken,
        OidcConstants.ResponseTypes.IdTokenToken,
        OidcConstants.ResponseTypes.CodeIdToken,
        OidcConstants.ResponseTypes.CodeToken,
        OidcConstants.ResponseTypes.CodeIdTokenToken
    };

    public static readonly Dictionary ResponseTypeToGrantTypeMapping = new Dictionary
    {
        { OidcConstants.ResponseTypes.Code, GrantType.AuthorizationCode },
        { OidcConstants.ResponseTypes.Token, GrantType.Implicit },
        { OidcConstants.ResponseTypes.IdToken, GrantType.Implicit },
        { OidcConstants.ResponseTypes.IdTokenToken, GrantType.Implicit },
        { OidcConstants.ResponseTypes.CodeIdToken, GrantType.Hybrid },
        { OidcConstants.ResponseTypes.CodeToken, GrantType.Hybrid },
        { OidcConstants.ResponseTypes.CodeIdTokenToken, GrantType.Hybrid }
    };

    public static readonly List AllowedGrantTypesForAuthorizeEndpoint = new List
    {
        GrantType.AuthorizationCode,
        GrantType.Implicit,
        GrantType.Hybrid
    };

    public static readonly List SupportedCodeChallengeMethods = new List
    {
        OidcConstants.CodeChallengeMethods.Plain,
        OidcConstants.CodeChallengeMethods.Sha256
    };

    public enum ScopeRequirement
    {
        None, 
        ResourceOnly, 
        IdentityOnly,
        Identity
    }

    public static readonly Dictionary ResponseTypeToScopeRequirement = new Dictionary
    {
        { OidcConstants.ResponseTypes.Code, ScopeRequirement.None },
        { OidcConstants.ResponseTypes.Token, ScopeRequirement.ResourceOnly },
        { OidcConstants.ResponseTypes.IdToken, ScopeRequirement.IdentityOnly },
        { OidcConstants.ResponseTypes.IdTokenToken, ScopeRequirement.Identity },
        { OidcConstants.ResponseTypes.CodeIdToken, ScopeRequirement.Identity },
        { OidcConstants.ResponseTypes.CodeToken, ScopeRequirement.Identity },
        { OidcConstants.ResponseTypes.CodeIdTokenToken, ScopeRequirement.Identity }
    };
                        
    public static readonly Dictionary> AllowedResponseModesForGrantType = new Dictionary>
    {
        { GrantType.AuthorizationCode, new[] { OidcConstants.ResponseModes.Query, OidcConstants.ResponseModes.FormPost, OidcConstants.ResponseModes.Fragment } },
        { GrantType.Hybrid, new[] { OidcConstants.ResponseModes.Fragment, OidcConstants.ResponseModes.FormPost }},
        { GrantType.Implicit, new[] { OidcConstants.ResponseModes.Fragment, OidcConstants.ResponseModes.FormPost }}
    };

    public static readonly List SupportedResponseModes = new List
    {
        OidcConstants.ResponseModes.FormPost,
        OidcConstants.ResponseModes.Query,
        OidcConstants.ResponseModes.Fragment
    };

    public static string[] SupportedSubjectTypes =
    {
        "pairwise", "public"
    };

    public static class SigningAlgorithms
    {
        public const string RSA_SHA_256 = "RS256";
    }

    public static readonly List SupportedDisplayModes = new List
    {
        OidcConstants.DisplayModes.Page,
        OidcConstants.DisplayModes.Popup,
        OidcConstants.DisplayModes.Touch,
        OidcConstants.DisplayModes.Wap
    };

    public static readonly List SupportedPromptModes = new List
    {
        OidcConstants.PromptModes.None,
        OidcConstants.PromptModes.Login,
        OidcConstants.PromptModes.Consent,
        OidcConstants.PromptModes.SelectAccount
    };

    public static class KnownAcrValues
    {
        public const string HomeRealm = "idp:";
        public const string Tenant = "tenant:";

        public static readonly string[] All = { HomeRealm, Tenant };
    }

    public static Dictionary ProtectedResourceErrorStatusCodes = new Dictionary
    {
        { OidcConstants.ProtectedResourceErrors.InvalidToken,      401 },
        { OidcConstants.ProtectedResourceErrors.ExpiredToken,      401 },
        { OidcConstants.ProtectedResourceErrors.InvalidRequest,    400 },
        { OidcConstants.ProtectedResourceErrors.InsufficientScope, 403 }
    };
    
    public static readonly Dictionary> ScopeToClaimsMapping = new Dictionary>
    {
        { IdentityServerConstants.StandardScopes.Profile, new[]
                        { 
                            JwtClaimTypes.Name,
                            JwtClaimTypes.FamilyName,
                            JwtClaimTypes.GivenName,
                            JwtClaimTypes.MiddleName,
                            JwtClaimTypes.NickName,
                            JwtClaimTypes.PreferredUserName,
                            JwtClaimTypes.Profile,
                            JwtClaimTypes.Picture,
                            JwtClaimTypes.WebSite,
                            JwtClaimTypes.Gender,
                            JwtClaimTypes.BirthDate,
                            JwtClaimTypes.ZoneInfo,
                            JwtClaimTypes.Locale,
                            JwtClaimTypes.UpdatedAt 
                        }},
        { IdentityServerConstants.StandardScopes.Email, new[]
                        { 
                            JwtClaimTypes.Email,
                            JwtClaimTypes.EmailVerified 
                        }},
        { IdentityServerConstants.StandardScopes.Address, new[]
                        {
                            JwtClaimTypes.Address
                        }},
        { IdentityServerConstants.StandardScopes.Phone, new[]
                        {
                            JwtClaimTypes.PhoneNumber,
                            JwtClaimTypes.PhoneNumberVerified
                        }},
        { IdentityServerConstants.StandardScopes.OpenId, new[]
                        {
                            JwtClaimTypes.Subject
                        }}
    };

    public static class UIConstants
    {
        // the limit after which old messages are purged
        public const int CookieMessageThreshold = 2;

        public static class DefaultRoutePathParams
        {
            public const string Error = "errorId";
            public const string Login = "returnUrl";
            public const string Consent = "returnUrl";
            public const string Logout = "logoutId";
            public const string EndSessionCallback = "endSessionId";
            public const string Custom = "returnUrl";
            public const string UserCode = "userCode";
        }

        public static class DefaultRoutePaths
        {
            public const string Login = "/account/login";
            public const string Logout = "/account/logout";
            public const string Consent = "/consent";
            public const string Error = "/home/error";
            public const string DeviceVerification = "/device";
        }
    }

    public static class EndpointNames
    {
        public const string Authorize = "Authorize";
        public const string Token = "Token";
        public const string DeviceAuthorization = "DeviceAuthorization";
        public const string Discovery = "Discovery";
        public const string Introspection = "Introspection";
        public const string Revocation = "Revocation";
        public const string EndSession = "Endsession";
        public const string CheckSession = "Checksession";
        public const string UserInfo = "Userinfo";
    }

    public static class ProtocolRoutePaths
    {
        public const string ConnectPathPrefix       = "connect";

        public const string Authorize               = ConnectPathPrefix + "/authorize";
        public const string AuthorizeCallback       = Authorize + "/callback";
        public const string DiscoveryConfiguration  = ".well-known/openid-configuration";
        public const string DiscoveryWebKeys        = DiscoveryConfiguration + "/jwks";
        public const string Token                   = ConnectPathPrefix + "/token";
        public const string Revocation              = ConnectPathPrefix + "/revocation";
        public const string UserInfo                = ConnectPathPrefix + "/userinfo";
        public const string Introspection           = ConnectPathPrefix + "/introspect";
        public const string EndSession              = ConnectPathPrefix + "/endsession";
        public const string EndSessionCallback      = EndSession + "/callback";
        public const string CheckSession            = ConnectPathPrefix + "/checksession";
        public const string DeviceAuthorization     = ConnectPathPrefix + "/deviceauthorization";

        public const string MtlsPathPrefix          = ConnectPathPrefix + "/mtls";
        public const string MtlsToken               = MtlsPathPrefix + "/token";
        public const string MtlsRevocation          = MtlsPathPrefix + "/revocation";
        public const string MtlsIntrospection       = MtlsPathPrefix + "/introspect";
        public const string MtlsDeviceAuthorization = MtlsPathPrefix + "/deviceauthorization";

        public static readonly string[] CorsPaths =
        {
            DiscoveryConfiguration,
            DiscoveryWebKeys,
            Token,
            UserInfo,
            Revocation
        };
    }

    public static class EnvironmentKeys
    {
        public const string IdentityServerBasePath = "idsvr:IdentityServerBasePath";
        [Obsolete("The IdentityServerOrigin constant is obsolete.")]
        public const string IdentityServerOrigin = "idsvr:IdentityServerOrigin"; // todo: deprecate
        public const string SignOutCalled = "idsvr:IdentityServerSignOutCalled";
    }

    public static class TokenTypeHints
    {
        public const string RefreshToken = "refresh_token";
        public const string AccessToken  = "access_token";
    }

    public static List SupportedTokenTypeHints = new List
    {
        TokenTypeHints.RefreshToken,
        TokenTypeHints.AccessToken
    };

    public static class RevocationErrors
    {
        public const string UnsupportedTokenType = "unsupported_token_type";
    }

    public class Filters
    {
        // filter for claims from an incoming access token (e.g. used at the user profile endpoint)
        public static readonly string[] ProtocolClaimsFilter = {
            JwtClaimTypes.AccessTokenHash,
            JwtClaimTypes.Audience,
            JwtClaimTypes.AuthorizedParty,
            JwtClaimTypes.AuthorizationCodeHash,
            JwtClaimTypes.ClientId,
            JwtClaimTypes.Expiration,
            JwtClaimTypes.IssuedAt,
            JwtClaimTypes.Issuer,
            JwtClaimTypes.JwtId,
            JwtClaimTypes.Nonce,
            JwtClaimTypes.NotBefore,
            JwtClaimTypes.ReferenceTokenId,
            JwtClaimTypes.SessionId,
            JwtClaimTypes.Scope
        };

        // filter list for claims returned from profile service prior to creating tokens
        public static readonly string[] ClaimsServiceFilterClaimTypes = {
            // TODO: consider JwtClaimTypes.AuthenticationContextClassReference,
            JwtClaimTypes.AccessTokenHash,
            JwtClaimTypes.Audience,
            JwtClaimTypes.AuthenticationMethod,
            JwtClaimTypes.AuthenticationTime,
            JwtClaimTypes.AuthorizedParty,
            JwtClaimTypes.AuthorizationCodeHash,
            JwtClaimTypes.ClientId,
            JwtClaimTypes.Expiration,
            JwtClaimTypes.IdentityProvider,
            JwtClaimTypes.IssuedAt,
            JwtClaimTypes.Issuer,
            JwtClaimTypes.JwtId,
            JwtClaimTypes.Nonce,
            JwtClaimTypes.NotBefore,
            JwtClaimTypes.ReferenceTokenId,
            JwtClaimTypes.SessionId,
            JwtClaimTypes.Subject,
            JwtClaimTypes.Scope,
            JwtClaimTypes.Confirmation
        };

        public static readonly string[] JwtRequestClaimTypesFilter = {
            JwtClaimTypes.Audience,
            JwtClaimTypes.Expiration,
            JwtClaimTypes.IssuedAt,
            JwtClaimTypes.Issuer,
            JwtClaimTypes.NotBefore,
            JwtClaimTypes.JwtId
        };
    }

    public static class WsFedSignOut
    {
        public const string LogoutUriParameterName = "wa";
        public const string LogoutUriParameterValue = "wsignoutcleanup1.0";
    }

    public static class AuthorizationParamsStore
    {
        public const string MessageStoreIdParameterName = "authzId";
    }

    public static class CurveOids
    {
        public const string P256 = "1.2.840.10045.3.1.7";
        public const string P384 = "1.3.132.0.34";
        public const string P521 = "1.3.132.0.35";
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/AuthorizeCallbackEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class AuthorizeCallbackEndpoint : AuthorizeEndpointBase
{
    private readonly IConsentMessageStore _consentResponseStore;
    private readonly IAuthorizationParametersMessageStore _authorizationParametersMessageStore;

    public AuthorizeCallbackEndpoint(
        IEventService events,
        ILogger logger,
        IdentityServerOptions options,
        IAuthorizeRequestValidator validator,
        IAuthorizeInteractionResponseGenerator interactionGenerator,
        IAuthorizeResponseGenerator authorizeResponseGenerator,
        IUserSession userSession,
        IConsentMessageStore consentResponseStore,
        IAuthorizationParametersMessageStore authorizationParametersMessageStore = null)
        : base(events, logger, options, validator, interactionGenerator, authorizeResponseGenerator, userSession)
    {
        _consentResponseStore = consentResponseStore;
        _authorizationParametersMessageStore = authorizationParametersMessageStore;
    }

    public override async Task ProcessAsync(HttpContext context)
    {
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            Logger.LogWarning("Invalid HTTP method for authorize endpoint.");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        Logger.LogDebug("Start authorize callback request");

        var parameters = context.Request.Query.AsNameValueCollection();
        if (_authorizationParametersMessageStore != null)
        {
            var messageStoreId = parameters[Constants.AuthorizationParamsStore.MessageStoreIdParameterName];
            var entry = await _authorizationParametersMessageStore.ReadAsync(messageStoreId);
            parameters = entry?.Data.FromFullDictionary() ?? new NameValueCollection();

            await _authorizationParametersMessageStore.DeleteAsync(messageStoreId);
        }

        var user = await UserSession.GetUserAsync();
        var consentRequest = new ConsentRequest(parameters, user?.GetSubjectId());
        var consent = await _consentResponseStore.ReadAsync(consentRequest.Id);

        if (consent != null && consent.Data == null)
        {
            return await CreateErrorResultAsync("consent message is missing data");
        }

        try
        {
            var result = await ProcessAuthorizeRequestAsync(parameters, user, consent?.Data);

            Logger.LogTrace("End Authorize Request. Result type: {0}", result?.GetType().ToString() ?? "-none-");

            return result;
        }
        finally
        {
            if (consent != null)
            {
                await _consentResponseStore.DeleteAsync(consentRequest.Id);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/AuthorizeEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class AuthorizeEndpoint : AuthorizeEndpointBase
{
    public AuthorizeEndpoint(
       IEventService events,
       ILogger logger,
       IdentityServerOptions options,
       IAuthorizeRequestValidator validator,
       IAuthorizeInteractionResponseGenerator interactionGenerator,
       IAuthorizeResponseGenerator authorizeResponseGenerator,
       IUserSession userSession)
        : base(events, logger, options, validator, interactionGenerator, authorizeResponseGenerator, userSession)
    {
    }

    public override async Task ProcessAsync(HttpContext context)
    {
        Logger.LogDebug("Start authorize request");

        NameValueCollection values;

        if (HttpMethods.IsGet(context.Request.Method))
        {
            values = context.Request.Query.AsNameValueCollection();
        }
        else if (HttpMethods.IsPost(context.Request.Method))
        {
            if (!context.Request.HasApplicationFormContentType())
            {
                return new StatusCodeResult(HttpStatusCode.UnsupportedMediaType);
            }

            values = context.Request.Form.AsNameValueCollection();
        }
        else
        {
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        var user = await UserSession.GetUserAsync();
        var result = await ProcessAuthorizeRequestAsync(values, user, null);

        Logger.LogTrace("End authorize request. result type: {0}", result?.GetType().ToString() ?? "-none-");

        return result;
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/AuthorizeEndpointBase.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal abstract class AuthorizeEndpointBase : IEndpointHandler
{
    private readonly IAuthorizeResponseGenerator _authorizeResponseGenerator;

    private readonly IEventService _events;
    private readonly IdentityServerOptions _options;

    private readonly IAuthorizeInteractionResponseGenerator _interactionGenerator;

    private readonly IAuthorizeRequestValidator _validator;

    protected AuthorizeEndpointBase(
        IEventService events,
        ILogger logger,
        IdentityServerOptions options,
        IAuthorizeRequestValidator validator,
        IAuthorizeInteractionResponseGenerator interactionGenerator,
        IAuthorizeResponseGenerator authorizeResponseGenerator,
        IUserSession userSession)
    {
        _events = events;
        _options = options;
        Logger = logger;
        _validator = validator;
        _interactionGenerator = interactionGenerator;
        _authorizeResponseGenerator = authorizeResponseGenerator;
        UserSession = userSession;
    }

    protected ILogger Logger { get; private set; }

    protected IUserSession UserSession { get; private set; }

    public abstract Task ProcessAsync(HttpContext context);

    internal async Task ProcessAuthorizeRequestAsync(NameValueCollection parameters, ClaimsPrincipal user, ConsentResponse consent)
    {
        if (user != null)
        {
            Logger.LogDebug("User in authorize request: {subjectId}", user.GetSubjectId());
        }
        else
        {
            Logger.LogDebug("No user present in authorize request");
        }

        // validate request
        var result = await _validator.ValidateAsync(parameters, user);
        if (result.IsError)
        {
            return await CreateErrorResultAsync(
                "Request validation failed",
                result.ValidatedRequest,
                result.Error,
                result.ErrorDescription);
        }

        var request = result.ValidatedRequest;
        LogRequest(request);

        // determine user interaction
        var interactionResult = await _interactionGenerator.ProcessInteractionAsync(request, consent);
        if (interactionResult.IsError)
        {
            return await CreateErrorResultAsync("Interaction generator error", request, interactionResult.Error, interactionResult.ErrorDescription, false);
        }
        if (interactionResult.IsLogin)
        {
            return new LoginPageResult(request);
        }
        if (interactionResult.IsConsent)
        {
            return new ConsentPageResult(request);
        }
        if (interactionResult.IsRedirect)
        {
            return new CustomRedirectResult(request, interactionResult.RedirectUrl);
        }

        var response = await _authorizeResponseGenerator.CreateResponseAsync(request);

        await RaiseResponseEventAsync(response);

        LogResponse(response);

        return new AuthorizeResult(response);
    }

    protected async Task CreateErrorResultAsync(
        string logMessage,
        ValidatedAuthorizeRequest request = null,
        string error = OidcConstants.AuthorizeErrors.ServerError,
        string errorDescription = null,
        bool logError = true)
    {
        if (logError)
        {
            Logger.LogError(logMessage);
        }

        if (request != null)
        {
            var details = new AuthorizeRequestValidationLog(request, _options.Logging.AuthorizeRequestSensitiveValuesFilter);
            Logger.LogInformation("{@validationDetails}", details);
        }

        // TODO: should we raise a token failure event for all errors to the authorize endpoint?
        await RaiseFailureEventAsync(request, error, errorDescription);

        return new AuthorizeResult(new AuthorizeResponse
        {
            Request = request,
            Error = error,
            ErrorDescription = errorDescription,
            SessionState = request?.GenerateSessionStateValue()
        });
    }

    private void LogRequest(ValidatedAuthorizeRequest request)
    {
        var details = new AuthorizeRequestValidationLog(request, _options.Logging.AuthorizeRequestSensitiveValuesFilter);
        Logger.LogDebug(nameof(ValidatedAuthorizeRequest) + Environment.NewLine + "{@validationDetails}", details);
    }

    private void LogResponse(AuthorizeResponse response)
    {
        var details = new AuthorizeResponseLog(response);
        Logger.LogDebug("Authorize endpoint response" + Environment.NewLine + "{@details}", details);
    }

    private void LogTokens(AuthorizeResponse response)
    {
        var clientId = $"{response.Request.ClientId} ({response.Request.Client.ClientName ?? "no name set"})";
        var subjectId = response.Request.Subject.GetSubjectId();

        if (response.IdentityToken != null)
        {
            Logger.LogTrace("Identity token issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.IdentityToken);
        }
        if (response.Code != null)
        {
            Logger.LogTrace("Code issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.Code);
        }
        if (response.AccessToken != null)
        {
            Logger.LogTrace("Access token issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.AccessToken);
        }
    }

    private Task RaiseFailureEventAsync(ValidatedAuthorizeRequest request, string error, string errorDescription)
    {
        return _events.RaiseAsync(new TokenIssuedFailureEvent(request, error, errorDescription));
    }

    private Task RaiseResponseEventAsync(AuthorizeResponse response)
    {
        if (!response.IsError)
        {
            LogTokens(response);
            return _events.RaiseAsync(new TokenIssuedSuccessEvent(response));
        }

        return RaiseFailureEventAsync(response.Request, response.Error, response.ErrorDescription);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/CheckSessionEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class CheckSessionEndpoint : IEndpointHandler
{
    private readonly ILogger _logger;

    public CheckSessionEndpoint(ILogger logger)
    {
        _logger = logger;
    }

    public Task ProcessAsync(HttpContext context)
    {
        IEndpointResult result;

        if (!HttpMethods.IsGet(context.Request.Method))
        {
            _logger.LogWarning("Invalid HTTP method for check session endpoint");
            result = new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }
        else
        {
            _logger.LogDebug("Rendering check session result");
            result = new CheckSessionResult();
        }

        return Task.FromResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/DeviceAuthorizationEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

/// 
/// The device authorization endpoint
/// 
/// 
internal class DeviceAuthorizationEndpoint : IEndpointHandler
{
    private readonly IClientSecretValidator _clientValidator;
    private readonly IDeviceAuthorizationRequestValidator _requestValidator;
    private readonly IDeviceAuthorizationResponseGenerator _responseGenerator;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    public DeviceAuthorizationEndpoint(
        IClientSecretValidator clientValidator,
        IDeviceAuthorizationRequestValidator requestValidator,
        IDeviceAuthorizationResponseGenerator responseGenerator,
        IEventService events,
        ILogger logger)
    {
        _clientValidator = clientValidator;
        _requestValidator = requestValidator;
        _responseGenerator = responseGenerator;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    /// 
    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing device authorize request.");

        // validate HTTP
        if (!HttpMethods.IsPost(context.Request.Method) || !context.Request.HasApplicationFormContentType())
        {
            _logger.LogWarning("Invalid HTTP request for device authorize endpoint");
            return Error(OidcConstants.TokenErrors.InvalidRequest);
        }

        return await ProcessDeviceAuthorizationRequestAsync(context);
    }

    private async Task ProcessDeviceAuthorizationRequestAsync(HttpContext context)
    {
        _logger.LogDebug("Start device authorize request.");

        // validate client
        var clientResult = await _clientValidator.ValidateAsync(context);
        if (clientResult.Client == null) return Error(OidcConstants.TokenErrors.InvalidClient);

        // validate request
        var form = (await context.Request.ReadFormAsync()).AsNameValueCollection();
        var requestResult = await _requestValidator.ValidateAsync(form, clientResult);

        if (requestResult.IsError)
        {
            await _events.RaiseAsync(new DeviceAuthorizationFailureEvent(requestResult));
            return Error(requestResult.Error, requestResult.ErrorDescription);
        }

        var baseUrl = context.GetIdentityServerBaseUrl().EnsureTrailingSlash();

        // create response
        _logger.LogTrace("Calling into device authorize response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.ProcessAsync(requestResult, baseUrl);

        await _events.RaiseAsync(new DeviceAuthorizationSuccessEvent(response, requestResult));

        // return result
        _logger.LogDebug("Device authorize request success.");
        return new DeviceAuthorizationResult(response);
    }

    private TokenErrorResult Error(string error, string errorDescription = null, Dictionary custom = null)
    {
        var response = new TokenErrorResponse
        {
            Error = error,
            ErrorDescription = errorDescription,
            Custom = custom
        };

        _logger.LogError("Device authorization error: {error}:{errorDescriptions}", error, error ?? "-no message-");

        return new TokenErrorResult(response);
    }

    private void LogResponse(DeviceAuthorizationResponse response, DeviceAuthorizationRequestValidationResult requestResult)
    {
        var clientId = $"{requestResult.ValidatedRequest.Client.ClientId} ({requestResult.ValidatedRequest.Client?.ClientName ?? "no name set"})";

        if (response.DeviceCode != null)
        {
            _logger.LogTrace("Device code issued for {clientId}: {deviceCode}", clientId, response.DeviceCode);
        }
        if (response.UserCode != null)
        {
            _logger.LogTrace("User code issued for {clientId}: {userCode}", clientId, response.UserCode);
        }
        if (response.VerificationUri != null)
        {
            _logger.LogTrace("Verification URI issued for {clientId}: {verificationUri}", clientId, response.VerificationUri);
        }
        if (response.VerificationUriComplete != null)
        {
            _logger.LogTrace("Verification URI (Complete) issued for {clientId}: {verificationUriComplete}", clientId, response.VerificationUriComplete);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/DiscoveryEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class DiscoveryEndpoint : IEndpointHandler
{
    private readonly ILogger _logger;

    private readonly IdentityServerOptions _options;

    private readonly IDiscoveryResponseGenerator _responseGenerator;

    public DiscoveryEndpoint(
        IdentityServerOptions options,
        IDiscoveryResponseGenerator responseGenerator,
        ILogger logger)
    {
        _logger = logger;
        _options = options;
        _responseGenerator = responseGenerator;
    }

    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing discovery request.");

        // validate HTTP
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            _logger.LogWarning("Discovery endpoint only supports GET requests");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        _logger.LogDebug("Start discovery request");

        if (!_options.Endpoints.EnableDiscoveryEndpoint)
        {
            _logger.LogInformation("Discovery endpoint disabled. 404.");
            return new StatusCodeResult(HttpStatusCode.NotFound);
        }

        var baseUrl = context.GetIdentityServerBaseUrl().EnsureTrailingSlash();
        var issuerUri = context.GetIdentityServerIssuerUri();

        // generate response
        _logger.LogTrace("Calling into discovery response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.CreateDiscoveryDocumentAsync(baseUrl, issuerUri);

        return new DiscoveryDocumentResult(response, _options.Discovery.ResponseCacheInterval);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/DiscoveryKeyEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class DiscoveryKeyEndpoint : IEndpointHandler
{
    private readonly ILogger _logger;

    private readonly IdentityServerOptions _options;

    private readonly IDiscoveryResponseGenerator _responseGenerator;

    public DiscoveryKeyEndpoint(
        IdentityServerOptions options,
        IDiscoveryResponseGenerator responseGenerator,
        ILogger logger)
    {
        _logger = logger;
        _options = options;
        _responseGenerator = responseGenerator;
    }

    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing discovery request.");

        // validate HTTP
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            _logger.LogWarning("Discovery endpoint only supports GET requests");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        _logger.LogDebug("Start key discovery request");

        if (_options.Discovery.ShowKeySet == false)
        {
            _logger.LogInformation("Key discovery disabled. 404.");
            return new StatusCodeResult(HttpStatusCode.NotFound);
        }

        // generate response
        _logger.LogTrace("Calling into discovery response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.CreateJwkDocumentAsync();

        return new JsonWebKeysResult(response, _options.Discovery.ResponseCacheInterval);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/EndSessionCallbackEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class EndSessionCallbackEndpoint : IEndpointHandler
{
    private readonly IEndSessionRequestValidator _endSessionRequestValidator;
    private readonly ILogger _logger;

    public EndSessionCallbackEndpoint(
        IEndSessionRequestValidator endSessionRequestValidator,
        ILogger logger)
    {
        _endSessionRequestValidator = endSessionRequestValidator;
        _logger = logger;
    }

    public async Task ProcessAsync(HttpContext context)
    {
        if (!HttpMethods.IsGet(context.Request.Method))
        {
            _logger.LogWarning("Invalid HTTP method for end session callback endpoint.");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        _logger.LogDebug("Processing signout callback request");

        var parameters = context.Request.Query.AsNameValueCollection();
        var result = await _endSessionRequestValidator.ValidateCallbackAsync(parameters);

        if (!result.IsError)
        {
            _logger.LogInformation("Successful signout callback.");
        }
        else
        {
            _logger.LogError("Error validating signout callback: {error}", result.Error);
        }
        
        return new EndSessionCallbackResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/EndSessionEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

internal class EndSessionEndpoint : IEndpointHandler
{
    private readonly IEndSessionRequestValidator _endSessionRequestValidator;

    private readonly ILogger _logger;

    private readonly IUserSession _userSession;

    public EndSessionEndpoint(
        IEndSessionRequestValidator endSessionRequestValidator,
        IUserSession userSession,
        ILogger logger)
    {
        _endSessionRequestValidator = endSessionRequestValidator;
        _userSession = userSession;
        _logger = logger;
    }

    public async Task ProcessAsync(HttpContext context)
    {
        NameValueCollection parameters;
        if (HttpMethods.IsGet(context.Request.Method))
        {
            parameters = context.Request.Query.AsNameValueCollection();
        }
        else if (HttpMethods.IsPost(context.Request.Method))
        {
            parameters = (await context.Request.ReadFormAsync()).AsNameValueCollection();
        }
        else
        {
            _logger.LogWarning("Invalid HTTP method for end session endpoint.");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        var user = await _userSession.GetUserAsync();

        _logger.LogDebug("Processing signout request for {subjectId}", user?.GetSubjectId() ?? "anonymous");

        var result = await _endSessionRequestValidator.ValidateAsync(parameters, user);

        if (result.IsError)
        {
            _logger.LogError("Error processing end session request {error}", result.Error);
        }
        else
        {
            _logger.LogDebug("Success validating end session request from {clientId}", result.ValidatedRequest?.Client?.ClientId);
        }

        return new EndSessionResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/IntrospectionEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

/// 
/// Introspection endpoint
/// 
/// 
internal class IntrospectionEndpoint : IEndpointHandler
{
    private readonly IIntrospectionResponseGenerator _responseGenerator;
    private readonly IEventService _events;
    private readonly ILogger _logger;
    private readonly IIntrospectionRequestValidator _requestValidator;
    private readonly IApiSecretValidator _apiSecretValidator;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The API secret validator.
    /// The request validator.
    /// The generator.
    /// The events.
    /// The logger.
    public IntrospectionEndpoint(
        IApiSecretValidator apiSecretValidator,
        IIntrospectionRequestValidator requestValidator,
        IIntrospectionResponseGenerator responseGenerator,
        IEventService events,
        ILogger logger)
    {
        _apiSecretValidator = apiSecretValidator;
        _requestValidator = requestValidator;
        _responseGenerator = responseGenerator;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing introspection request.");

        // validate HTTP
        if (!HttpMethods.IsPost(context.Request.Method))
        {
            _logger.LogWarning("Introspection endpoint only supports POST requests");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        if (!context.Request.HasApplicationFormContentType())
        {
            _logger.LogWarning("Invalid media type for introspection endpoint");
            return new StatusCodeResult(HttpStatusCode.UnsupportedMediaType);
        }

        return await ProcessIntrospectionRequestAsync(context);
    }

    private async Task ProcessIntrospectionRequestAsync(HttpContext context)
    {
        _logger.LogDebug("Starting introspection request.");

        // caller validation
        var apiResult = await _apiSecretValidator.ValidateAsync(context);
        if (apiResult.Resource == null)
        {
            _logger.LogError("API unauthorized to call introspection endpoint. aborting.");
            return new StatusCodeResult(HttpStatusCode.Unauthorized);
        }

        var body = await context.Request.ReadFormAsync();
        if (body == null)
        {
            _logger.LogError("Malformed request body. aborting.");
            await _events.RaiseAsync(new TokenIntrospectionFailureEvent(apiResult.Resource.Name, "Malformed request body"));

            return new StatusCodeResult(HttpStatusCode.BadRequest);
        }

        // request validation
        _logger.LogTrace("Calling into introspection request validator: {type}", _requestValidator.GetType().FullName);
        var validationResult = await _requestValidator.ValidateAsync(body.AsNameValueCollection(), apiResult.Resource);
        if (validationResult.IsError)
        {
            LogFailure(validationResult.Error, apiResult.Resource.Name);
            await _events.RaiseAsync(new TokenIntrospectionFailureEvent(apiResult.Resource.Name, validationResult.Error));

            return new BadRequestResult(validationResult.Error);
        }

        // response generation
        _logger.LogTrace("Calling into introspection response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.ProcessAsync(validationResult);

        // render result
        LogSuccess(validationResult.IsActive, validationResult.Api.Name);
        return new IntrospectionResult(response);
    }

    private void LogSuccess(bool tokenActive, string apiName)
    {
        _logger.LogInformation("Success token introspection. Token active: {tokenActive}, for API name: {apiName}", tokenActive, apiName);
    }

    private void LogFailure(string error, string apiName)
    {
        _logger.LogError("Failed token introspection: {error}, for API name: {apiName}", error, apiName);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/AuthorizeResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class AuthorizeResult : IEndpointResult
{
    public AuthorizeResponse Response { get; }

    public AuthorizeResult(AuthorizeResponse response)
    {
        Response = response ?? throw new ArgumentNullException(nameof(response));
    }

    internal AuthorizeResult(
        AuthorizeResponse response,
        IdentityServerOptions options,
        IUserSession userSession,
        IMessageStore errorMessageStore,
        ISystemClock clock)
        : this(response)
    {
        _options = options;
        _userSession = userSession;
        _errorMessageStore = errorMessageStore;
        _clock = clock;
    }

    private IdentityServerOptions _options;
    private IUserSession _userSession;
    private IMessageStore _errorMessageStore;
    private ISystemClock _clock;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
        _userSession = _userSession ?? context.RequestServices.GetRequiredService();
        _errorMessageStore = _errorMessageStore ?? context.RequestServices.GetRequiredService>();
        _clock = _clock ?? context.RequestServices.GetRequiredService();
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        if (Response.IsError)
        {
            await ProcessErrorAsync(context);
        }
        else
        {
            await ProcessResponseAsync(context);
        }
    }

    private async Task ProcessErrorAsync(HttpContext context)
    {
        // these are the conditions where we can send a response 
        // back directly to the client, otherwise we're only showing the error UI
        var isSafeError =
            Response.Error == OidcConstants.AuthorizeErrors.AccessDenied ||
            Response.Error == OidcConstants.AuthorizeErrors.AccountSelectionRequired ||
            Response.Error == OidcConstants.AuthorizeErrors.LoginRequired ||
            Response.Error == OidcConstants.AuthorizeErrors.ConsentRequired ||
            Response.Error == OidcConstants.AuthorizeErrors.InteractionRequired;

        if (isSafeError)
        {
            // this scenario we can return back to the client
            await ProcessResponseAsync(context);
        }
        else
        {
            // we now know we must show error page
            await RedirectToErrorPageAsync(context);
        }
    }

    protected async Task ProcessResponseAsync(HttpContext context)
    {
        if (!Response.IsError)
        {
            // success response -- track client authorization for sign-out
            //_logger.LogDebug("Adding client {0} to client list cookie for subject {1}", request.ClientId, request.Subject.GetSubjectId());
            await _userSession.AddClientIdAsync(Response.Request.ClientId);
        }

        await RenderAuthorizeResponseAsync(context);
    }

    private async Task RenderAuthorizeResponseAsync(HttpContext context)
    {
        if (Response.Request.ResponseMode == OidcConstants.ResponseModes.Query ||
            Response.Request.ResponseMode == OidcConstants.ResponseModes.Fragment)
        {
            context.Response.SetNoCache();
            context.Response.Redirect(BuildRedirectUri());
        }
        else if (Response.Request.ResponseMode == OidcConstants.ResponseModes.FormPost)
        {
            context.Response.SetNoCache();
            AddSecurityHeaders(context);
            await context.Response.WriteHtmlAsync(GetFormPostHtml());
        }
        else
        {
            //_logger.LogError("Unsupported response mode.");
            throw new InvalidOperationException("Unsupported response mode");
        }
    }

    private void AddSecurityHeaders(HttpContext context)
    {
        context.Response.AddScriptCspHeaders(_options.Csp, "sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8=");

        var referrer_policy = "no-referrer";
        if (!context.Response.Headers.ContainsKey("Referrer-Policy"))
        {
            context.Response.Headers.Append("Referrer-Policy", referrer_policy);
        }
    }

    private string BuildRedirectUri()
    {
        var uri = Response.RedirectUri;
        var query = Response.ToNameValueCollection().ToQueryString();

        if (Response.Request.ResponseMode == OidcConstants.ResponseModes.Query)
        {
            uri = uri.AddQueryString(query);
        }
        else
        {
            uri = uri.AddHashFragment(query);
        }

        if (Response.IsError && !uri.Contains("#"))
        {
            // https://tools.ietf.org/html/draft-bradley-oauth-open-redirector-00
            uri += "#_=_";
        }

        return uri;
    }

    private const string FormPostHtml = "
    {body}
    ";

    private string GetFormPostHtml()
    {
        var html = FormPostHtml;

        var url = Response.Request.RedirectUri;
        url = HtmlEncoder.Default.Encode(url);
        html = html.Replace("{uri}", url);
        html = html.Replace("{body}", Response.ToNameValueCollection().ToFormPost());

        return html;
    }

    private async Task RedirectToErrorPageAsync(HttpContext context)
    {
        var errorModel = new ErrorMessage
        {
            RequestId = context.TraceIdentifier,
            Error = Response.Error,
            ErrorDescription = Response.ErrorDescription,
            UiLocales = Response.Request?.UiLocales,
            DisplayMode = Response.Request?.DisplayMode,
            ClientId = Response.Request?.ClientId
        };

        if (Response.RedirectUri != null && Response.Request?.ResponseMode != null)
        {
            // if we have a valid redirect uri, then include it to the error page
            errorModel.RedirectUri = BuildRedirectUri();
            errorModel.ResponseMode = Response.Request.ResponseMode;
        }

        var message = new Message(errorModel, _clock.UtcNow.UtcDateTime);
        var id = await _errorMessageStore.WriteAsync(message);

        var errorUrl = _options.UserInteraction.ErrorUrl;

        var url = errorUrl.AddQueryString(_options.UserInteraction.ErrorIdParameter, id);
        context.Response.RedirectToAbsoluteUrl(url);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/BadRequestResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class BadRequestResult : IEndpointResult
{
    public string Error { get; set; }
    public string ErrorDescription { get; set; }

    public BadRequestResult(string error = null, string errorDescription = null)
    {
        Error = error;
        ErrorDescription = errorDescription;
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        context.Response.StatusCode = 400;
        context.Response.SetNoCache();

        if (Error.IsPresent())
        {
            var dto = new ResultDto
            {
                error = Error,
                error_description = ErrorDescription
            };

            await context.Response.WriteJsonAsync(dto);
        }
    }

    internal class ResultDto
    {
        public string error { get; set; }
        public string error_description { get; set; }
    }    
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/CheckSessionResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class CheckSessionResult : IEndpointResult
{
    public CheckSessionResult()
    {
    }

    internal CheckSessionResult(IdentityServerOptions options)
    {
        _options = options;
    }

    private IdentityServerOptions _options;
    private static volatile string FormattedHtml;
    private static readonly object Lock = new object();
    private static volatile string LastCheckSessionCookieName;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        AddCspHeaders(context);

        var html = GetHtml(_options.Authentication.CheckSessionCookieName);
        await context.Response.WriteHtmlAsync(html);
    }

    private void AddCspHeaders(HttpContext context)
    {
        context.Response.AddScriptCspHeaders(_options.Csp, "sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI=");
    }
    private string GetHtml(string cookieName)
    {
        if (cookieName != LastCheckSessionCookieName)
        {
            lock (Lock)
            {
                if (cookieName != LastCheckSessionCookieName)
                {
                    FormattedHtml = Html.Replace("{cookieName}", cookieName);
                    LastCheckSessionCookieName = cookieName;
                }
            }
        }
        return FormattedHtml;
    }

    private const string Html = @"





    
    Check Session IFrame


    
    


";
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/ConsentPageResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for consent page
/// 
/// 
public class ConsentPageResult : IEndpointResult
{
    private readonly ValidatedAuthorizeRequest _request;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// request
    public ConsentPageResult(ValidatedAuthorizeRequest request)
    {
        _request = request ?? throw new ArgumentNullException(nameof(request));
    }

    internal ConsentPageResult(
        ValidatedAuthorizeRequest request,
        IdentityServerOptions options,
        IAuthorizationParametersMessageStore authorizationParametersMessageStore = null) 
        : this(request)
    {
        _options = options;
        _authorizationParametersMessageStore = authorizationParametersMessageStore;
    }

    private IdentityServerOptions _options;
    private IAuthorizationParametersMessageStore _authorizationParametersMessageStore;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
        _authorizationParametersMessageStore = _authorizationParametersMessageStore ?? context.RequestServices.GetService();
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        var returnUrl = context.GetIdentityServerBasePath().EnsureTrailingSlash() + Constants.ProtocolRoutePaths.AuthorizeCallback;
        if (_authorizationParametersMessageStore != null)
        {
            var msg = new Message>(_request.Raw.ToFullDictionary());
            var id = await _authorizationParametersMessageStore.WriteAsync(msg);
            returnUrl = returnUrl.AddQueryString(Constants.AuthorizationParamsStore.MessageStoreIdParameterName, id);
        }
        else
        {
            returnUrl = returnUrl.AddQueryString(_request.Raw.ToQueryString());
        }

        var consentUrl = _options.UserInteraction.ConsentUrl;
        if (!consentUrl.IsLocalUrl())
        {
            // this converts the relative redirect path to an absolute one if we're 
            // redirecting to a different server
            returnUrl = context.GetIdentityServerHost().EnsureTrailingSlash() + returnUrl.RemoveLeadingSlash();
        }

        var url = consentUrl.AddQueryString(_options.UserInteraction.ConsentReturnUrlParameter, returnUrl);
        context.Response.RedirectToAbsoluteUrl(url);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/CustomRedirectResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for a custom redirect
/// 
/// 
public class CustomRedirectResult : IEndpointResult
{
    private readonly ValidatedAuthorizeRequest _request;
    private readonly string _url;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// The URL.
    /// 
    /// request
    /// or
    /// url
    /// 
    public CustomRedirectResult(ValidatedAuthorizeRequest request, string url)
    {
        if (request == null) throw new ArgumentNullException(nameof(request));
        if (url.IsMissing()) throw new ArgumentNullException(nameof(url));

        _request = request;
        _url = url;
    }

    internal CustomRedirectResult(
        ValidatedAuthorizeRequest request,
        string url,
        IdentityServerOptions options) 
        : this(request, url)
    {
        _options = options;
    }

    private IdentityServerOptions _options;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        var returnUrl = context.GetIdentityServerBasePath().EnsureTrailingSlash() + Constants.ProtocolRoutePaths.Authorize;
        returnUrl = returnUrl.AddQueryString(_request.Raw.ToQueryString());

        if (!_url.IsLocalUrl())
        {
            // this converts the relative redirect path to an absolute one if we're 
            // redirecting to a different server
            returnUrl = context.GetIdentityServerBaseUrl().EnsureTrailingSlash() + returnUrl.RemoveLeadingSlash();
        }

        var url = _url.AddQueryString(_options.UserInteraction.CustomRedirectReturnUrlParameter, returnUrl);
        context.Response.RedirectToAbsoluteUrl(url);

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/DeviceAuthorizationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class DeviceAuthorizationResult : IEndpointResult
{
    public DeviceAuthorizationResponse Response { get; }

    public DeviceAuthorizationResult(DeviceAuthorizationResponse response)
    {
        Response = response ?? throw new ArgumentNullException(nameof(response));
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        context.Response.SetNoCache();

        var dto = new ResultDto
        {
            device_code = Response.DeviceCode,
            user_code = Response.UserCode,
            verification_uri = Response.VerificationUri,
            verification_uri_complete = Response.VerificationUriComplete,
            expires_in = Response.DeviceCodeLifetime,
            interval = Response.Interval
        };

        await context.Response.WriteJsonAsync(dto);
    }

    internal class ResultDto
    {
        public string device_code { get; set; }
        public string user_code { get; set; }
        public string verification_uri { get; set; }
        public string verification_uri_complete { get; set; }
        public int expires_in { get; set; }
        public int interval { get; set; }
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/DiscoveryDocumentResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for a discovery document
/// 
/// 
public class DiscoveryDocumentResult : IEndpointResult
{
    /// 
    /// Gets the entries.
    /// 
    /// 
    /// The entries.
    /// 
    public Dictionary Entries { get; }

    /// 
    /// Gets the maximum age.
    /// 
    /// 
    /// The maximum age.
    /// 
    public int? MaxAge { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The entries.
    /// The maximum age.
    /// entries
    public DiscoveryDocumentResult(Dictionary entries, int? maxAge)
    {
        Entries = entries ?? throw new ArgumentNullException(nameof(entries));
        MaxAge = maxAge;
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        if (MaxAge.HasValue && MaxAge.Value >= 0)
        {
            context.Response.SetCache(MaxAge.Value, "Origin");
        }

        return context.Response.WriteJsonAsync(Entries);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/EndSessionCallbackResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class EndSessionCallbackResult : IEndpointResult
{
    private readonly EndSessionCallbackValidationResult _result;

    public EndSessionCallbackResult(EndSessionCallbackValidationResult result)
    {
        _result = result ?? throw new ArgumentNullException(nameof(result));
    }

    internal EndSessionCallbackResult(
        EndSessionCallbackValidationResult result,
        IdentityServerOptions options)
        : this(result)
    {
        _options = options;
    }

    private IdentityServerOptions _options;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        if (_result.IsError)
        {
            context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
        }
        else
        {
            context.Response.SetNoCache();
            AddCspHeaders(context);

            var html = GetHtml();
            await context.Response.WriteHtmlAsync(html);
        }
    }

    private void AddCspHeaders(HttpContext context)
    {
        if (_options.Authentication.RequireCspFrameSrcForSignout)
        {
            string frameSources = null;
            var origins = _result.FrontChannelLogoutUrls?.Select(x => x.GetOrigin());
            if (origins != null && origins.Any())
            {
                frameSources = origins.Distinct().Aggregate((x, y) => $"{x} {y}");
            }

            // the hash matches the embedded style element being used below
            context.Response.AddStyleCspHeaders(_options.Csp, "sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY=", frameSources);
        }
    }

    private string GetHtml()
    {
        string framesHtml = null;

        if (_result.FrontChannelLogoutUrls != null && _result.FrontChannelLogoutUrls.Any())
        {
            var frameUrls = _result.FrontChannelLogoutUrls.Select(url => $"");
            framesHtml = frameUrls.Aggregate((x, y) => x + y);
        }

        return $"{framesHtml}";
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/EndSessionResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for endsession
/// 
/// 
public class EndSessionResult : IEndpointResult
{
    private readonly EndSessionValidationResult _result;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The result.
    /// result
    public EndSessionResult(EndSessionValidationResult result)
    {
        _result = result ?? throw new ArgumentNullException(nameof(result));
    }

    internal EndSessionResult(
        EndSessionValidationResult result,
        IdentityServerOptions options,
        ISystemClock clock,
        IMessageStore logoutMessageStore)
        : this(result)
    {
        _options = options;
        _clock = clock;
        _logoutMessageStore = logoutMessageStore;
    }

    private IdentityServerOptions _options;
    private ISystemClock _clock;
    private IMessageStore _logoutMessageStore;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
        _clock = _clock ?? context.RequestServices.GetRequiredService();
        _logoutMessageStore = _logoutMessageStore ?? context.RequestServices.GetRequiredService>();
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        var validatedRequest = _result.IsError ? null : _result.ValidatedRequest;

        string id = null;

        if (validatedRequest != null)
        {
            var logoutMessage = new LogoutMessage(validatedRequest);
            if (logoutMessage.ContainsPayload)
            {
                var msg = new Message(logoutMessage, _clock.UtcNow.UtcDateTime);
                id = await _logoutMessageStore.WriteAsync(msg);
            }
        }

        var redirect = _options.UserInteraction.LogoutUrl;

        if (redirect.IsLocalUrl())
        {
            redirect = context.GetIdentityServerRelativeUrl(redirect);
        }

        if (id != null)
        {
            redirect = redirect.AddQueryString(_options.UserInteraction.LogoutIdParameter, id);
        }

        context.Response.RedirectIfAllowed(redirect);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/IntrospectionResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for introspection
/// 
/// 
public class IntrospectionResult : IEndpointResult
{
    /// 
    /// Gets the result.
    /// 
    /// 
    /// The result.
    /// 
    public Dictionary Entries { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The result.
    /// result
    public IntrospectionResult(Dictionary entries)
    {
        Entries = entries ?? throw new ArgumentNullException(nameof(entries));
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        context.Response.SetNoCache();
        
        return context.Response.WriteJsonAsync(Entries);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/JsonWebKeysResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for the jwks document
/// 
/// 
public class JsonWebKeysResult : IEndpointResult
{
    /// 
    /// Gets the web keys.
    /// 
    /// 
    /// The web keys.
    /// 
    public IEnumerable WebKeys { get; }

    /// 
    /// Gets the maximum age.
    /// 
    /// 
    /// The maximum age.
    /// 
    public int? MaxAge { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The web keys.
    /// The maximum age.
    public JsonWebKeysResult(IEnumerable webKeys, int? maxAge)
    {
        WebKeys = webKeys ?? throw new ArgumentNullException(nameof(webKeys));
        MaxAge = maxAge;
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        if (MaxAge.HasValue && MaxAge.Value >= 0)
        {
            context.Response.SetCache(MaxAge.Value, "Origin");
        }

        return context.Response.WriteJsonAsync(new { keys = WebKeys }, "application/json; charset=UTF-8");
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/LoginPageResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for login page
/// 
/// 
public class LoginPageResult : IEndpointResult
{
    private readonly ValidatedAuthorizeRequest _request;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// request
    public LoginPageResult(ValidatedAuthorizeRequest request)
    {
        _request = request ?? throw new ArgumentNullException(nameof(request));
    }

    internal LoginPageResult(
        ValidatedAuthorizeRequest request,
        IdentityServerOptions options,
        IAuthorizationParametersMessageStore authorizationParametersMessageStore = null) 
        : this(request)
    {
        _options = options;
        _authorizationParametersMessageStore = authorizationParametersMessageStore;
    }

    private IdentityServerOptions _options;
    private IAuthorizationParametersMessageStore _authorizationParametersMessageStore;

    private void Init(HttpContext context)
    {
        _options = _options ?? context.RequestServices.GetRequiredService();
        _authorizationParametersMessageStore = _authorizationParametersMessageStore ?? context.RequestServices.GetService();
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public async Task ExecuteAsync(HttpContext context)
    {
        Init(context);

        var returnUrl = context.GetIdentityServerBasePath().EnsureTrailingSlash() + Constants.ProtocolRoutePaths.AuthorizeCallback;
        if (_authorizationParametersMessageStore != null)
        {
            var msg = new Message>(_request.Raw.ToFullDictionary());
            var id = await _authorizationParametersMessageStore.WriteAsync(msg);
            returnUrl = returnUrl.AddQueryString(Constants.AuthorizationParamsStore.MessageStoreIdParameterName, id);
        }
        else
        {
            returnUrl = returnUrl.AddQueryString(_request.Raw.ToQueryString());
        }

        var loginUrl = _options.UserInteraction.LoginUrl;
        if (!loginUrl.IsLocalUrl())
        {
            // this converts the relative redirect path to an absolute one if we're 
            // redirecting to a different server
            returnUrl = context.GetIdentityServerHost().EnsureTrailingSlash() + returnUrl.RemoveLeadingSlash();
        }

        var url = loginUrl.AddQueryString(_options.UserInteraction.LoginReturnUrlParameter, returnUrl);
        context.Response.RedirectToAbsoluteUrl(url);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/ProtectedResourceErrorResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.Net.Http.Headers;

namespace IdentityServer8.Endpoints.Results;

internal class ProtectedResourceErrorResult : IEndpointResult
{
    public string Error;
    public string ErrorDescription;

    public ProtectedResourceErrorResult(string error, string errorDescription = null)
    {
        Error = error;
        ErrorDescription = errorDescription;
    }

    public Task ExecuteAsync(HttpContext context)
    {
        context.Response.StatusCode = 401;
        context.Response.SetNoCache();

        if (Constants.ProtectedResourceErrorStatusCodes.ContainsKey(Error))
        {
            context.Response.StatusCode = Constants.ProtectedResourceErrorStatusCodes[Error];
        }

        if (Error == OidcConstants.ProtectedResourceErrors.ExpiredToken)
        {
            Error = OidcConstants.ProtectedResourceErrors.InvalidToken;
            ErrorDescription = "The access token expired";
        }

        var errorString = string.Format($"error=\"{Error}\"");
        if (ErrorDescription.IsMissing())
        {
            context.Response.Headers.Append(HeaderNames.WWWAuthenticate, new StringValues(new[] { "Bearer realm=\"IdentityServer\"", errorString }).ToString());
        }
        else
        {
            var errorDescriptionString = string.Format($"error_description=\"{ErrorDescription}\"");
            context.Response.Headers.Append(HeaderNames.WWWAuthenticate, new StringValues(new[] { "Bearer realm=\"IdentityServer\"", errorString, errorDescriptionString }).ToString());
        }

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/StatusCodeResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for a raw HTTP status code
/// 
/// 
public class StatusCodeResult : IEndpointResult
{
    /// 
    /// Gets the status code.
    /// 
    /// 
    /// The status code.
    /// 
    public int StatusCode { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The status code.
    public StatusCodeResult(HttpStatusCode statusCode)
    {
        StatusCode = (int)statusCode;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The status code.
    public StatusCodeResult(int statusCode)
    {
        StatusCode = statusCode;
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        context.Response.StatusCode = StatusCode;

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/TokenErrorResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonExtensionDataAttribute = System.Text.Json.Serialization.JsonExtensionDataAttribute;


namespace IdentityServer8.Endpoints.Results;

internal class TokenErrorResult : IEndpointResult
{
    public TokenErrorResponse Response { get; }

    public TokenErrorResult(TokenErrorResponse error)
    {
        if (error.Error.IsMissing()) throw new ArgumentNullException(nameof(error.Error), "Error must be set");

        Response = error;
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        context.Response.StatusCode = 400;
        context.Response.SetNoCache();

        var dto = new ResultDto
        {
            error = Response.Error,
            error_description = Response.ErrorDescription,
            
            custom = Response.Custom
        };

        await context.Response.WriteJsonAsync(dto);
    }

    internal class ResultDto
    {
        public string error { get; set; }
        public string error_description { get; set; }

        [JsonExtensionData]
        public Dictionary custom { get; set; }
    }    
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/TokenResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonExtensionDataAttribute = System.Text.Json.Serialization.JsonExtensionDataAttribute;
using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServer8.Endpoints.Results;

internal class TokenResult : IEndpointResult
{
    public TokenResponse Response { get; set; }

    public TokenResult(TokenResponse response)
    {
        Response = response ?? throw new ArgumentNullException(nameof(response));
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        context.Response.SetNoCache();

        var dto = new ResultDto
        {
            id_token = Response.IdentityToken,
            access_token = Response.AccessToken,
            refresh_token = Response.RefreshToken,
            expires_in = Response.AccessTokenLifetime,
            token_type = OidcConstants.TokenResponse.BearerTokenType,
            scope = Response.Scope,

            Custom = Response.Custom
        };

        await context.Response.WriteJsonAsync(dto);
    }

    internal class ResultDto
    {
        public string id_token { get; set; }
        public string access_token { get; set; }
        public int expires_in { get; set; }
        public string token_type { get; set; }
        public string refresh_token { get; set; }
        public string scope { get; set; }

        [JsonExtensionData]
        public Dictionary? Custom { get; set; }
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/TokenRevocationErrorResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

/// 
/// Result for revocation error
/// 
/// 
public class TokenRevocationErrorResult : IEndpointResult
{
    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The error.
    public TokenRevocationErrorResult(string error)
    {
        Error = error;
    }

    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    public Task ExecuteAsync(HttpContext context)
    {
        context.Response.StatusCode = (int)HttpStatusCode.BadRequest;
        return context.Response.WriteJsonAsync(new { error = Error });
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/Results/UserInfoResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints.Results;

internal class UserInfoResult : IEndpointResult
{
    public Dictionary Claims;

    public UserInfoResult(Dictionary claims)
    {
        Claims = claims;
    }

    public async Task ExecuteAsync(HttpContext context)
    {
        context.Response.SetNoCache();
        await context.Response.WriteJsonAsync(Claims);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/TokenEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

/// 
/// The token endpoint
/// 
/// 
internal class TokenEndpoint : IEndpointHandler
{
    private readonly IClientSecretValidator _clientValidator;
    private readonly ITokenRequestValidator _requestValidator;
    private readonly ITokenResponseGenerator _responseGenerator;
    private readonly IEventService _events;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The client validator.
    /// The request validator.
    /// The response generator.
    /// The events.
    /// The logger.
    public TokenEndpoint(
        IClientSecretValidator clientValidator, 
        ITokenRequestValidator requestValidator, 
        ITokenResponseGenerator responseGenerator, 
        IEventService events, 
        ILogger logger)
    {
        _clientValidator = clientValidator;
        _requestValidator = requestValidator;
        _responseGenerator = responseGenerator;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing token request.");

        // validate HTTP
        if (!HttpMethods.IsPost(context.Request.Method) || !context.Request.HasApplicationFormContentType())
        {
            _logger.LogWarning("Invalid HTTP request for token endpoint");
            return Error(OidcConstants.TokenErrors.InvalidRequest);
        }

        return await ProcessTokenRequestAsync(context);
    }

    private async Task ProcessTokenRequestAsync(HttpContext context)
    {
        _logger.LogDebug("Start token request.");

        // validate client
        var clientResult = await _clientValidator.ValidateAsync(context);

        if (clientResult.Client == null)
        {
            return Error(OidcConstants.TokenErrors.InvalidClient);
        }

        // validate request
        var form = (await context.Request.ReadFormAsync()).AsNameValueCollection();
        _logger.LogTrace("Calling into token request validator: {type}", _requestValidator.GetType().FullName);
        var requestResult = await _requestValidator.ValidateRequestAsync(form, clientResult);

        if (requestResult.IsError)
        {
            await _events.RaiseAsync(new TokenIssuedFailureEvent(requestResult));
            return Error(requestResult.Error, requestResult.ErrorDescription, requestResult.CustomResponse);
        }

        // create response
        _logger.LogTrace("Calling into token request response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.ProcessAsync(requestResult);

        await _events.RaiseAsync(new TokenIssuedSuccessEvent(response, requestResult));
        LogTokens(response, requestResult);

        // return result
        _logger.LogDebug("Token request success.");
        return new TokenResult(response);
    }

    private TokenErrorResult Error(string error, string errorDescription = null, Dictionary custom = null)
    {
        var response = new TokenErrorResponse
        {
            Error = error,
            ErrorDescription = errorDescription,
            Custom = custom
        };

        return new TokenErrorResult(response);
    }

    private void LogTokens(TokenResponse response, TokenRequestValidationResult requestResult)
    {
        var clientId = $"{requestResult.ValidatedRequest.Client.ClientId} ({requestResult.ValidatedRequest.Client?.ClientName ?? "no name set"})";
        var subjectId = requestResult.ValidatedRequest.Subject?.GetSubjectId() ?? "no subject";

        if (response.IdentityToken != null)
        {
            _logger.LogTrace("Identity token issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.IdentityToken);
        }
        if (response.RefreshToken != null)
        {
            _logger.LogTrace("Refresh token issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.RefreshToken);
        }
        if (response.AccessToken != null)
        {
            _logger.LogTrace("Access token issued for {clientId} / {subjectId}: {token}", clientId, subjectId, response.AccessToken);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/TokenRevocationEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

/// 
/// The revocation endpoint
/// 
/// 
internal class TokenRevocationEndpoint : IEndpointHandler
{
    private readonly ILogger _logger;
    private readonly IClientSecretValidator _clientValidator;
    private readonly ITokenRevocationRequestValidator _requestValidator;
    private readonly ITokenRevocationResponseGenerator _responseGenerator;
    private readonly IEventService _events;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    /// The client validator.
    /// The request validator.
    /// The response generator.
    /// The events.
    public TokenRevocationEndpoint(ILogger logger,
        IClientSecretValidator clientValidator,
        ITokenRevocationRequestValidator requestValidator,
        ITokenRevocationResponseGenerator responseGenerator,
        IEventService events)
    {
        _logger = logger;
        _clientValidator = clientValidator;
        _requestValidator = requestValidator;
        _responseGenerator = responseGenerator;

        _events = events;
    }

    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    public async Task ProcessAsync(HttpContext context)
    {
        _logger.LogTrace("Processing revocation request.");

        if (!HttpMethods.IsPost(context.Request.Method))
        {
            _logger.LogWarning("Invalid HTTP method");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        if (!context.Request.HasApplicationFormContentType())
        {
            _logger.LogWarning("Invalid media type");
            return new StatusCodeResult(HttpStatusCode.UnsupportedMediaType);
        }

        var response = await ProcessRevocationRequestAsync(context);

        return response;
    }

    private async Task ProcessRevocationRequestAsync(HttpContext context)
    {
        _logger.LogDebug("Start revocation request.");

        // validate client
        var clientValidationResult = await _clientValidator.ValidateAsync(context);

        if (clientValidationResult.IsError)
        {
            return new TokenRevocationErrorResult(OidcConstants.TokenErrors.InvalidClient);
        }

        _logger.LogTrace("Client validation successful");

        // validate the token request
        var form = (await context.Request.ReadFormAsync()).AsNameValueCollection();

        _logger.LogTrace("Calling into token revocation request validator: {type}", _requestValidator.GetType().FullName);
        var requestValidationResult = await _requestValidator.ValidateRequestAsync(form, clientValidationResult.Client);

        if (requestValidationResult.IsError)
        {
            return new TokenRevocationErrorResult(requestValidationResult.Error);
        }

        _logger.LogTrace("Calling into token revocation response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.ProcessAsync(requestValidationResult);

        if (response.Success)
        {
            _logger.LogInformation("Token revocation complete");
            await _events.RaiseAsync(new TokenRevokedSuccessEvent(requestValidationResult, requestValidationResult.Client));
        }
        else
        {
            _logger.LogInformation("No matching token found");
        }

        if (response.Error.IsPresent()) return new TokenRevocationErrorResult(response.Error);

        return new StatusCodeResult(HttpStatusCode.OK);
    }
}


================================================
FILE: src/IdentityServer8/src/Endpoints/UserInfoEndpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Endpoints;

/// 
/// The userinfo endpoint
/// 
/// 
internal class UserInfoEndpoint : IEndpointHandler
{
    private readonly BearerTokenUsageValidator _tokenUsageValidator;
    private readonly IUserInfoRequestValidator _requestValidator;
    private readonly IUserInfoResponseGenerator _responseGenerator;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The token usage validator.
    /// The request validator.
    /// The response generator.
    /// The logger.
    public UserInfoEndpoint(
        BearerTokenUsageValidator tokenUsageValidator, 
        IUserInfoRequestValidator requestValidator, 
        IUserInfoResponseGenerator responseGenerator, 
        ILogger logger)
    {
        _tokenUsageValidator = tokenUsageValidator;
        _requestValidator = requestValidator;
        _responseGenerator = responseGenerator;
        _logger = logger;
    }

    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    public async Task ProcessAsync(HttpContext context)
    {
        if (!HttpMethods.IsGet(context.Request.Method) && !HttpMethods.IsPost(context.Request.Method))
        {
            _logger.LogWarning("Invalid HTTP method for userinfo endpoint.");
            return new StatusCodeResult(HttpStatusCode.MethodNotAllowed);
        }

        return await ProcessUserInfoRequestAsync(context);
    }

    private async Task ProcessUserInfoRequestAsync(HttpContext context)
    {
        _logger.LogDebug("Start userinfo request");

        // userinfo requires an access token on the request
        var tokenUsageResult = await _tokenUsageValidator.ValidateAsync(context);
        if (tokenUsageResult.TokenFound == false)
        {
            var error = "No access token found.";

            _logger.LogError(error);
            return Error(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        // validate the request
        _logger.LogTrace("Calling into userinfo request validator: {type}", _requestValidator.GetType().FullName);
        var validationResult = await _requestValidator.ValidateRequestAsync(tokenUsageResult.Token);

        if (validationResult.IsError)
        {
            //_logger.LogError("Error validating  validationResult.Error);
            return Error(validationResult.Error);
        }

        // generate response
        _logger.LogTrace("Calling into userinfo response generator: {type}", _responseGenerator.GetType().FullName);
        var response = await _responseGenerator.ProcessAsync(validationResult);

        _logger.LogDebug("End userinfo request");
        return new UserInfoResult(response);
    }

    private IEndpointResult Error(string error, string description = null)
    {
        return new ProtectedResourceErrorResult(error, description);
    }
}


================================================
FILE: src/IdentityServer8/src/Events/ApiAuthenticationFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for failed API authentication
/// 
/// 
public class ApiAuthenticationFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// Name of the API.
    /// The message.
    public ApiAuthenticationFailureEvent(string apiName, string message)
        : base(EventCategories.Authentication, 
              "API Authentication Failure",
              EventTypes.Failure, 
              EventIds.ApiAuthenticationFailure, 
              message)
    {
        ApiName = apiName;
    }

    /// 
    /// Gets or sets the name of the API.
    /// 
    /// 
    /// The name of the API.
    /// 
    public string ApiName { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/ApiAuthenticationSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful API authentication
/// 
/// 
public class ApiAuthenticationSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// Name of the API.
    /// The authentication method.
    public ApiAuthenticationSuccessEvent(string apiName, string authenticationMethod)
        : base(EventCategories.Authentication, 
              "API Authentication Success",
              EventTypes.Success, 
              EventIds.ApiAuthenticationSuccess)
    {
        ApiName = apiName;
        AuthenticationMethod = authenticationMethod;
    }

    /// 
    /// Gets or sets the name of the API.
    /// 
    /// 
    /// The name of the API.
    /// 
    public string ApiName { get; set; }

    /// 
    /// Gets or sets the authentication method.
    /// 
    /// 
    /// The authentication method.
    /// 
    public string AuthenticationMethod { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/ClientAuthenticationFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for failed client authentication
/// 
/// 
public class ClientAuthenticationFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The client identifier.
    /// The message.
    public ClientAuthenticationFailureEvent(string clientId, string message)
        : base(EventCategories.Authentication, 
              "Client Authentication Failure",
              EventTypes.Failure, 
              EventIds.ClientAuthenticationFailure, 
              message)
    {
        ClientId = clientId;
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/ClientAuthenticationSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful client authentication
/// 
/// 
public class ClientAuthenticationSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The client identifier.
    /// The authentication method.
    public ClientAuthenticationSuccessEvent(string clientId, string authenticationMethod)
        : base(EventCategories.Authentication, 
              "Client Authentication Success",
              EventTypes.Success, 
              EventIds.ClientAuthenticationSuccess)
    {
        ClientId = clientId;
        AuthenticationMethod = authenticationMethod;
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the authentication method.
    /// 
    /// 
    /// The authentication method.
    /// 
    public string AuthenticationMethod { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/ConsentDeniedEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for denied consent.
/// 
/// 
public class ConsentDeniedEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// The requested scopes.
    public ConsentDeniedEvent(string subjectId, string clientId, IEnumerable requestedScopes)
        : base(EventCategories.Grants,
              "Consent denied",
              EventTypes.Information,
              EventIds.ConsentDenied)
    {
        SubjectId = subjectId;
        ClientId = clientId;
        RequestedScopes = requestedScopes;
    }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the client ID.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The requested scopes.
    /// 
    public IEnumerable RequestedScopes { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/ConsentGrantedEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for granted consent.
/// 
/// 
public class ConsentGrantedEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// The requested scopes.
    /// The granted scopes.
    /// if set to true consent was remembered.
    public ConsentGrantedEvent(string subjectId, string clientId, IEnumerable requestedScopes, IEnumerable grantedScopes, bool consentRemembered)
        : base(EventCategories.Grants,
              "Consent granted",
              EventTypes.Information,
              EventIds.ConsentGranted)
    {
        SubjectId = subjectId;
        ClientId = clientId;
        RequestedScopes = requestedScopes;
        GrantedScopes = grantedScopes;
        ConsentRemembered = consentRemembered;
    }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the client ID.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The requested scopes.
    /// 
    public IEnumerable RequestedScopes { get; set; }

    /// 
    /// Gets or sets the granted scopes.
    /// 
    /// 
    /// The granted scopes.
    /// 
    public IEnumerable GrantedScopes { get; set; }

    /// 
    /// Gets or sets a value indicating whether consent was remembered.
    /// 
    /// 
    ///   true if consent was remembered; otherwise, false.
    /// 
    public bool ConsentRemembered { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/DeviceAuthorizationFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for device authorization failure
/// 
/// 
public class DeviceAuthorizationFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The result.
    public DeviceAuthorizationFailureEvent(DeviceAuthorizationRequestValidationResult result)
        : this()
    {
        if (result.ValidatedRequest != null)
        {
            ClientId = result.ValidatedRequest.Client?.ClientId;
            ClientName = result.ValidatedRequest.Client?.ClientName;
            Scopes = result.ValidatedRequest.RequestedScopes?.ToSpaceSeparatedString();
            
        }

        Endpoint = Constants.EndpointNames.DeviceAuthorization;
        Error = result.Error;
        ErrorDescription = result.ErrorDescription;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public DeviceAuthorizationFailureEvent()
        : base(EventCategories.DeviceFlow,
            "Device Authorization Failure",
            EventTypes.Failure,
            EventIds.DeviceAuthorizationFailure)
    {
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }

    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public string Scopes { get; set; }
    
    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/DeviceAuthorizationSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for device authorization failure
/// 
/// 
public class DeviceAuthorizationSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The response.
    /// The request.
    public DeviceAuthorizationSuccessEvent(DeviceAuthorizationResponse response, DeviceAuthorizationRequestValidationResult request)
        : this()
    {
        ClientId = request.ValidatedRequest.Client?.ClientId;
        ClientName = request.ValidatedRequest.Client?.ClientName;
        Endpoint = Constants.EndpointNames.DeviceAuthorization;
        Scopes = request.ValidatedRequest.ValidatedResources?.RawScopeValues.ToSpaceSeparatedString();
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    protected DeviceAuthorizationSuccessEvent()
        : base(EventCategories.DeviceFlow,
            "Device Authorization Success",
            EventTypes.Success,
            EventIds.DeviceAuthorizationSuccess)
    {
    }


    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }

    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public string Scopes { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/GrantsRevokedEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for revoked grants.
/// 
/// 
public class GrantsRevokedEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject identifier.
    /// The client identifier.
    public GrantsRevokedEvent(string subjectId, string clientId)
        : base(EventCategories.Grants,
              "Grants revoked",
              EventTypes.Information,
              EventIds.GrantsRevoked)
    {
        SubjectId = subjectId;
        ClientId = clientId;
    }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the client ID.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/Infrastructure/Event.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Models base class for events raised from IdentityServer.
/// 
public abstract class Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The category.
    /// The name.
    /// The type.
    /// The identifier.
    /// The message.
    /// category
    protected Event(string category, string name, EventTypes type, int id, string message = null)
    {
        Category = category ?? throw new ArgumentNullException(nameof(category));
        Name = name ?? throw new ArgumentNullException(nameof(name));

        EventType = type;
        Id = id;
        Message = message;
    }

    /// 
    /// Allows implementing custom initialization logic.
    /// 
    /// 
    protected internal virtual Task PrepareAsync()
    {
        return Task.CompletedTask;
    }

    /// 
    /// Gets or sets the category.
    /// 
    /// 
    /// The category.
    /// 
    public string Category { get; set; }

    /// 
    /// Gets or sets the name.
    /// 
    /// 
    /// The name.
    /// 
    public string Name { get; set; }

    /// 
    /// Gets or sets the event type.
    /// 
    /// 
    /// The type of the event.
    /// 
    public EventTypes EventType { get; set; }

    /// 
    /// Gets or sets the identifier.
    /// 
    /// 
    /// The identifier.
    /// 
    public int Id { get; set; }

    /// 
    /// Gets or sets the event message.
    /// 
    /// 
    /// The message.
    /// 
    public string Message { get; set; }

    /// 
    /// Gets or sets the per-request activity identifier.
    /// 
    /// 
    /// The activity identifier.
    /// 
    public string ActivityId { get; set; }

    /// 
    /// Gets or sets the time stamp when the event was raised.
    /// 
    /// 
    /// The time stamp.
    /// 
    public DateTime TimeStamp { get; set; }

    /// 
    /// Gets or sets the server process identifier.
    /// 
    /// 
    /// The process identifier.
    /// 
    public int ProcessId { get; set; }

    /// 
    /// Gets or sets the local ip address of the current request.
    /// 
    /// 
    /// The local ip address.
    /// 
    public string LocalIpAddress { get; set; }

    /// 
    /// Gets or sets the remote ip address of the current request.
    /// 
    /// 
    /// The remote ip address.
    /// 
    public string RemoteIpAddress { get; set; }

    /// 
    /// Obfuscates a token.
    /// 
    /// The token.
    /// 
    protected static string Obfuscate(string value)
    {
        var last4Chars = "****";
        if (value.IsPresent() && value.Length > 4)
        {
            last4Chars = value.Substring(value.Length - 4);
        }

        return "****" + last4Chars;
    }

    /// 
    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Events/Infrastructure/EventCategories.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Categories for events
/// 
public static class EventCategories
{
    /// 
    /// Authentication related events
    /// 
    public const string Authentication = "Authentication";

    /// 
    /// Token related events
    /// 
    public const string Token = "Token";

    /// 
    /// Grants related events
    /// 
    public const string Grants = "Grants";

    /// 
    /// Error related events
    /// 
    public const string Error = "Error";

    /// 
    /// Device flow related events
    /// 
    public const string DeviceFlow = "Device";
}


================================================
FILE: src/IdentityServer8/src/Events/Infrastructure/EventIds.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Events;

public static class EventIds
{
    //////////////////////////////////////////////////////
    /// Authentication related events
    //////////////////////////////////////////////////////
    private const int AuthenticationEventsStart = 1000;

    public const int UserLoginSuccess = AuthenticationEventsStart + 0;
    public const int UserLoginFailure = AuthenticationEventsStart + 1;
    public const int UserLogoutSuccess = AuthenticationEventsStart + 2;

    public const int ClientAuthenticationSuccess = AuthenticationEventsStart + 10;
    public const int ClientAuthenticationFailure = AuthenticationEventsStart + 11;
    
    public const int ApiAuthenticationSuccess = AuthenticationEventsStart + 20;
    public const int ApiAuthenticationFailure = AuthenticationEventsStart + 21;

    //////////////////////////////////////////////////////
    /// Token related events
    //////////////////////////////////////////////////////
    private const int TokenEventsStart = 2000;

    public const int TokenIssuedSuccess = TokenEventsStart + 0;
    public const int TokenIssuedFailure = TokenEventsStart + 1;

    public const int TokenRevokedSuccess = TokenEventsStart + 10;

    public const int TokenIntrospectionSuccess = TokenEventsStart + 20;
    public const int TokenIntrospectionFailure = TokenEventsStart + 21;
    
    //////////////////////////////////////////////////////
    /// Error related events
    //////////////////////////////////////////////////////
    private const int ErrorEventsStart = 3000;

    public const int UnhandledException = ErrorEventsStart + 0;
    public const int InvalidClientConfiguration = ErrorEventsStart + 1;

    //////////////////////////////////////////////////////
    /// Grants related events
    //////////////////////////////////////////////////////
    private const int GrantsEventsStart = 4000;

    public const int ConsentGranted = GrantsEventsStart + 0;
    public const int ConsentDenied = GrantsEventsStart + 1;
    public const int GrantsRevoked = GrantsEventsStart + 2;

    private const int DeviceFlowEventsStart = 5000;

    public const int DeviceAuthorizationSuccess = DeviceFlowEventsStart + 0;
    public const int DeviceAuthorizationFailure = DeviceFlowEventsStart + 1;
}


================================================
FILE: src/IdentityServer8/src/Events/Infrastructure/EventType.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Indicates if the event is a success or fail event.
/// 
public enum EventTypes
{
    /// 
    /// Success event
    /// 
    Success = 1,

    /// 
    /// Failure event
    /// 
    Failure = 2,

    /// 
    /// Information event
    /// 
    Information = 3,
    
    /// 
    /// Error event
    /// 
    Error = 4
}


================================================
FILE: src/IdentityServer8/src/Events/InvalidClientConfiguration.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for unhandled exceptions
/// 
/// 
public class InvalidClientConfigurationEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The client.
    /// The error message.
    public InvalidClientConfigurationEvent(Client client, string errorMessage)
        : base(EventCategories.Error,
              "Invalid Client Configuration",
              EventTypes.Error, 
              EventIds.InvalidClientConfiguration,
              errorMessage)
    {
        ClientId = client.ClientId;
        ClientName = client.ClientName ?? "unknown name";
    }

    /// 
    /// Gets or sets the client ID.
    /// 
    /// 
    /// The details.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/TokenIntrospectionFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for failed token introspection
/// 
/// 
public class TokenIntrospectionFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// Name of the API.
    /// The error message.
    /// The token.
    /// The API scopes.
    /// The token scopes.
    public TokenIntrospectionFailureEvent(string apiName, string errorMessage, string token = null, IEnumerable apiScopes = null, IEnumerable tokenScopes = null)
        : base(EventCategories.Token,
              "Token Introspection Failure",
              EventTypes.Failure,
              EventIds.TokenIntrospectionFailure,
              errorMessage)
    {
        ApiName = apiName;

        if (token.IsPresent())
        {
            Token = Obfuscate(token);
        }

        if (apiScopes != null)
        {
            ApiScopes = apiScopes;
        }

        if (tokenScopes != null)
        {
            TokenScopes = tokenScopes;
        }
    }

    /// 
    /// Gets or sets the name of the API.
    /// 
    /// 
    /// The name of the API.
    /// 
    public string ApiName { get; set; }

    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }

    /// 
    /// Gets or sets the API scopes.
    /// 
    /// 
    /// The API scopes.
    /// 
    public IEnumerable ApiScopes { get; set; }

    /// 
    /// Gets or sets the token scopes.
    /// 
    /// 
    /// The token scopes.
    /// 
    public IEnumerable TokenScopes { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/TokenIntrospectionSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful token introspection
/// 
/// 
public class TokenIntrospectionSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The result.
    public TokenIntrospectionSuccessEvent(IntrospectionRequestValidationResult result)
        : base(EventCategories.Token,
              "Token Introspection Success",
              EventTypes.Success,
              EventIds.TokenIntrospectionSuccess)
    {
        ApiName = result.Api.Name;
        IsActive = result.IsActive;

        if (result.Token.IsPresent())
        {
            Token = Obfuscate(result.Token);
        }
        
        if (!result.Claims.EnumerableIsNullOrEmpty())
        {
            ClaimTypes = result.Claims.Select(c => c.Type).Distinct();
            TokenScopes = result.Claims.Where(c => c.Type == "scope").Select(c => c.Value);
        }
    }

    /// 
    /// Gets or sets the name of the API.
    /// 
    /// 
    /// The name of the API.
    /// 
    public string ApiName { get; set; }

    /// 
    /// Gets or sets a value indicating whether this instance is active.
    /// 
    /// 
    ///   true if this instance is active; otherwise, false.
    /// 
    public bool IsActive { get; set; }

    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }

    /// 
    /// Gets or sets the claim types.
    /// 
    /// 
    /// The claim types.
    /// 
    public IEnumerable ClaimTypes { get; set; }

    /// 
    /// Gets or sets the token scopes.
    /// 
    /// 
    /// The token scopes.
    /// 
    public IEnumerable TokenScopes { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/TokenIssuedFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for failed token issuance
/// 
/// 
public class TokenIssuedFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// The error.
    /// The description.
    public TokenIssuedFailureEvent(ValidatedAuthorizeRequest request, string error, string description)
        : this()
    {
        if (request != null)
        {
            ClientId = request.ClientId;
            ClientName = request.Client?.ClientName;
            RedirectUri = request.RedirectUri;
            Scopes = request.RequestedScopes?.ToSpaceSeparatedString();
            GrantType = request.GrantType;

            if (request.Subject != null && request.Subject.Identity.IsAuthenticated)
            {
                SubjectId = request.Subject?.GetSubjectId();
            }
        }

        Endpoint = EndpointNames.Authorize;
        Error = error;
        ErrorDescription = description;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The result.
    public TokenIssuedFailureEvent(TokenRequestValidationResult result)
        : this()
    {
        if (result.ValidatedRequest != null)
        {
            ClientId = result.ValidatedRequest.Client.ClientId;
            ClientName = result.ValidatedRequest.Client.ClientName;
            GrantType = result.ValidatedRequest.GrantType;
            Scopes = result.ValidatedRequest.RequestedScopes?.ToSpaceSeparatedString();

            if (result.ValidatedRequest.Subject != null && result.ValidatedRequest.Subject.Identity.IsAuthenticated)
            {
                SubjectId = result.ValidatedRequest.Subject.GetSubjectId();
            }
        }

        Endpoint = EndpointNames.Token;
        Error = result.Error;
        ErrorDescription = result.ErrorDescription;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    protected TokenIssuedFailureEvent()
        : base(EventCategories.Token,
              "Token Issued Failure",
              EventTypes.Failure,
              EventIds.TokenIssuedFailure)
    {
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the redirect URI.
    /// 
    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public string Scopes { get; set; }

    /// 
    /// Gets or sets the grant type.
    /// 
    /// 
    /// The grant type.
    /// 
    public string GrantType { get; set; }

    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/TokenIssuedSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful token issuance
/// 
/// 
public class TokenIssuedSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The response.
    public TokenIssuedSuccessEvent(AuthorizeResponse response)
        : this()
    {
        ClientId = response.Request.ClientId;
        ClientName = response.Request.Client.ClientName;
        RedirectUri = response.RedirectUri;
        Endpoint = EndpointNames.Authorize;
        SubjectId = response.Request.Subject.GetSubjectId();
        Scopes = response.Scope;
        GrantType = response.Request.GrantType;

        var tokens = new List();
        if (response.IdentityToken != null)
        {
            tokens.Add(new Token(OidcConstants.TokenTypes.IdentityToken, response.IdentityToken));
        }
        if (response.Code != null)
        {
            tokens.Add(new Token(OidcConstants.ResponseTypes.Code, response.Code));
        }
        if (response.AccessToken != null)
        {
            tokens.Add(new Token(OidcConstants.TokenTypes.AccessToken, response.AccessToken));
        }
        Tokens = tokens;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The response.
    /// The request.
    public TokenIssuedSuccessEvent(TokenResponse response, TokenRequestValidationResult request)
        : this()
    {
        ClientId = request.ValidatedRequest.Client.ClientId;
        ClientName = request.ValidatedRequest.Client.ClientName;
        Endpoint = EndpointNames.Token;
        SubjectId = request.ValidatedRequest.Subject?.GetSubjectId();
        GrantType = request.ValidatedRequest.GrantType;

        if (GrantType == OidcConstants.GrantTypes.RefreshToken)
        {
            Scopes = request.ValidatedRequest.RefreshToken.AccessToken.Scopes.ToSpaceSeparatedString();
        }
        else if (GrantType == OidcConstants.GrantTypes.AuthorizationCode)
        {
            Scopes = request.ValidatedRequest.AuthorizationCode.RequestedScopes.ToSpaceSeparatedString();
        }
        else
        {
            Scopes = request.ValidatedRequest.ValidatedResources?.RawScopeValues.ToSpaceSeparatedString();
        }

        var tokens = new List();
        if (response.IdentityToken != null)
        {
            tokens.Add(new Token(OidcConstants.TokenTypes.IdentityToken, response.IdentityToken));
        }
        if (response.RefreshToken != null)
        {
            tokens.Add(new Token(OidcConstants.TokenTypes.RefreshToken, response.RefreshToken));
        }
        if (response.AccessToken != null)
        {
            tokens.Add(new Token(OidcConstants.TokenTypes.AccessToken, response.AccessToken));
        }
        Tokens = tokens;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    protected TokenIssuedSuccessEvent()
        : base(EventCategories.Token,
              "Token Issued Success",
              EventTypes.Success,
              EventIds.TokenIssuedSuccess)
    {
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the redirect URI.
    /// 
    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public string Scopes { get; set; }

    /// 
    /// Gets or sets the grant type.
    /// 
    /// 
    /// The grant type.
    /// 
    public string GrantType { get; set; }

    /// 
    /// Gets or sets the tokens.
    /// 
    /// 
    /// The tokens.
    /// 
    public IEnumerable Tokens { get; set; }

    /// 
    /// Data structure serializing issued tokens
    /// 
    public class Token
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        /// The type.
        /// The value.
        public Token(string type, string value)
        {
            TokenType = type;
            TokenValue = Obfuscate(value);
        }

        /// 
        /// Gets the type of the token.
        /// 
        /// 
        /// The type of the token.
        /// 
        public string TokenType { get; }

        /// 
        /// Gets the token value.
        /// 
        /// 
        /// The token value.
        /// 
        public string TokenValue { get; }
    }
}


================================================
FILE: src/IdentityServer8/src/Events/TokenRevokedSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful token revocation
/// 
/// 
public class TokenRevokedSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request result.
    /// The client.
    public TokenRevokedSuccessEvent(TokenRevocationRequestValidationResult requestResult, Client client)
        : base(EventCategories.Token,
              "Token Revoked Success",
              EventTypes.Success,
              EventIds.TokenRevokedSuccess)
    {
        ClientId = client.ClientId;
        ClientName = client.ClientName;
        TokenType = requestResult.TokenTypeHint;
        Token = Obfuscate(requestResult.Token);
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the name of the client.
    /// 
    /// 
    /// The name of the client.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the type of the token.
    /// 
    /// 
    /// The type of the token.
    /// 
    public string TokenType { get; set; }

    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/UnhandledExceptionEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for unhandled exceptions
/// 
/// 
public class UnhandledExceptionEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The ex.
    public UnhandledExceptionEvent(Exception ex)
        : base(EventCategories.Error,
              "Unhandled Exception",
              EventTypes.Error, 
              EventIds.UnhandledException,
              ex.Message)
    {
        Details = ex.ToString();
    }

    /// 
    /// Gets or sets the details.
    /// 
    /// 
    /// The details.
    /// 
    public string Details { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/UserLoginFailureEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for failed user authentication
/// 
/// 
public class UserLoginFailureEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The username.
    /// The error.
    /// Specifies if login was interactive
    /// The client id
    public UserLoginFailureEvent(string username, string error, bool interactive = true, string clientId = null)
        : base(EventCategories.Authentication,
              "User Login Failure",
              EventTypes.Failure, 
              EventIds.UserLoginFailure,
              error)
    {
        Username = username;
        ClientId = clientId;

        if (interactive)
        {
            Endpoint = "UI";
        }
        else
        {
            Endpoint = EndpointNames.Token;
        }
    }

    /// 
    /// Gets or sets the username.
    /// 
    /// 
    /// The username.
    /// 
    public string Username { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }

    /// 
    /// Gets or sets the client id.
    /// 
    /// 
    /// The client id.
    /// 
    public string ClientId { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/UserLoginSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful user authentication
/// 
/// 
public class UserLoginSuccessEvent : Event
{
    // todo: consolidate ctors in 3.0

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The provider.
    /// The provider user identifier.
    /// The subject identifier.
    /// The name.
    /// if set to true [interactive].
    /// The client id.
    public UserLoginSuccessEvent(string provider, string providerUserId, string subjectId, string name, bool interactive = true, string clientId = null)
        : this()
    {
        Provider = provider;
        ProviderUserId = providerUserId;
        SubjectId = subjectId;
        DisplayName = name;
        if (interactive)
        {
            Endpoint = "UI";
        }
        else
        {
            Endpoint = EndpointNames.Token;
        }
        ClientId = clientId;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The username.
    /// The subject identifier.
    /// The name.
    /// if set to true [interactive].
    /// The client id.
    public UserLoginSuccessEvent(string username, string subjectId, string name, bool interactive = true, string clientId = null)
        : this()
    {
        Username = username;
        SubjectId = subjectId;
        DisplayName = name;
        ClientId = clientId;

        if (interactive)
        {
            Endpoint = "UI";
        }
        else
        {
            Endpoint = EndpointNames.Token;
        }
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    protected UserLoginSuccessEvent()
        : base(EventCategories.Authentication,
              "User Login Success",
              EventTypes.Success,
              EventIds.UserLoginSuccess)
    {
    }

    /// 
    /// Gets or sets the username.
    /// 
    /// 
    /// The username.
    /// 
    public string Username { get; set; }

    /// 
    /// Gets or sets the provider.
    /// 
    /// 
    /// The provider.
    /// 
    public string Provider { get; set; }

    /// 
    /// Gets or sets the provider user identifier.
    /// 
    /// 
    /// The provider user identifier.
    /// 
    public string ProviderUserId { get; set; }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the display name.
    /// 
    /// 
    /// The display name.
    /// 
    public string DisplayName { get; set; }

    /// 
    /// Gets or sets the endpoint.
    /// 
    /// 
    /// The endpoint.
    /// 
    public string Endpoint { get; set; }
    
    /// 
    /// Gets or sets the client id.
    /// 
    /// 
    /// The client id.
    /// 
    public string ClientId { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Events/UserLogoutSuccessEvent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// Event for successful user logout
/// 
/// 
public class UserLogoutSuccessEvent : Event
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject identifier.
    /// The name.
    public UserLogoutSuccessEvent(string subjectId, string name)
        : base(EventCategories.Authentication, 
              "User Logout Success",
              EventTypes.Success, 
              EventIds.UserLogoutSuccess)
    {
        SubjectId = subjectId;
        DisplayName = name;
    }

    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the display name.
    /// 
    /// 
    /// The display name.
    /// 
    public string DisplayName { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Extensions/AuthenticationPropertiesExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

/// 
/// Extensions for AuthenticationProperties
/// 
public static class AuthenticationPropertiesExtensions
{
    internal const string SessionIdKey = "session_id";
    internal const string ClientListKey = "client_list";

    /// 
    /// Gets the user's session identifier.
    /// 
    /// 
    /// 
    public static string GetSessionId(this AuthenticationProperties properties)
    {
        if (properties?.Items.ContainsKey(SessionIdKey) == true)
        {
            return properties.Items[SessionIdKey];
        }

        return null;
    }

    /// 
    /// Sets the user's session identifier.
    /// 
    /// 
    /// The session id
    /// 
    public static void SetSessionId(this AuthenticationProperties properties, string sid)
    {
        properties.Items[SessionIdKey] = sid;
    }

    /// 
    /// Gets the list of client ids the user has signed into during their session.
    /// 
    /// 
    /// 
    public static IEnumerable GetClientList(this AuthenticationProperties properties)
    {
        if (properties?.Items.ContainsKey(ClientListKey) == true)
        {
            var value = properties.Items[ClientListKey];
            return DecodeList(value);
        }

        return Enumerable.Empty();
    }

    /// 
    /// Removes the list of client ids.
    /// 
    /// 
    public static void RemoveClientList(this AuthenticationProperties properties)
    {
        properties?.Items.Remove(ClientListKey);
    }

    /// 
    /// Adds a client to the list of clients the user has signed into during their session.
    /// 
    /// 
    /// 
    public static void AddClientId(this AuthenticationProperties properties, string clientId)
    {
        if (clientId == null) throw new ArgumentNullException(nameof(clientId));

        var clients = properties.GetClientList();
        if (!clients.Contains(clientId))
        {
            var update = clients.ToList();
            update.Add(clientId);

            var value = EncodeList(update);
            if (value == null)
            {
                properties.Items.Remove(ClientListKey);
            }
            else
            {
                properties.Items[ClientListKey] = value;
            }
        }
    }


    private static IEnumerable DecodeList(string value)
    {
        if (value.IsPresent())
        {
            var bytes = Base64Url.Decode(value);
            value = Encoding.UTF8.GetString(bytes);
            return ObjectSerializer.FromString(value);
        }

        return Enumerable.Empty();
    }

    private static string EncodeList(IEnumerable list)
    {
        if (list != null && list.Any())
        {
            var value = ObjectSerializer.ToString(list);
            var bytes = Encoding.UTF8.GetBytes(value);
            value = Base64Url.Encode(bytes);
            return value;
        }

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/AuthorizeResponseExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

internal static class AuthorizeResponseExtensions
{
    public static NameValueCollection ToNameValueCollection(this AuthorizeResponse response)
    {
        var collection = new NameValueCollection();

        if (response.IsError)
        {
            if (response.Error.IsPresent())
            {
                collection.Add("error", response.Error);
            }
            if (response.ErrorDescription.IsPresent())
            {
                collection.Add("error_description", response.ErrorDescription);
            }
        }
        else
        {
            if (response.Code.IsPresent())
            {
                collection.Add("code", response.Code);
            }

            if (response.IdentityToken.IsPresent())
            {
                collection.Add("id_token", response.IdentityToken);
            }

            if (response.AccessToken.IsPresent())
            {
                collection.Add("access_token", response.AccessToken);
                collection.Add("token_type", "Bearer");
                collection.Add("expires_in", response.AccessTokenLifetime.ToString());
            }

            if (response.Scope.IsPresent())
            {
                collection.Add("scope", response.Scope);
            }
        }

        if (response.State.IsPresent())
        {
            collection.Add("state", response.State);
        }
        
        if (response.SessionState.IsPresent())
        {
            collection.Add("session_state", response.SessionState);
        }

        return collection;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ClaimsExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

internal static class ClaimsExtensions
{
    public static Dictionary ToClaimsDictionary(this IEnumerable claims)
    {
        var d = new Dictionary();

        if (claims == null)
        {
            return d;
        }

        var distinctClaims = claims.Distinct(new ClaimComparer());

        foreach (var claim in distinctClaims)
        {
            if (!d.ContainsKey(claim.Type))
            {
                d.Add(claim.Type, GetValue(claim));
            }
            else
            {
                var value = d[claim.Type];

                if (value is List list)
                {
                    list.Add(GetValue(claim));
                }
                else
                {
                    d.Remove(claim.Type);
                    d.Add(claim.Type, new List { value, GetValue(claim) });
                }
            }
        }

        return d;
    }

    private static object GetValue(Claim claim)
    {
        if (claim.ValueType == ClaimValueTypes.Integer ||
            claim.ValueType == ClaimValueTypes.Integer32)
        {
            if (Int32.TryParse(claim.Value, out int value))
            {
                return value;
            }
        }

        if (claim.ValueType == ClaimValueTypes.Integer64)
        {
            if (Int64.TryParse(claim.Value, out long value))
            {
                return value;
            }
        }

        if (claim.ValueType == ClaimValueTypes.Boolean)
        {
            if (bool.TryParse(claim.Value, out bool value))
            {
                return value;
            }
        }

        if (claim.ValueType == IdentityServerConstants.ClaimValueTypes.Json)
        {
            try
            {
                return System.Text.Json.JsonSerializer.Deserialize(claim.Value);
            }
            catch { }
        }

        return claim.Value;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ClientExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Models;

/// 
/// Extension methods for client.
/// 
public static class ClientExtensions
{
    /// 
    /// Returns true if the client is an implicit-only client.
    /// 
    public static bool IsImplicitOnly(this Client client)
    {
        return client != null &&
            client.AllowedGrantTypes != null &&
            client.AllowedGrantTypes.Count == 1 &&
            client.AllowedGrantTypes.First() == GrantType.Implicit;
    }

    /// 
    /// Constructs a list of SecurityKey from a Secret collection
    /// 
    /// The secrets
    /// 
    public static Task> GetKeysAsync(this IEnumerable secrets)
    {
        var secretList = secrets.ToList().AsReadOnly();
        var keys = new List();

        var certificates = GetCertificates(secretList)
                            .Select(c => (SecurityKey)new X509SecurityKey(c))
                            .ToList();
        keys.AddRange(certificates);

        var jwks = secretList
                    .Where(s => s.Type == IdentityServerConstants.SecretTypes.JsonWebKey)
                    .Select(s => new Microsoft.IdentityModel.Tokens.JsonWebKey(s.Value))
                    .ToList();
        keys.AddRange(jwks);

        return Task.FromResult(keys);
    }

    private static List GetCertificates(IEnumerable secrets)
    {
        return secrets
            .Where(s => s.Type == IdentityServerConstants.SecretTypes.X509CertificateBase64)
            .Select(s => new X509Certificate2(Convert.FromBase64String(s.Value)))
            .Where(c => c != null)
            .ToList();
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/DateTimeExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

internal static class DateTimeExtensions
{
    [DebuggerStepThrough]
    public static bool HasExceeded(this DateTime creationTime, int seconds, DateTime now)
    {
        return (now > creationTime.AddSeconds(seconds));
    }

    [DebuggerStepThrough]
    public static int GetLifetimeInSeconds(this DateTime creationTime, DateTime now)
    {
        return ((int)(now - creationTime).TotalSeconds);
    }

    [DebuggerStepThrough]
    public static bool HasExpired(this DateTime? expirationTime, DateTime now)
    {
        if (expirationTime.HasValue &&
            expirationTime.Value.HasExpired(now))
        {
            return true;
        }

        return false;
    }

    [DebuggerStepThrough]
    public static bool HasExpired(this DateTime expirationTime, DateTime now)
    {
        if (now > expirationTime)
        {
            return true;
        }

        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/EndpointOptionsExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Endpoint = IdentityServer8.Hosting.Endpoint;

namespace IdentityServer8.Extensions;

internal static class EndpointOptionsExtensions
{
    public static bool IsEndpointEnabled(this EndpointsOptions options, Endpoint endpoint)
    {
        return endpoint?.Name switch
        {
            EndpointNames.Authorize => options.EnableAuthorizeEndpoint,
            EndpointNames.CheckSession => options.EnableCheckSessionEndpoint,
            EndpointNames.DeviceAuthorization => options.EnableDeviceAuthorizationEndpoint,
            EndpointNames.Discovery => options.EnableDiscoveryEndpoint,
            EndpointNames.EndSession => options.EnableEndSessionEndpoint,
            EndpointNames.Introspection => options.EnableIntrospectionEndpoint,
            EndpointNames.Revocation => options.EnableTokenRevocationEndpoint,
            EndpointNames.Token => options.EnableTokenEndpoint,
            EndpointNames.UserInfo => options.EnableUserInfoEndpoint,
            _ => true
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/HashExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Extension methods for hashing strings
/// 
public static class HashExtensions
{
    /// 
    /// Creates a SHA256 hash of the specified input.
    /// 
    /// The input.
    /// A hash
    public static string Sha256(this string input)
    {
        if (input.IsMissing()) return string.Empty;

        using (var sha = SHA256.Create())
        {
            var bytes = Encoding.UTF8.GetBytes(input);
            var hash = sha.ComputeHash(bytes);

            return Convert.ToBase64String(hash);
        }
    }

    /// 
    /// Creates a SHA256 hash of the specified input.
    /// 
    /// The input.
    /// A hash.
    public static byte[] Sha256(this byte[] input)
    {
        if (input == null)
        {
            return null;
        }

        using (var sha = SHA256.Create())
        {
            return sha.ComputeHash(input);
        }
    }

    /// 
    /// Creates a SHA512 hash of the specified input.
    /// 
    /// The input.
    /// A hash
    public static string Sha512(this string input)
    {
        if (input.IsMissing()) return string.Empty;

        using (var sha = SHA512.Create())
        {
            var bytes = Encoding.UTF8.GetBytes(input);
            var hash = sha.ComputeHash(bytes);

            return Convert.ToBase64String(hash);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/HttpContextAuthenticationExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.AspNetCore.Http;

/// 
/// Extension methods for signin/out using the IdentityServer authentication scheme.
/// 
public static class AuthenticationManagerExtensions
{
    /// 
    /// Signs the user in.
    /// 
    /// The manager.
    /// The IdentityServer user.
    /// 
    public static async Task SignInAsync(this HttpContext context, IdentityServerUser user)
    {
        await context.SignInAsync(await context.GetCookieAuthenticationSchemeAsync(), user.CreatePrincipal());
    }

    /// 
    /// Signs the user in.
    /// 
    /// The manager.
    /// The IdentityServer user.
    /// The authentication properties.
    /// 
    public static async Task SignInAsync(this HttpContext context, IdentityServerUser user, AuthenticationProperties properties)
    {
        await context.SignInAsync(await context.GetCookieAuthenticationSchemeAsync(), user.CreatePrincipal(), properties);
    }

    internal static ISystemClock GetClock(this HttpContext context)
    {
        return context.RequestServices.GetRequiredService();
    }

    internal static async Task GetCookieAuthenticationSchemeAsync(this HttpContext context)
    {
        var options = context.RequestServices.GetRequiredService();
        if (options.Authentication.CookieAuthenticationScheme != null)
        {
            return options.Authentication.CookieAuthenticationScheme;
        }

        var schemes = context.RequestServices.GetRequiredService();
        var scheme = await schemes.GetDefaultAuthenticateSchemeAsync();
        if (scheme == null)
        {
            throw new InvalidOperationException("No DefaultAuthenticateScheme found or no CookieAuthenticationScheme configured on IdentityServerOptions.");
        }

        return scheme.Name;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/HttpContextExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591


namespace IdentityServer8.Extensions;

public static class HttpContextExtensions
{
    public static async Task GetSchemeSupportsSignOutAsync(this HttpContext context, string scheme)
    {
        var provider = context.RequestServices.GetRequiredService();
        var handler = await provider.GetHandlerAsync(context, scheme);
        return (handler is IAuthenticationSignOutHandler);
    }

    public static void SetIdentityServerOrigin(this HttpContext context, string value)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));
        if (value == null) throw new ArgumentNullException(nameof(value));

        var split = value.Split(new[] { "://" }, StringSplitOptions.RemoveEmptyEntries);

        var request = context.Request;
        request.Scheme = split.First();
        request.Host = new HostString(split.Last());
    }

    public static void SetIdentityServerBasePath(this HttpContext context, string value)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));

        context.Items[Constants.EnvironmentKeys.IdentityServerBasePath] = value;
    }

    public static string GetIdentityServerOrigin(this HttpContext context)
    {
        var options = context.RequestServices.GetRequiredService();
        var request = context.Request;
        
        if (options.MutualTls.Enabled && options.MutualTls.DomainName.IsPresent())
        {
            if (!options.MutualTls.DomainName.Contains("."))
            {
                if (request.Host.Value.StartsWith(options.MutualTls.DomainName, StringComparison.OrdinalIgnoreCase))
                {
                    return request.Scheme + "://" +
                           request.Host.Value.Substring(options.MutualTls.DomainName.Length + 1);
                }
            }
        }
        
        return request.Scheme + "://" + request.Host.Value;
    }


    internal static void SetSignOutCalled(this HttpContext context)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));
        context.Items[Constants.EnvironmentKeys.SignOutCalled] = "true";
    }

    internal static bool GetSignOutCalled(this HttpContext context)
    {
        return context.Items.ContainsKey(Constants.EnvironmentKeys.SignOutCalled);
    }

    /// 
    /// Gets the host name of IdentityServer.
    /// 
    /// The context.
    /// 
    public static string GetIdentityServerHost(this HttpContext context)
    {
        var request = context.Request;
        return request.Scheme + "://" + request.Host.ToUriComponent();
    }

    /// 
    /// Gets the base path of IdentityServer.
    /// 
    /// The context.
    /// 
    public static string GetIdentityServerBasePath(this HttpContext context)
    {
        return context.Items[Constants.EnvironmentKeys.IdentityServerBasePath] as string;
    }

    /// 
    /// Gets the public base URL for IdentityServer.
    /// 
    /// The context.
    /// 
    public static string GetIdentityServerBaseUrl(this HttpContext context)
    {
        return context.GetIdentityServerHost() + context.GetIdentityServerBasePath();
    }

    /// 
    /// Gets the identity server relative URL.
    /// 
    /// The context.
    /// The path.
    /// 
    public static string GetIdentityServerRelativeUrl(this HttpContext context, string path)
    {
        if (!path.IsLocalUrl())
        {
            return null;
        }

        if (path.StartsWith("~/")) path = path.Substring(1);
        path = context.GetIdentityServerBaseUrl().EnsureTrailingSlash() + path.RemoveLeadingSlash();
        return path;
    }

    /// 
    /// Gets the identity server issuer URI.
    /// 
    /// The context.
    /// 
    /// context
    public static string GetIdentityServerIssuerUri(this HttpContext context)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));

        // if they've explicitly configured a URI then use it,
        // otherwise dynamically calculate it
        var options = context.RequestServices.GetRequiredService();
        var uri = options.IssuerUri;
        if (uri.IsMissing())
        {
            uri = context.GetIdentityServerOrigin() + context.GetIdentityServerBasePath();
            if (uri.EndsWith("/")) uri = uri.Substring(0, uri.Length - 1);
            if (options.LowerCaseIssuerUri)
            {
                uri = uri.ToLowerInvariant();
            }
        }

        return uri;
    }

    internal static async Task GetIdentityServerSignoutFrameCallbackUrlAsync(this HttpContext context, LogoutMessage logoutMessage = null)
    {
        var userSession = context.RequestServices.GetRequiredService();
        var user = await userSession.GetUserAsync();
        var currentSubId = user?.GetSubjectId();

        LogoutNotificationContext endSessionMsg = null;

        // if we have a logout message, then that take precedence over the current user
        if (logoutMessage?.ClientIds?.Any() == true)
        {
            var clientIds = logoutMessage?.ClientIds;

            // check if current user is same, since we might have new clients (albeit unlikely)
            if (currentSubId == logoutMessage?.SubjectId)
            {
                clientIds = clientIds.Union(await userSession.GetClientListAsync());
                clientIds = clientIds.Distinct();
            }

            endSessionMsg = new LogoutNotificationContext
            {
                SubjectId = logoutMessage.SubjectId,
                SessionId = logoutMessage.SessionId,
                ClientIds = clientIds
            };
        }
        else if (currentSubId != null)
        {
            // see if current user has any clients they need to signout of 
            var clientIds = await userSession.GetClientListAsync();
            if (clientIds.Any())
            {
                endSessionMsg = new LogoutNotificationContext
                {
                    SubjectId = currentSubId,
                    SessionId = await userSession.GetSessionIdAsync(),
                    ClientIds = clientIds
                };
            }
        }

        if (endSessionMsg != null)
        {
            var clock = context.RequestServices.GetRequiredService();
            var msg = new Message(endSessionMsg, clock.UtcNow.UtcDateTime);

            var endSessionMessageStore = context.RequestServices.GetRequiredService>();
            var id = await endSessionMessageStore.WriteAsync(msg);

            var signoutIframeUrl = context.GetIdentityServerBaseUrl().EnsureTrailingSlash() + Constants.ProtocolRoutePaths.EndSessionCallback;
            signoutIframeUrl = signoutIframeUrl.AddQueryString(Constants.UIConstants.DefaultRoutePathParams.EndSessionCallback, id);

            return signoutIframeUrl;
        }

        // no sessions, so nothing to cleanup
        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/HttpRequestExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591


using System.Net.Http.Headers;

namespace IdentityServer8.Extensions;

public static class HttpRequestExtensions
{
    public static string GetCorsOrigin(this HttpRequest request)
    {
        var origin = request.Headers["Origin"].FirstOrDefault();
        var thisOrigin = request.Scheme + "://" + request.Host;

        // see if the Origin is different than this server's origin. if so
        // that indicates a proper CORS request. some browsers send Origin
        // on POST requests.
        if (origin != null && origin != thisOrigin)
        {
            return origin;
        }

        return null;
    }
    
    internal static bool HasApplicationFormContentType(this HttpRequest request)
    {
        if (request.ContentType is null) return false;
        
        if (MediaTypeHeaderValue.TryParse(request.ContentType, out var header))
        {
            // Content-Type: application/x-www-form-urlencoded; charset=utf-8
            return header.MediaType.Equals("application/x-www-form-urlencoded", StringComparison.OrdinalIgnoreCase);
        }

        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/HttpResponseExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591


namespace IdentityServer8.Extensions;

public static class HttpResponseExtensions
{
    public static async Task WriteJsonAsync(this HttpResponse response, object o, string contentType = null)
    {
        var json = ObjectSerializer.ToString(o);
        await response.WriteJsonAsync(json, contentType);
        await response.Body.FlushAsync();
    }

    public static async Task WriteJsonAsync(this HttpResponse response, string json, string contentType = null)
    {
        response.ContentType = contentType ?? "application/json; charset=UTF-8";
        await response.WriteAsync(json);
        await response.Body.FlushAsync();
    }

    public static void SetCache(this HttpResponse response, int maxAge, params string[] varyBy)
    {
        if (maxAge == 0)
        {
            SetNoCache(response);
        }
        else if (maxAge > 0)
        {
            if (!response.Headers.ContainsKey("Cache-Control"))
            {
                response.Headers.Append("Cache-Control", $"max-age={maxAge}");
            }

            if (varyBy?.Any() == true)
            {
                var vary = varyBy.Aggregate((x, y) => x + "," + y);
                if (response.Headers.ContainsKey("Vary"))
                {
                    vary = response.Headers["Vary"].ToString() + "," + vary;
                }
                response.Headers["Vary"] = vary;
            }
        }
    }

    public static void SetNoCache(this HttpResponse response)
    {
        if (!response.Headers.ContainsKey("Cache-Control"))
        {
            response.Headers.Append("Cache-Control", "no-store, no-cache, max-age=0");
        }
        else
        {
            response.Headers["Cache-Control"] = "no-store, no-cache, max-age=0";
        }

        if (!response.Headers.ContainsKey("Pragma"))
        {
            response.Headers.Append("Pragma", "no-cache");
        }
    }

    public static async Task WriteHtmlAsync(this HttpResponse response, string html)
    {
        response.ContentType = "text/html; charset=UTF-8";
        await response.WriteAsync(html, Encoding.UTF8);
        await response.Body.FlushAsync();
    }

    public static void RedirectToAbsoluteUrl(this HttpResponse response, string url)
    {
        if (url.IsLocalUrl())
        {
            if (url.StartsWith("~/")) url = url.Substring(1);
            url = response.HttpContext.GetIdentityServerBaseUrl().EnsureTrailingSlash() + url.RemoveLeadingSlash();
        }
        response.RedirectIfAllowed(url);
    }

    public static void AddScriptCspHeaders(this HttpResponse response, CspOptions options, string hash)
    {
        var csp1part = options.Level == CspLevel.One ? "'unsafe-inline' " : string.Empty;
        var cspHeader = $"default-src 'none'; script-src {csp1part}'{hash}'";

        AddCspHeaders(response.Headers, options, cspHeader);
    }

    public static void AddStyleCspHeaders(this HttpResponse response, CspOptions options, string hash, string frameSources)
    {
        var csp1part = options.Level == CspLevel.One ? "'unsafe-inline' " : string.Empty;
        var cspHeader = $"default-src 'none'; style-src {csp1part}'{hash}'";

        if (!string.IsNullOrEmpty(frameSources))
        {
            cspHeader += $"; frame-src {frameSources}";
        }

        AddCspHeaders(response.Headers, options, cspHeader);
    }

    public static void AddCspHeaders(IHeaderDictionary headers, CspOptions options, string cspHeader)
    {
        if (!headers.ContainsKey("Content-Security-Policy"))
        {
            headers.Append("Content-Security-Policy", cspHeader);
        }
        if (options.AddDeprecatedHeader && !headers.ContainsKey("X-Content-Security-Policy"))
        {
            headers.Append("X-Content-Security-Policy", cspHeader);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ICacheExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

/// 
/// Extensions for ICache
/// 
public static class ICacheExtensions
{
    /// 
    /// Attempts to get an item from the cache. If the item is not found, the get function is used to
    /// obtain the item and populate the cache.
    /// 
    /// 
    /// The cache.
    /// The key.
    /// The duration.
    /// The get function.
    /// The logger.
    /// 
    /// cache
    /// or
    /// get
    /// cache
    /// or
    /// get
    public static async Task GetAsync(this ICache cache, string key, TimeSpan duration, Func> get, ILogger logger)
        where T : class
    {
        if (cache == null) throw new ArgumentNullException(nameof(cache));
        if (get == null) throw new ArgumentNullException(nameof(get));
        if (key == null) return null;

        var item = await cache.GetAsync(key);

        if (item == null)
        {
            logger.LogTrace("Cache miss for {cacheKey}", Ioc.Sanitizer.Log.Sanitize(key));

            item = await get();

            if (item != null)
            {
                logger.LogTrace("Setting item in cache for {cacheKey}", Ioc.Sanitizer.Log.Sanitize(key));
                await cache.SetAsync(key, item, duration);
            }
        }
        else
        {
            logger.LogTrace("Cache hit for {cacheKey}", Ioc.Sanitizer.Log.Sanitize(key));
        }

        return item;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IClientStoreExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Extension for IClientStore
/// 
public static class IClientStoreExtensions
{
    /// 
    /// Finds the enabled client by identifier.
    /// 
    /// The store.
    /// The client identifier.
    /// 
    public static async Task FindEnabledClientByIdAsync(this IClientStore store, string clientId)
    {
        var client = await store.FindClientByIdAsync(clientId);
        if (client != null && client.Enabled) return client;

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IEnumerableExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Extensions;

public static class IEnumerableExtensions
{
    [DebuggerStepThrough]
    public static bool EnumerableIsNullOrEmpty(this IEnumerable list)
    {
        if (list == null)
        {
            return true;
        }

        if (!list.Any())
        {
            return true;
        }

        return false;
    }

    public static bool HasDuplicates(this IEnumerable list, Func selector)
    {
        var d = new HashSet();
        foreach (var t in list)
        {
            if (!d.Add(selector(t)))
            {
                return true;
            }
        }
        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IReadableStringCollectionExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Extensions;

public static class IReadableStringCollectionExtensions
{
    [DebuggerStepThrough]
    public static NameValueCollection AsNameValueCollection(this IEnumerable> collection)
    {
        var nv = new NameValueCollection();

        foreach (var field in collection)
        {
            nv.Add(field.Key, field.Value.First());
        }

        return nv;
    }

    [DebuggerStepThrough]
    public static NameValueCollection AsNameValueCollection(this IDictionary collection)
    {
        var nv = new NameValueCollection();

        foreach (var field in collection)
        {
            nv.Add(field.Key, field.Value.First());
        }

        return nv;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IResourceStoreExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Extensions for IResourceStore
/// 
public static class IResourceStoreExtensions
{
    /// 
    /// Finds the resources by scope.
    /// 
    /// The store.
    /// The scope names.
    /// 
    public static async Task FindResourcesByScopeAsync(this IResourceStore store, IEnumerable scopeNames)
    {
        var identity = await store.FindIdentityResourcesByScopeNameAsync(scopeNames);
        var apiResources = await store.FindApiResourcesByScopeNameAsync(scopeNames);
        var scopes = await store.FindApiScopesByNameAsync(scopeNames);

        Validate(identity, apiResources, scopes);

        var resources = new Resources(identity, apiResources, scopes)
        {
            OfflineAccess = scopeNames.Contains(IdentityServerConstants.StandardScopes.OfflineAccess)
        };

        return resources;
    }

    private static void Validate(IEnumerable identity, IEnumerable apiResources, IEnumerable apiScopes)
    {
        // attempt to detect invalid configuration. this is about the only place
        // we can do this, since it's hard to get the values in the store.
        var identityScopeNames = identity.Select(x => x.Name).ToArray();
        var dups = GetDuplicates(identityScopeNames);
        if (dups.Any())
        {
            var names = dups.Aggregate((x, y) => x + ", " + y);
            throw new Exception(
                $"Duplicate identity scopes found. This is an invalid configuration. Use different names for identity scopes. Scopes found: {names}");
        }

        var apiNames = apiResources.Select(x => x.Name);
        dups = GetDuplicates(apiNames);
        if (dups.Any())
        {
            var names = dups.Aggregate((x, y) => x + ", " + y);
            throw new Exception(
                $"Duplicate api resources found. This is an invalid configuration. Use different names for API resources. Names found: {names}");
        }
        
        var scopesNames = apiScopes.Select(x => x.Name);
        dups = GetDuplicates(scopesNames);
        if (dups.Any())
        {
            var names = dups.Aggregate((x, y) => x + ", " + y);
            throw new Exception(
                $"Duplicate scopes found. This is an invalid configuration. Use different names for scopes. Names found: {names}");
        }

        var overlap = identityScopeNames.Intersect(scopesNames).ToArray();
        if (overlap.Any())
        {
            var names = overlap.Aggregate((x, y) => x + ", " + y);
            throw new Exception(
                $"Found identity scopes and API scopes that use the same names. This is an invalid configuration. Use different names for identity scopes and API scopes. Scopes found: {names}");
        }
    }

    private static IEnumerable GetDuplicates(IEnumerable names)
    {
        var duplicates = names
                        .GroupBy(x => x)
                        .Where(g => g.Count() > 1)
                        .Select(y => y.Key)
                        .ToArray();
        return duplicates.ToArray();
    }

    /// 
    /// Finds the enabled resources by scope.
    /// 
    /// The store.
    /// The scope names.
    /// 
    public static async Task FindEnabledResourcesByScopeAsync(this IResourceStore store, IEnumerable scopeNames)
    {
        return (await store.FindResourcesByScopeAsync(scopeNames)).FilterEnabled();
    }

    /// 
    /// Creates a resource validation result.
    /// 
    /// The store.
    /// The parsed scopes.
    /// 
    public static async Task CreateResourceValidationResult(this IResourceStore store, ParsedScopesResult parsedScopesResult)
    {
        var validScopeValues = parsedScopesResult.ParsedScopes;
        var scopes = validScopeValues.Select(x => x.ParsedName).ToArray();
        var resources = await store.FindEnabledResourcesByScopeAsync(scopes);
        return new ResourceValidationResult(resources, validScopeValues);
    }

    /// 
    /// Gets all enabled resources.
    /// 
    /// The store.
    /// 
    public static async Task GetAllEnabledResourcesAsync(this IResourceStore store)
    {
        var resources = await store.GetAllResourcesAsync();
        Validate(resources.IdentityResources, resources.ApiResources, resources.ApiScopes);

        return resources.FilterEnabled();
    }

    /// 
    /// Finds the enabled identity resources by scope.
    /// 
    /// The store.
    /// The scope names.
    /// 
    public static async Task> FindEnabledIdentityResourcesByScopeAsync(this IResourceStore store, IEnumerable scopeNames)
    {
        return (await store.FindIdentityResourcesByScopeNameAsync(scopeNames)).Where(x => x.Enabled).ToArray();
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IUserSessionExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Extension for IUserSession.
/// 
public static class IUserSessionExtensions
{
    /// 
    /// Creates a LogoutNotificationContext for the current user session.
    /// 
    /// 
    public static async Task GetLogoutNotificationContext(this IUserSession session)
    {
        var clientIds = await session.GetClientListAsync();

        if (clientIds.Any())
        {
            var user = await session.GetUserAsync();
            var sub = user.GetSubjectId();
            var sid = await session.GetSessionIdAsync();

            return new LogoutNotificationContext
            {
                SubjectId = sub,
                SessionId = sid,
                ClientIds = clientIds
            };
        }

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/IdentityServerToolsExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

/// 
/// Extensions for IdentityServerTools
/// 
public static class IdentityServerToolsExtensions
{
    /// 
    /// Issues the client JWT.
    /// 
    /// The tools.
    /// The client identifier.
    /// The lifetime.
    /// The scopes.
    /// The audiences.
    /// Additional claims
    /// 
    public static async Task IssueClientJwtAsync(this IdentityServerTools tools,
        string clientId,
        int lifetime,
        IEnumerable scopes = null,
        IEnumerable audiences = null,
        IEnumerable additionalClaims = null)
    {
        var claims = new HashSet(new ClaimComparer());
        var context = tools.ContextAccessor.HttpContext;
        var options = context.RequestServices.GetRequiredService();
        
        if (additionalClaims != null)
        {
            foreach (var claim in additionalClaims)
            {
                claims.Add(claim);
            }
        }

        claims.Add(new Claim(JwtClaimTypes.ClientId, clientId));

        if (!scopes.EnumerableIsNullOrEmpty())
        {
            foreach (var scope in scopes)
            {
                claims.Add(new Claim(JwtClaimTypes.Scope, scope));
            }
        }

        if (options.EmitStaticAudienceClaim)
        {
            claims.Add(new Claim(JwtClaimTypes.Audience, string.Format(IdentityServerConstants.AccessTokenAudience, tools.ContextAccessor.HttpContext.GetIdentityServerIssuerUri().EnsureTrailingSlash())));
        }
        
        if (!audiences.EnumerableIsNullOrEmpty())
        {
            foreach (var audience in audiences)
            {
                claims.Add(new Claim(JwtClaimTypes.Audience, audience));
            }
        }

        return await tools.IssueJwtAsync(lifetime, claims);
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/JsonExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServer8.Extensions;

internal static partial class JsonExtensions
{
    [DebuggerStepThrough]
    public static T ToObject(this JsonElement element, JsonSerializerOptions options = null)
    {
        var bufferWriter = new ArrayBufferWriter();
        using (var writer = new Utf8JsonWriter(bufferWriter))
            element.WriteTo(writer);
        return JsonSerializer.Deserialize(bufferWriter.WrittenSpan, options);
    }

    [DebuggerStepThrough]
    public static T ToObject(this JsonDocument document, JsonSerializerOptions options = null)
    {
        if (document == null)
            throw new ArgumentNullException(nameof(document));
        return document.RootElement.ToObject(options);
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/NameValueCollectionExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

internal static class NameValueCollectionExtensions
{
    public static IDictionary ToFullDictionary(this NameValueCollection source)
    {
        return source.AllKeys.ToDictionary(k => k, k => source.GetValues(k));
    }

    public static NameValueCollection FromFullDictionary(this IDictionary source)
    {
        var nvc = new NameValueCollection();

        foreach ((string key, string[] strings) in source)
        {
            foreach (var value in strings)
            {
                nvc.Add(key, value);
            }
        }

        return nvc;
    }
    
    public static string ToQueryString(this NameValueCollection collection)
    {
        if (collection.Count == 0)
        {
            return String.Empty;
        }

        var builder = new StringBuilder(128);
        var first = true;
        foreach (string name in collection)
        {
            var values = collection.GetValues(name);
            if (values == null || values.Length == 0)
            {
                first = AppendNameValuePair(builder, first, true, name, String.Empty);
            }
            else
            {
                foreach (var value in values)
                {
                    first = AppendNameValuePair(builder, first, true, name, value);
                }
            }
        }

        return builder.ToString();
    }

    public static string ToFormPost(this NameValueCollection collection)
    {
        var builder = new StringBuilder(128);
        const string inputFieldFormat = "\n";

        foreach (string name in collection)
        {
            var values = collection.GetValues(name);
            var value = values.First();
            value = HtmlEncoder.Default.Encode(value);
            builder.AppendFormat(inputFieldFormat, name, value);
        }

        return builder.ToString();
    }

    public static NameValueCollection ToNameValueCollection(this Dictionary data)
    {
        var result = new NameValueCollection();

        if (data == null || data.Count == 0)
        {
            return result;
        }

        foreach (var name in data.Keys)
        {
            var value = data[name];
            if (value != null)
            {
                result.Add(name, value);
            }
        }

        return result;
    }

    public static Dictionary ToDictionary(this NameValueCollection collection)
    {
        return collection.ToScrubbedDictionary();
    }

    public static Dictionary ToScrubbedDictionary(this NameValueCollection collection, params string[] nameFilter)
    {
        var dict = new Dictionary();

        if (collection == null || collection.Count == 0)
        {
            return dict;
        }

        foreach (string name in collection)
        {
            var value = collection.Get(name);
            if (value != null)
            {
                if (nameFilter.Contains(name, StringComparer.OrdinalIgnoreCase))
                {
                    value = "***REDACTED***";
                }
                dict.Add(name, value);
            }
        }

        return dict;
    }

    internal static string ConvertFormUrlEncodedSpacesToUrlEncodedSpaces(string str)
    {
        if ((str != null) && (str.IndexOf('+') >= 0))
        {
            str = str.Replace("+", "%20");
        }
        return str;
    }

    private static bool AppendNameValuePair(StringBuilder builder, bool first, bool urlEncode, string name, string value)
    {
        var effectiveName = name ?? String.Empty;
        var encodedName = urlEncode ? UrlEncoder.Default.Encode(effectiveName) : effectiveName;

        var effectiveValue = value ?? String.Empty;
        var encodedValue = urlEncode ? UrlEncoder.Default.Encode(effectiveValue) : effectiveValue;
        encodedValue = ConvertFormUrlEncodedSpacesToUrlEncodedSpaces(encodedValue);

        if (first)
        {
            first = false;
        }
        else
        {
            builder.Append("&");
        }

        builder.Append(encodedName);
        if (!String.IsNullOrEmpty(encodedValue))
        {
            builder.Append("=");
            builder.Append(encodedValue);
        }
        return first;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/PrincipalExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

/// 
/// Extension methods for  and  .
/// 
public static class PrincipalExtensions
{
    /// 
    /// Gets the authentication time.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static DateTime GetAuthenticationTime(this IPrincipal principal)
    {
        return DateTimeOffset.FromUnixTimeSeconds(principal.GetAuthenticationTimeEpoch()).UtcDateTime;
    }

    /// 
    /// Gets the authentication epoch time.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static long GetAuthenticationTimeEpoch(this IPrincipal principal)
    {
        return principal.Identity.GetAuthenticationTimeEpoch();
    }

    /// 
    /// Gets the authentication epoch time.
    /// 
    /// The identity.
    /// 
    [DebuggerStepThrough]
    public static long GetAuthenticationTimeEpoch(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        var claim = id.FindFirst(JwtClaimTypes.AuthenticationTime);

        if (claim == null) throw new InvalidOperationException("auth_time is missing.");
       
        return long.Parse(claim.Value);
    }

    /// 
    /// Gets the subject identifier.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static string GetSubjectId(this IPrincipal principal)
    {
        return principal.Identity.GetSubjectId();
    }

    /// 
    /// Gets the subject identifier.
    /// 
    /// The identity.
    /// 
    /// sub claim is missing
    [DebuggerStepThrough]
    public static string GetSubjectId(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        var claim = id.FindFirst(JwtClaimTypes.Subject);

        if (claim == null) throw new InvalidOperationException("sub claim is missing");
        return claim.Value;
    }

    /// 
    /// Gets the name.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    [Obsolete("This method will be removed in a future version. Use GetDisplayName instead.")]
    public static string GetName(this IPrincipal principal)
    {
        return principal.Identity.GetName();
    }

    /// 
    /// Gets the name.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static string GetDisplayName(this ClaimsPrincipal principal)
    {
        var name = principal.Identity.Name;
        if (name.IsPresent()) return name;

        var sub = principal.FindFirst(JwtClaimTypes.Subject);
        if (sub != null) return sub.Value;

        return string.Empty;
    }

    /// 
    /// Gets the name.
    /// 
    /// The identity.
    /// 
    /// name claim is missing
    [DebuggerStepThrough]
    [Obsolete("This method will be removed in a future version. Use GetDisplayName instead.")]
    public static string GetName(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        var claim = id.FindFirst(JwtClaimTypes.Name);

        if (claim == null) throw new InvalidOperationException("name claim is missing");
        return claim.Value;
    }

    /// 
    /// Gets the authentication method.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static string GetAuthenticationMethod(this IPrincipal principal)
    {
        return principal.Identity.GetAuthenticationMethod();
    }

    /// 
    /// Gets the authentication method claims.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static IEnumerable GetAuthenticationMethods(this IPrincipal principal)
    {
        return principal.Identity.GetAuthenticationMethods();
    }

    /// 
    /// Gets the authentication method.
    /// 
    /// The identity.
    /// 
    /// amr claim is missing
    [DebuggerStepThrough]
    public static string GetAuthenticationMethod(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        var claim = id.FindFirst(JwtClaimTypes.AuthenticationMethod);

        if (claim == null) throw new InvalidOperationException("amr claim is missing");
        return claim.Value;
    }

    /// 
    /// Gets the authentication method claims.
    /// 
    /// The identity.
    /// 
    [DebuggerStepThrough]
    public static IEnumerable GetAuthenticationMethods(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        return id.FindAll(JwtClaimTypes.AuthenticationMethod);
    }

    /// 
    /// Gets the identity provider.
    /// 
    /// The principal.
    /// 
    [DebuggerStepThrough]
    public static string GetIdentityProvider(this IPrincipal principal)
    {
        return principal.Identity.GetIdentityProvider();
    }

    /// 
    /// Gets the identity provider.
    /// 
    /// The identity.
    /// 
    /// idp claim is missing
    [DebuggerStepThrough]
    public static string GetIdentityProvider(this IIdentity identity)
    {
        var id = identity as ClaimsIdentity;
        var claim = id.FindFirst(JwtClaimTypes.IdentityProvider);

        if (claim == null) throw new InvalidOperationException("idp claim is missing");
        return claim.Value;
    }

    /// 
    /// Determines whether this instance is authenticated.
    /// 
    /// The principal.
    /// 
    ///   true if the specified principal is authenticated; otherwise, false.
    /// 
    [DebuggerStepThrough]
    public static bool IsAuthenticated(this IPrincipal principal)
    {
        return principal != null && principal.Identity != null && principal.Identity.IsAuthenticated;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ProfileDataRequestContextExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Extensions for ProfileDataRequestContext
/// 
public static class ProfileDataRequestContextExtensions
{
    /// 
    /// Filters the claims based on requested claim types.
    /// 
    /// The context.
    /// The claims.
    /// 
    public static List FilterClaims(this ProfileDataRequestContext context, IEnumerable claims)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));
        if (claims == null) throw new ArgumentNullException(nameof(claims));

        return claims.Where(x => context.RequestedClaimTypes.Contains(x.Type)).ToList();
    }

    /// 
    /// Filters the claims based on the requested claim types and then adds them to the IssuedClaims collection.
    /// 
    /// The context.
    /// The claims.
    public static void AddRequestedClaims(this ProfileDataRequestContext context, IEnumerable claims)
    {
        if (context.RequestedClaimTypes.Any())
        {
            context.IssuedClaims.AddRange(context.FilterClaims(claims));
        }
    }

    /// 
    /// Logs the profile request.
    /// 
    /// The context.
    /// The logger.
    public static void LogProfileRequest(this ProfileDataRequestContext context, ILogger logger)
    {
        logger.LogDebug("Get profile called for subject {subject} from client {client} with claim types {claimTypes} via {caller}",
            context.Subject.GetSubjectId(),
            context.Client.ClientName ?? context.Client.ClientId,
            context.RequestedClaimTypes,
            context.Caller);
    }

    /// 
    /// Logs the issued claims.
    /// 
    /// The context.
    /// The logger.
    public static void LogIssuedClaims(this ProfileDataRequestContext context, ILogger logger)
    {
        logger.LogDebug("Issued claims: {claims}", context.IssuedClaims.Select(c => c.Type));
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ResourceExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Extensions for Resource
/// 
public static class ResourceExtensions
{
    /// 
    /// Returns the collection of scope values that are required.
    /// 
    /// 
    /// 
    public static IEnumerable GetRequiredScopeValues(this ResourceValidationResult resourceValidationResult)
    {
        var names = resourceValidationResult.Resources.IdentityResources.Where(x => x.Required).Select(x => x.Name).ToList();
        names.AddRange(resourceValidationResult.Resources.ApiScopes.Where(x => x.Required).Select(x => x.Name));

        var values = resourceValidationResult.ParsedScopes.Where(x => names.Contains(x.ParsedName)).Select(x => x.RawValue);
        return values;
    }

    /// 
    /// Converts to scope names.
    /// 
    /// The resources.
    /// 
    public static IEnumerable ToScopeNames(this Resources resources)
    {
        var names = resources.IdentityResources.Select(x => x.Name).ToList();
        names.AddRange(resources.ApiScopes.Select(x => x.Name));
        if (resources.OfflineAccess)
        {
            names.Add(IdentityServerConstants.StandardScopes.OfflineAccess);
        }
        
        return names;
    }

    /// 
    /// Finds the IdentityResource that matches the scope.
    /// 
    /// The resources.
    /// The name.
    /// 
    public static IdentityResource FindIdentityResourcesByScope(this Resources resources, string name)
    {
        var q = from id in resources.IdentityResources
                where id.Name == name
                select id;
        return q.FirstOrDefault();
    }

    /// 
    /// Finds the API resources that contain the scope.
    /// 
    /// The resources.
    /// The name.
    /// 
    public static IEnumerable FindApiResourcesByScope(this Resources resources, string name)
    {
        var q = from api in resources.ApiResources
                where api.Scopes != null && api.Scopes.Contains(name)
                select api;
        return q.ToArray();
    }

    /// 
    /// Finds the API scope.
    /// 
    /// The resources.
    /// The name.
    /// 
    public static ApiScope FindApiScope(this Resources resources, string name)
    {
        var q = from scope in resources.ApiScopes
                where scope.Name == name
                select scope;
        return q.FirstOrDefault();
    }

    internal static Resources FilterEnabled(this Resources resources)
    {
        if (resources == null) return new Resources();

        return new Resources(
            resources.IdentityResources.Where(x => x.Enabled),
            resources.ApiResources.Where(x => x.Enabled),
            resources.ApiScopes.Where(x => x.Enabled))
        {
            OfflineAccess = resources.OfflineAccess
        };
    }

    internal static ICollection FindMatchingSigningAlgorithms(this IEnumerable apiResources)
    {
        var apis = apiResources.ToList();

        if (apis.EnumerableIsNullOrEmpty())
        {
            return new List();
        }

        // only one API resource request, forward the allowed signing algorithms (if any)
        if (apis.Count == 1)
        {
            return apis.First().AllowedAccessTokenSigningAlgorithms;
        }
        
        var allAlgorithms = apis.Where(r => r.AllowedAccessTokenSigningAlgorithms.Any()).Select(r => r.AllowedAccessTokenSigningAlgorithms).ToList();

        // resources need to agree on allowed signing algorithms
        if (allAlgorithms.Any())
        {
            var allowedAlgorithms = IntersectLists(allAlgorithms);

            if (allowedAlgorithms.Any())
            {
                return allowedAlgorithms.ToHashSet();
            }

            throw new InvalidOperationException("Signing algorithms requirements for requested resources are not compatible.");
        }

        return new List();
    }

    private static IEnumerable IntersectLists(IEnumerable> lists)
    {
        return lists.Aggregate((l1, l2) => l1.Intersect(l2));
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ScopeExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

internal static class ScopeExtensions
{
    [DebuggerStepThrough]
    public static string ToSpaceSeparatedString(this IEnumerable apiScopes)
    {
        var scopeNames = from s in apiScopes
                         select s.Name;

        return string.Join(" ", scopeNames.ToArray());
    }

    [DebuggerStepThrough]
    public static IEnumerable ToStringList(this IEnumerable apiScopes)
    {
        var scopeNames = from s in apiScopes
                         select s.Name;

        return scopeNames;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/StringsExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;


internal static class StringExtensions
{
    [DebuggerStepThrough]
    public static string ToSpaceSeparatedString(this IEnumerable list)
    {
        if (list == null)
        {
            return string.Empty;
        }

        var sb = new StringBuilder(100);

        foreach (var element in list)
        {
            sb.Append(element + " ");
        }

        return sb.ToString().Trim();
    }

    [DebuggerStepThrough]
    public static IEnumerable FromSpaceSeparatedString(this string input)
    {
        input = input.Trim();
        return input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).ToList();
    }

    public static List ParseScopesString(this string scopes)
    {
        if (scopes.IsMissing())
        {
            return null;
        }

        scopes = scopes.Trim();
        var parsedScopes = scopes.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries).Distinct().ToList();

        if (parsedScopes.Any())
        {
            parsedScopes.Sort();
            return parsedScopes;
        }

        return null;
    }

    [DebuggerStepThrough]
    public static bool IsMissing(this string value)
    {
        return string.IsNullOrWhiteSpace(value);
    }

    [DebuggerStepThrough]
    public static bool IsMissingOrTooLong(this string value, int maxLength)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            return true;
        }
        if (value.Length > maxLength)
        {
            return true;
        }

        return false;
    }

    [DebuggerStepThrough]
    public static bool IsPresent(this string value)
    {
        return !string.IsNullOrWhiteSpace(value);
    }

    [DebuggerStepThrough]
    public static string EnsureLeadingSlash(this string url)
    {
        if (url != null && !url.StartsWith("/"))
        {
            return "/" + url;
        }

        return url;
    }

    [DebuggerStepThrough]
    public static string EnsureTrailingSlash(this string url)
    {
        if (url != null && !url.EndsWith("/"))
        {
            return url + "/";
        }

        return url;
    }

    [DebuggerStepThrough]
    public static string RemoveLeadingSlash(this string url)
    {
        if (url != null && url.StartsWith("/"))
        {
            url = url.Substring(1);
        }

        return url;
    }

    [DebuggerStepThrough]
    public static string RemoveTrailingSlash(this string url)
    {
        if (url != null && url.EndsWith("/"))
        {
            url = url.Substring(0, url.Length - 1);
        }

        return url;
    }

    [DebuggerStepThrough]
    public static string CleanUrlPath(this string url)
    {
        if (String.IsNullOrWhiteSpace(url)) url = "/";

        if (url != "/" && url.EndsWith("/"))
        {
            url = url.Substring(0, url.Length - 1);
        }

        return url;
    }

    [DebuggerStepThrough]
    public static bool IsLocalUrl(this string url)
    {
        if (string.IsNullOrEmpty(url))
        {
            return false;
        }

        // Allows "/" or "/foo" but not "//" or "/\".
        if (url[0] == '/')
        {
            // url is exactly "/"
            if (url.Length == 1)
            {
                return true;
            }

            // url doesn't start with "//" or "/\"
            if (url[1] != '/' && url[1] != '\\')
            {
                return true;
            }

            return false;
        }

        // Allows "~/" or "~/foo" but not "~//" or "~/\".
        if (url[0] == '~' && url.Length > 1 && url[1] == '/')
        {
            // url is exactly "~/"
            if (url.Length == 2)
            {
                return true;
            }

            // url doesn't start with "~//" or "~/\"
            if (url[2] != '/' && url[2] != '\\')
            {
                return true;
            }

            return false;
        }

        return false;
    }

    [DebuggerStepThrough]
    public static string AddQueryString(this string url, string query)
    {
        if (!url.Contains("?"))
        {
            url += "?";
        }
        else if (!url.EndsWith("&"))
        {
            url += "&";
        }

        return url + query;
    }

    [DebuggerStepThrough]
    public static string AddQueryString(this string url, string name, string value)
    {
        return url.AddQueryString(name + "=" + UrlEncoder.Default.Encode(value));
    }

    [DebuggerStepThrough]
    public static string AddHashFragment(this string url, string query)
    {
        if (!url.Contains("#"))
        {
            url += "#";
        }

        return url + query;
    }

    [DebuggerStepThrough]
    public static NameValueCollection ReadQueryStringAsNameValueCollection(this string url)
    {
        if (url != null)
        {
            var idx = url.IndexOf('?');
            if (idx >= 0)
            {
                url = url.Substring(idx + 1);
            }
            var query = QueryHelpers.ParseNullableQuery(url);
            if (query != null)
            {
                return query.AsNameValueCollection();
            }
        }

        return new NameValueCollection();
    }

    public static string GetOrigin(this string url)
    {
        if (url != null)
        {
            Uri uri;
            try
            {
                uri = new Uri(url);
            }
            catch (Exception)
            {
                return null;
            }

            if (uri.Scheme == "http" || uri.Scheme == "https")
            {
                return $"{uri.Scheme}://{uri.Authority}";
            }
        }

        return null;
    }

    public static string Obfuscate(this string value)
    {
        var last4Chars = "****";
        if (value.IsPresent() && value.Length > 4)
        {
            last4Chars = value.Substring(value.Length - 4);
        }

        return "****" + last4Chars;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/TokenExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

/// 
/// Extensions for Token
/// 
public static class TokenExtensions
{
    /// 
    /// Creates the default JWT payload.
    /// 
    /// The token.
    /// The clock.
    /// The options
    /// The logger.
    /// 
    /// 
    /// 
    public static JwtPayload CreateJwtPayload(this Token token, ISystemClock clock, IdentityServerOptions options, ILogger logger)
    {
        var payload = new JwtPayload(
            token.Issuer,
            null,
            null,
            clock.UtcNow.UtcDateTime,
            clock.UtcNow.UtcDateTime.AddSeconds(token.Lifetime));

        foreach (var aud in token.Audiences)
        {
            payload.AddClaim(new Claim(JwtClaimTypes.Audience, aud));
        }

        var amrClaims = token.Claims.Where(x => x.Type == JwtClaimTypes.AuthenticationMethod).ToArray();
        var scopeClaims = token.Claims.Where(x => x.Type == JwtClaimTypes.Scope).ToArray();
        var jsonClaims = token.Claims.Where(x => x.ValueType == IdentityServerConstants.ClaimValueTypes.Json).ToList();
        
        // add confirmation claim if present (it's JSON valued)
        if (token.Confirmation.IsPresent())
        {
            jsonClaims.Add(new Claim(JwtClaimTypes.Confirmation, token.Confirmation, IdentityServerConstants.ClaimValueTypes.Json));
        }

        var normalClaims = token.Claims
            .Except(amrClaims)
            .Except(jsonClaims)
            .Except(scopeClaims);

        payload.AddClaims(normalClaims);

        // scope claims
        if (!scopeClaims.EnumerableIsNullOrEmpty())
        {
            var scopeValues = scopeClaims.Select(x => x.Value).ToArray();

            if (options.EmitScopesAsSpaceDelimitedStringInJwt)
            {
                payload.Add(JwtClaimTypes.Scope, string.Join(" ", scopeValues));
            }
            else
            {
                payload.Add(JwtClaimTypes.Scope, scopeValues);
            }
        }

        // amr claims
        if (!amrClaims.EnumerableIsNullOrEmpty())
        {
            var amrValues = amrClaims.Select(x => x.Value).Distinct().ToArray();
            payload.Add(JwtClaimTypes.AuthenticationMethod, amrValues);
        }
        
        // deal with json types
        // calling ToArray() to trigger JSON parsing once and so later 
        // collection identity comparisons work for the anonymous type
        try
        {
            var jsonTokens = jsonClaims.Select(x => new { x.Type, JsonValue = JRaw.Parse(x.Value) }).ToArray();

            var jsonObjects = jsonTokens.Where(x => x.JsonValue.Type == JTokenType.Object).ToArray();
            var jsonObjectGroups = jsonObjects.GroupBy(x => x.Type).ToArray();
            foreach (var group in jsonObjectGroups)
            {
                if (payload.ContainsKey(group.Key))
                {
                    throw new Exception($"Can't add two claims where one is a JSON object and the other is not a JSON object ({group.Key})");
                }

                if (group.Skip(1).Any())
                {
                    // add as array
                    payload.Add(group.Key, group.Select(x => x.JsonValue).ToArray());
                }
                else
                {
                    // add just one
                    payload.Add(group.Key, group.First().JsonValue);
                }
            }

            var jsonArrays = jsonTokens.Where(x => x.JsonValue.Type == JTokenType.Array).ToArray();
            var jsonArrayGroups = jsonArrays.GroupBy(x => x.Type).ToArray();
            foreach (var group in jsonArrayGroups)
            {
                if (payload.ContainsKey(group.Key))
                {
                    throw new Exception(
                        $"Can't add two claims where one is a JSON array and the other is not a JSON array ({group.Key})");
                }

                var newArr = new List();
                foreach (var arrays in group)
                {
                    var arr = (JArray)arrays.JsonValue;
                    newArr.AddRange(arr);
                }

                // add just one array for the group/key/claim type
                payload.Add(group.Key, newArr.ToArray());
            }

            var unsupportedJsonTokens = jsonTokens.Except(jsonObjects).Except(jsonArrays).ToArray();
            var unsupportedJsonClaimTypes = unsupportedJsonTokens.Select(x => x.Type).Distinct().ToArray();
            if (unsupportedJsonClaimTypes.Any())
            {
                throw new Exception(
                    $"Unsupported JSON type for claim types: {unsupportedJsonClaimTypes.Aggregate((x, y) => x + ", " + y)}");
            }

            return payload;
        }
        catch (Exception ex)
        {
            logger.LogCritical(ex, "Error creating a JSON valued claim");
            throw;
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/ValidatedAuthorizeRequestExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Validation;

public static class ValidatedAuthorizeRequestExtensions
{
    public static void RemovePrompt(this ValidatedAuthorizeRequest request)
    {
        request.PromptModes = Enumerable.Empty();
        request.Raw.Remove(OidcConstants.AuthorizeRequest.Prompt);
    }

    public static string GetPrefixedAcrValue(this ValidatedAuthorizeRequest request, string prefix)
    {
        var value = request.AuthenticationContextReferenceClasses
            .FirstOrDefault(x => x.StartsWith(prefix));

        if (value != null)
        {
            value = value.Substring(prefix.Length);
        }

        return value;
    }

    public static void RemovePrefixedAcrValue(this ValidatedAuthorizeRequest request, string prefix)
    {
        request.AuthenticationContextReferenceClasses.RemoveAll(acr => acr.StartsWith(prefix, StringComparison.Ordinal));
        var acr_values = request.AuthenticationContextReferenceClasses.ToSpaceSeparatedString();
        if (acr_values.IsPresent())
        {
            request.Raw[OidcConstants.AuthorizeRequest.AcrValues] = acr_values;
        }
        else
        {
            request.Raw.Remove(OidcConstants.AuthorizeRequest.AcrValues);
        }
    }

    public static string GetIdP(this ValidatedAuthorizeRequest request)
    {
        return request.GetPrefixedAcrValue(Constants.KnownAcrValues.HomeRealm);
    }

    public static void RemoveIdP(this ValidatedAuthorizeRequest request)
    {
        request.RemovePrefixedAcrValue(Constants.KnownAcrValues.HomeRealm);
    }

    public static string GetTenant(this ValidatedAuthorizeRequest request)
    {
        return request.GetPrefixedAcrValue(Constants.KnownAcrValues.Tenant);
    }

    public static IEnumerable GetAcrValues(this ValidatedAuthorizeRequest request)
    {
        return request
            .AuthenticationContextReferenceClasses
            .Where(acr => !Constants.KnownAcrValues.All.Any(well_known => acr.StartsWith(well_known)))
            .Distinct()
            .ToArray();
    }

    public static void RemoveAcrValue(this ValidatedAuthorizeRequest request, string value)
    {
        request.AuthenticationContextReferenceClasses.RemoveAll(x => x.Equals(value, StringComparison.Ordinal));
        var acr_values = request.AuthenticationContextReferenceClasses.ToSpaceSeparatedString();
        if (acr_values.IsPresent())
        {
            request.Raw[OidcConstants.AuthorizeRequest.AcrValues] = acr_values;
        }
        else
        {
            request.Raw.Remove(OidcConstants.AuthorizeRequest.AcrValues);
        }
    }

    public static void AddAcrValue(this ValidatedAuthorizeRequest request, string value)
    {
        if (String.IsNullOrWhiteSpace(value)) throw new ArgumentNullException(nameof(value));

        request.AuthenticationContextReferenceClasses.Add(value);
        var acr_values = request.AuthenticationContextReferenceClasses.ToSpaceSeparatedString();
        request.Raw[OidcConstants.AuthorizeRequest.AcrValues] = acr_values;
    }

    public static string GenerateSessionStateValue(this ValidatedAuthorizeRequest request)
    {
        if (request == null) return null;
        if (!request.IsOpenIdRequest) return null;
        
        if (request.SessionId == null) return null;

        if (request.ClientId.IsMissing()) return null;
        if (request.RedirectUri.IsMissing()) return null;

        var clientId = request.ClientId;
        var sessionId = request.SessionId;
        var salt = CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex);

        var uri = new Uri(request.RedirectUri);
        var origin = uri.Scheme + "://" + uri.Host;
        if (!uri.IsDefaultPort)
        {
            origin += ":" + uri.Port;
        }

        var bytes = Encoding.UTF8.GetBytes(clientId + origin + sessionId + salt);
        byte[] hash;

        using (var sha = SHA256.Create())
        {
            hash = sha.ComputeHash(bytes);
        }

        return Base64Url.Encode(hash) + "." + salt;
    }
}


================================================
FILE: src/IdentityServer8/src/Extensions/X509CertificateExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServer8.Extensions;

/// 
/// Extensions methods for X509Certificate2
/// 
public static class X509CertificateExtensions
{
    /// 
    /// Create the value of a thumbprint-based cnf claim
    /// 
    /// 
    /// 
    public static string CreateThumbprintCnf(this X509Certificate2 certificate)
    {
        var hash = certificate.GetCertHash(HashAlgorithmName.SHA256);
                        
        var values = new Dictionary
        {
            { "x5t#S256", Base64Url.Encode(hash) }
        };

        return JsonSerializer.Serialize(values);
    }
}


================================================
FILE: src/IdentityServer8/src/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8;
global using IdentityServer8.Configuration;
global using IdentityServer8.Configuration.DependencyInjection;
global using IdentityServer8.Endpoints;
global using IdentityServer8.Endpoints.Results;
global using IdentityServer8.Events;
global using IdentityServer8.Extensions;
global using IdentityServer8.Hosting;
global using IdentityServer8.Hosting.FederatedSignOut;
global using IdentityServer8.Hosting.LocalApiAuthentication;
global using IdentityServer8.Infrastructure;
global using IdentityServer8.Logging;
global using IdentityServer8.Logging.Models;
global using IdentityServer8.Models;
global using IdentityServer8.ResponseHandling;
global using IdentityServer8.Services;
global using IdentityServer8.Services.Default;
global using IdentityServer8.Stores;
global using IdentityServer8.Stores.Serialization;
global using IdentityServer8.Test;
global using IdentityServer8.Validation;
global using Microsoft.AspNetCore.Authentication;
global using Microsoft.AspNetCore.Authentication.Cookies;
global using Microsoft.AspNetCore.Authentication.OpenIdConnect;
global using Microsoft.AspNetCore.Builder;
global using Microsoft.AspNetCore.Cors.Infrastructure;
//global using Microsoft.AspNetCore.DataProtection;
global using Microsoft.AspNetCore.Http;
global using Microsoft.AspNetCore.WebUtilities;
global using Microsoft.Extensions.Caching.Distributed;
global using Microsoft.Extensions.Caching.Memory;
global using Microsoft.Extensions.Configuration;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.DependencyInjection.Extensions;
global using Microsoft.Extensions.Logging;
global using Microsoft.Extensions.Options;
global using Microsoft.Extensions.Primitives;
//global using Microsoft.IdentityModel.Tokens;
//global using Microsoft.Net.Http.Headers;
global using Newtonsoft.Json;
global using Newtonsoft.Json.Linq;
global using System.Buffers;
global using System.Collections.Concurrent;
global using System.Collections.Specialized;
global using System.Diagnostics;
global using System.Globalization;
global using System.IdentityModel.Tokens.Jwt;
global using System.Net;
global using System.Reflection;
global using System.Runtime.CompilerServices;
global using System.Security.Claims;
global using System.Security.Cryptography;
global using System.Security.Cryptography.X509Certificates;
global using System.Security.Principal;
global using System.Text;
global using System.Text.Encodings.Web;
global using System.Text.Json;
global using System.Text.Json.Serialization;
global using static IdentityServer8.Constants;
global using static IdentityServer8.IdentityServerConstants;
global using ClaimValueTypes = System.Security.Claims.ClaimValueTypes;


================================================
FILE: src/IdentityServer8/src/Hosting/BaseUrlMiddleware.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Hosting;

public class BaseUrlMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IdentityServerOptions _options;

    public BaseUrlMiddleware(RequestDelegate next, IdentityServerOptions options)
    {
        _next = next;
        _options = options;
    }

    public async Task Invoke(HttpContext context)
    {
        var request = context.Request;
        
        context.SetIdentityServerBasePath(request.PathBase.Value.RemoveTrailingSlash());

        await _next(context);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/CorsMiddleware.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Hosting;

public static class CorsMiddlewareExtensions
{
    public static void ConfigureCors(this IApplicationBuilder app)
    {
        var options = app.ApplicationServices.GetRequiredService();
        app.UseCors(options.Cors.CorsPolicyName);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/CorsPolicyProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

internal class CorsPolicyProvider : ICorsPolicyProvider
{
    private readonly ILogger _logger;
    private readonly ICorsPolicyProvider _inner;
    private readonly IdentityServerOptions _options;
    private readonly IHttpContextAccessor _httpContext;

    public CorsPolicyProvider(
        ILogger logger,
        Decorator inner,
        IdentityServerOptions options,
        IHttpContextAccessor httpContext)
    {
        _logger = logger;
        _inner = inner.Instance;
        _options = options;
        _httpContext = httpContext;
    }

    public Task GetPolicyAsync(HttpContext context, string policyName)
    {
        if (_options.Cors.CorsPolicyName == policyName)
        {
            return ProcessAsync(context);
        }
        else
        {
            return _inner.GetPolicyAsync(context, policyName);
        }
    }
    private async Task ProcessAsync(HttpContext context)
    {
        var origin = context.Request.GetCorsOrigin();
        if (origin != null)
        {
            var path = context.Request.Path;
            if (IsPathAllowed(path))
            {
                var sanitizedOrigin = origin.SanitizeForLog();
                _logger.LogDebug("CORS request made for path: {path} from origin: {origin}", path.SanitizeForLog(), sanitizedOrigin);

                // manually resolving this from DI because this: 
                // https://github.com/aspnet/CORS/issues/105
                var corsPolicyService = _httpContext.HttpContext.RequestServices.GetRequiredService();

                if (await corsPolicyService.IsOriginAllowedAsync(origin))
                {
                    _logger.LogDebug("CorsPolicyService allowed origin: {origin}", sanitizedOrigin);
                    return Allow(origin);
                }
                else
                {
                    _logger.LogWarning("CorsPolicyService did not allow origin: {origin}", sanitizedOrigin);
                }
            }
            else
            {
                _logger.LogDebug("CORS request made for path: {path} from origin: {origin} but was ignored because path was not for an allowed IdentityServer CORS endpoint", Ioc.Sanitizer.Log.Sanitize(path), Ioc.Sanitizer.Log.Sanitize(origin));
            }
        }

        return null;
    }

    private CorsPolicy Allow(string origin)
    {
        var policyBuilder = new CorsPolicyBuilder()
            .WithOrigins(origin)
            .AllowAnyHeader()
            .AllowAnyMethod();

        if (_options.Cors.PreflightCacheDuration.HasValue)
        {
            policyBuilder.SetPreflightMaxAge(_options.Cors.PreflightCacheDuration.Value);
        }

        return policyBuilder.Build();
    }

    private bool IsPathAllowed(PathString path)
    {
        return _options.Cors.CorsPaths.Any(x => path == x);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/Endpoint.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591


namespace IdentityServer8.Hosting;

public class Endpoint
{
    public Endpoint(string name, string path, Type handlerType)
    {
        Name = name;
        Path = path;
        Handler = handlerType;
    }

    /// 
    /// Gets or sets the name.
    /// 
    /// 
    /// The name.
    /// 
    public string Name { get; set; }

    /// 
    /// Gets or sets the path.
    /// 
    /// 
    /// The path.
    /// 
    public PathString Path { get; set; }

    /// 
    /// Gets or sets the handler.
    /// 
    /// 
    /// The handler.
    /// 
    public Type Handler { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Hosting/EndpointRouter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

internal class EndpointRouter : IEndpointRouter
{
    private readonly IEnumerable _endpoints;
    private readonly IdentityServerOptions _options;
    private readonly ILogger _logger;

    public EndpointRouter(IEnumerable endpoints, IdentityServerOptions options, ILogger logger)
    {
        _endpoints = endpoints;
        _options = options;
        _logger = logger;
    }

    public IEndpointHandler Find(HttpContext context)
    {
        if (context == null) throw new ArgumentNullException(nameof(context));

        foreach(var endpoint in _endpoints)
        {
            var path = endpoint.Path;
            if (context.Request.Path.Equals(path, StringComparison.OrdinalIgnoreCase))
            {
                var endpointName = endpoint.Name;
                _logger.LogDebug("Request path {path} matched to endpoint type {endpoint}", Ioc.Sanitizer.Log.Sanitize(context.Request.Path), endpointName);

                return GetEndpointHandler(endpoint, context);
            }
        }

        _logger.LogTrace("No endpoint entry found for request path: {path}", Ioc.Sanitizer.Log.Sanitize(context.Request.Path));

        return null;
    }

    private IEndpointHandler GetEndpointHandler(Endpoint endpoint, HttpContext context)
    {
        if (_options.Endpoints.IsEndpointEnabled(endpoint))
        {
            if (context.RequestServices.GetService(endpoint.Handler) is IEndpointHandler handler)
            {
                _logger.LogDebug("Endpoint enabled: {endpoint}, successfully created handler: {endpointHandler}", endpoint.Name, endpoint.Handler.FullName);
                return handler;
            }

            _logger.LogDebug("Endpoint enabled: {endpoint}, failed to create handler: {endpointHandler}", endpoint.Name, endpoint.Handler.FullName);
        }
        else
        {
            _logger.LogWarning("Endpoint disabled: {endpoint}", endpoint.Name);
        }

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/FederatedSignOut/AuthenticationRequestHandlerWrapper.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.FederatedSignOut;

internal class AuthenticationRequestHandlerWrapper : IAuthenticationRequestHandler
{
    private const string IframeHtml = "";

    private readonly IAuthenticationRequestHandler _inner;
    private readonly HttpContext _context;
    private readonly ILogger _logger;

    public AuthenticationRequestHandlerWrapper(IAuthenticationRequestHandler inner, IHttpContextAccessor httpContextAccessor)
    {
        _inner = inner;
        _context = httpContextAccessor.HttpContext;

        var factory = (ILoggerFactory)_context.RequestServices.GetService(typeof(ILoggerFactory));
        _logger = factory?.CreateLogger(GetType());
    }

    public Task InitializeAsync(AuthenticationScheme scheme, HttpContext context)
    {
        return _inner.InitializeAsync(scheme, context);
    }

    public async Task HandleRequestAsync()
    {
        var result = await _inner.HandleRequestAsync();

        if (result && _context.GetSignOutCalled() && _context.Response.StatusCode == 200)
        {
            // given that this runs prior to the authentication middleware running
            // we need to explicitly trigger authentication so we can have our 
            // session service populated with the current user info
            await _context.AuthenticateAsync();

            // now we can do our processing to render the iframe (if needed)
            await ProcessFederatedSignOutRequestAsync();
        }

        return result;
    }

    public Task AuthenticateAsync()
    {
        return _inner.AuthenticateAsync();
    }

    public Task ChallengeAsync(AuthenticationProperties properties)
    {
        return _inner.ChallengeAsync(properties);
    }

    public Task ForbidAsync(AuthenticationProperties properties)
    {
        return _inner.ForbidAsync(properties);
    }

    private async Task ProcessFederatedSignOutRequestAsync()
    {
        _logger?.LogDebug("Processing federated signout");

        var iframeUrl = await _context.GetIdentityServerSignoutFrameCallbackUrlAsync();
        if (iframeUrl != null)
        {
            _logger?.LogDebug("Rendering signout callback iframe");
            await RenderResponseAsync(iframeUrl);
        }
        else
        {
            _logger?.LogDebug("No signout callback iframe to render");
        }
    }

    private async Task RenderResponseAsync(string iframeUrl)
    {
        _context.Response.SetNoCache();

        if (_context.Response.Body.CanWrite)
        {
            var iframe = String.Format(IframeHtml, iframeUrl);
            _context.Response.ContentType = "text/html";
            await _context.Response.WriteAsync(iframe);
            await _context.Response.Body.FlushAsync();
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/FederatedSignOut/AuthenticationRequestSignInHandlerWrapper.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.FederatedSignOut;

internal class AuthenticationRequestSignInHandlerWrapper : AuthenticationRequestSignOutHandlerWrapper, IAuthenticationSignInHandler
{
    private readonly IAuthenticationSignInHandler _inner;

    public AuthenticationRequestSignInHandlerWrapper(IAuthenticationSignInHandler inner, IHttpContextAccessor httpContextAccessor)
        : base(inner, httpContextAccessor)
    {
        _inner = inner;
    }

    public Task SignInAsync(ClaimsPrincipal user, AuthenticationProperties properties)
    {
        return _inner.SignInAsync(user, properties);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/FederatedSignOut/AuthenticationRequestSignOutHandlerWrapper.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.FederatedSignOut;

internal class AuthenticationRequestSignOutHandlerWrapper : AuthenticationRequestHandlerWrapper, IAuthenticationSignOutHandler
{
    private readonly IAuthenticationSignOutHandler _inner;

    public AuthenticationRequestSignOutHandlerWrapper(IAuthenticationSignOutHandler inner, IHttpContextAccessor httpContextAccessor)
        : base((IAuthenticationRequestHandler)inner, httpContextAccessor)
    {
        _inner = inner;
    }

    public Task SignOutAsync(AuthenticationProperties properties)
    {
        return _inner.SignOutAsync(properties);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/FederatedSignOut/FederatedSignoutAuthenticationHandlerProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.FederatedSignOut;

// this intercepts IAuthenticationRequestHandler authentication handlers
// to detect when they are handling federated signout. when they are invoked,
// call signout on the default authentication scheme, and return 200 then 
// we assume they are handling the federated signout in an iframe. 
// based on this assumption, we then render our federated signout iframes 
// to any current clients.
internal class FederatedSignoutAuthenticationHandlerProvider : IAuthenticationHandlerProvider
{
    private readonly IAuthenticationHandlerProvider _provider;
    private readonly IHttpContextAccessor _httpContextAccessor;

    public FederatedSignoutAuthenticationHandlerProvider(
        Decorator decorator, 
        IHttpContextAccessor httpContextAccessor)
    {
        _provider = decorator.Instance;
        _httpContextAccessor = httpContextAccessor;
    }

    public async Task GetHandlerAsync(HttpContext context, string authenticationScheme)
    {
        var handler = await _provider.GetHandlerAsync(context, authenticationScheme);
        if (handler is IAuthenticationRequestHandler requestHandler)
        {
            if (requestHandler is IAuthenticationSignInHandler signinHandler)
            {
                return new AuthenticationRequestSignInHandlerWrapper(signinHandler, _httpContextAccessor);
            }

            if (requestHandler is IAuthenticationSignOutHandler signoutHandler)
            {
                return new AuthenticationRequestSignOutHandlerWrapper(signoutHandler, _httpContextAccessor);
            }

            return new AuthenticationRequestHandlerWrapper(requestHandler, _httpContextAccessor);
        }

        return handler;
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/IEndpointHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

/// 
/// Endpoint handler
/// 
public interface IEndpointHandler
{
    /// 
    /// Processes the request.
    /// 
    /// The HTTP context.
    /// 
    Task ProcessAsync(HttpContext context);
}


================================================
FILE: src/IdentityServer8/src/Hosting/IEndpointResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

/// 
/// Endpoint result
/// 
public interface IEndpointResult
{
    /// 
    /// Executes the result.
    /// 
    /// The HTTP context.
    /// 
    Task ExecuteAsync(HttpContext context);
}


================================================
FILE: src/IdentityServer8/src/Hosting/IEndpointRouter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

/// 
/// The endpoint router
/// 
public interface IEndpointRouter
{
    /// 
    /// Finds a matching endpoint.
    /// 
    /// The HTTP context.
    /// 
    IEndpointHandler Find(HttpContext context);
}


================================================
FILE: src/IdentityServer8/src/Hosting/IdentityServerAuthenticationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

// this decorates the real authentication service to detect when the 
// user is being signed in. this allows us to ensure the user has
// the claims needed for identity server to do its job. it also allows
// us to track signin/signout so we can issue/remove the session id
// cookie used for check session iframe for session management spec.
// finally, we track if signout is called to collaborate with the 
// FederatedSignoutAuthenticationHandlerProvider for federated signout.
internal class IdentityServerAuthenticationService : IAuthenticationService
{
    private readonly IAuthenticationService _inner;
    private readonly IAuthenticationSchemeProvider _schemes;
    private readonly ISystemClock _clock;
    private readonly IUserSession _session;
    private readonly IBackChannelLogoutService _backChannelLogoutService;
    private readonly IdentityServerOptions _options;
    private readonly ILogger _logger;

    public IdentityServerAuthenticationService(
        Decorator decorator,
        IAuthenticationSchemeProvider schemes,
        ISystemClock clock,
        IUserSession session,
        IBackChannelLogoutService backChannelLogoutService,
        IdentityServerOptions options,
        ILogger logger)
    {
        _inner = decorator.Instance;
        
        _schemes = schemes;
        _clock = clock;
        _session = session;
        _backChannelLogoutService = backChannelLogoutService;
        _options = options;
        _logger = logger;
    }

    public async Task SignInAsync(HttpContext context, string scheme, ClaimsPrincipal principal, AuthenticationProperties properties)
    {
        var defaultScheme = await _schemes.GetDefaultSignInSchemeAsync();
        var cookieScheme = await context.GetCookieAuthenticationSchemeAsync();

        if ((scheme == null && defaultScheme?.Name == cookieScheme) || scheme == cookieScheme)
        {
            AugmentPrincipal(principal);

            properties ??= new AuthenticationProperties();
            await _session.CreateSessionIdAsync(principal, properties);
        }

        await _inner.SignInAsync(context, scheme, principal, properties);
    }

    private void AugmentPrincipal(ClaimsPrincipal principal)
    {
        _logger.LogDebug("Augmenting SignInContext");

        AssertRequiredClaims(principal);
        AugmentMissingClaims(principal, _clock.UtcNow.UtcDateTime);
    }

    public async Task SignOutAsync(HttpContext context, string scheme, AuthenticationProperties properties)
    {
        var defaultScheme = await _schemes.GetDefaultSignOutSchemeAsync();
        var cookieScheme = await context.GetCookieAuthenticationSchemeAsync();

        if ((scheme == null && defaultScheme?.Name == cookieScheme) || scheme == cookieScheme)
        {
            // this sets a flag used by middleware to do post-signout work.
            context.SetSignOutCalled();
        }

        await _inner.SignOutAsync(context, scheme, properties);
    }

    public Task AuthenticateAsync(HttpContext context, string scheme)
    {
        return _inner.AuthenticateAsync(context, scheme);
    }

    public Task ChallengeAsync(HttpContext context, string scheme, AuthenticationProperties properties)
    {
        return _inner.ChallengeAsync(context, scheme, properties);
    }

    public Task ForbidAsync(HttpContext context, string scheme, AuthenticationProperties properties)
    {
        return _inner.ForbidAsync(context, scheme, properties);
    }

    private void AssertRequiredClaims(ClaimsPrincipal principal)
    {
        // for now, we don't allow more than one identity in the principal/cookie
        if (principal.Identities.Count() != 1) throw new InvalidOperationException("only a single identity supported");
        if (principal.FindFirst(JwtClaimTypes.Subject) == null) throw new InvalidOperationException("sub claim is missing");
    }

    private void AugmentMissingClaims(ClaimsPrincipal principal, DateTime authTime)
    {
        var identity = principal.Identities.First();

        // ASP.NET Identity issues this claim type and uses the authentication middleware name
        // such as "Google" for the value. this code is trying to correct/convert that for
        // our scenario. IOW, we take their old AuthenticationMethod value of "Google"
        // and issue it as the idp claim. we then also issue a amr with "external"
        var amr = identity.FindFirst(ClaimTypes.AuthenticationMethod);
        if (amr != null &&
            identity.FindFirst(JwtClaimTypes.IdentityProvider) == null &&
            identity.FindFirst(JwtClaimTypes.AuthenticationMethod) == null)
        {
            _logger.LogDebug("Removing amr claim with value: {value}", amr.Value);
            identity.RemoveClaim(amr);

            _logger.LogDebug("Adding idp claim with value: {value}", amr.Value);
            identity.AddClaim(new Claim(JwtClaimTypes.IdentityProvider, amr.Value));

            _logger.LogDebug("Adding amr claim with value: {value}", Constants.ExternalAuthenticationMethod);
            identity.AddClaim(new Claim(JwtClaimTypes.AuthenticationMethod, Constants.ExternalAuthenticationMethod));
        }

        if (identity.FindFirst(JwtClaimTypes.IdentityProvider) == null)
        {
            _logger.LogDebug("Adding idp claim with value: {value}", IdentityServerConstants.LocalIdentityProvider);
            identity.AddClaim(new Claim(JwtClaimTypes.IdentityProvider, IdentityServerConstants.LocalIdentityProvider));
        }

        if (identity.FindFirst(JwtClaimTypes.AuthenticationMethod) == null)
        {
            if (identity.FindFirst(JwtClaimTypes.IdentityProvider).Value == IdentityServerConstants.LocalIdentityProvider)
            {
                _logger.LogDebug("Adding amr claim with value: {value}", OidcConstants.AuthenticationMethods.Password);
                identity.AddClaim(new Claim(JwtClaimTypes.AuthenticationMethod, OidcConstants.AuthenticationMethods.Password));
            }
            else
            {
                _logger.LogDebug("Adding amr claim with value: {value}", Constants.ExternalAuthenticationMethod);
                identity.AddClaim(new Claim(JwtClaimTypes.AuthenticationMethod, Constants.ExternalAuthenticationMethod));
            }
        }

        if (identity.FindFirst(JwtClaimTypes.AuthenticationTime) == null)
        {
            var time = new DateTimeOffset(authTime).ToUnixTimeSeconds().ToString();

            _logger.LogDebug("Adding auth_time claim with value: {value}", time);
            identity.AddClaim(new Claim(JwtClaimTypes.AuthenticationTime, time, ClaimValueTypes.Integer64));
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/IdentityServerMiddleware.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

/// 
/// IdentityServer middleware
/// 
public class IdentityServerMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The next.
    /// The logger.
    public IdentityServerMiddleware(RequestDelegate next, ILogger logger)
    {
        _next = next;
        _logger = logger;
    }

    /// 
    /// Invokes the middleware.
    /// 
    /// The context.
    /// The router.
    /// The user session.
    /// The event service.
    /// 
    /// 
    public async Task Invoke(HttpContext context, IEndpointRouter router, IUserSession session, IEventService events, IBackChannelLogoutService backChannelLogoutService)
    {
        // this will check the authentication session and from it emit the check session
        // cookie needed from JS-based signout clients.
        await session.EnsureSessionIdCookieAsync();

        context.Response.OnStarting(async () =>
        {
            if (context.GetSignOutCalled())
            {
                _logger.LogDebug("SignOutCalled set; processing post-signout session cleanup.");

                // this clears our session id cookie so JS clients can detect the user has signed out
                await session.RemoveSessionIdCookieAsync();

                // back channel logout
                var logoutContext = await session.GetLogoutNotificationContext();
                if (logoutContext != null)
                {
                    await backChannelLogoutService.SendLogoutNotificationsAsync(logoutContext);
                }
            }
        });

        try
        {
            var endpoint = router.Find(context);
            if (endpoint != null)
            {
                _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString());

                var result = await endpoint.ProcessAsync(context);

                if (result != null)
                {
                    _logger.LogTrace("Invoking result: {type}", result.GetType().FullName);
                    await result.ExecuteAsync(context);
                }

                return;
            }
        }
        catch (Exception ex)
        {
            await events.RaiseAsync(new UnhandledExceptionEvent(ex));
            _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message);
            throw;
        }

        await _next(context);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/LocalApiAuthentication/LocalApiAuthenticationEvents.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.LocalApiAuthentication;

/// 
/// Events for local API authentication
/// 
public class LocalApiAuthenticationEvents
{
    /// 
    /// Invoked after the security token has passed validation and a ClaimsIdentity has been generated.
    /// 
    public Func OnClaimsTransformation { get; set; } = context => Task.CompletedTask;

    /// 
    /// Invoked after the security token has passed validation and a ClaimsIdentity has been generated.
    /// 
    public virtual Task ClaimsTransformation(ClaimsTransformationContext context) => OnClaimsTransformation(context);

}

/// 
/// Context class for local API claims transformation
/// 
public class ClaimsTransformationContext
{
    /// 
    /// The principal
    /// 
    public ClaimsPrincipal Principal { get; set; }

    /// 
    /// the HTTP context
    /// 
    public HttpContext HttpContext { get; internal set; }
}


================================================
FILE: src/IdentityServer8/src/Hosting/LocalApiAuthentication/LocalApiAuthenticationExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Extensions for registering the local access token authentication handler
/// 
public static class LocalApiAuthenticationExtensions
{
    /// 
    /// Adds support for local APIs
    /// 
    /// The service collection
    /// Function to transform the resulting principal
    /// 
    public static IServiceCollection AddLocalApiAuthentication(this IServiceCollection services, Func> transformationFunc = null)
    {
        services.AddAuthentication()
            .AddLocalApi(options =>
            {
                options.ExpectedScope = IdentityServerConstants.LocalApi.ScopeName;

                if (transformationFunc != null)
                {
                    options.Events = new LocalApiAuthenticationEvents
                    {
                        OnClaimsTransformation = async e =>
                        {
                            e.Principal = await transformationFunc(e.Principal);
                        }
                    };
                }
            });

        services.AddAuthorization(options =>
        {
            options.AddPolicy(IdentityServerConstants.LocalApi.PolicyName, policy =>
            {
                policy.AddAuthenticationSchemes(IdentityServerConstants.LocalApi.AuthenticationScheme);
                policy.RequireAuthenticatedUser();
            });
        });

        return services;
    }

    /// 
    /// Registers the authentication handler for local APIs.
    /// 
    /// The builder.
    /// 
    public static AuthenticationBuilder AddLocalApi(this AuthenticationBuilder builder)
        => builder.AddLocalApi(IdentityServerConstants.LocalApi.AuthenticationScheme, _ => { });

    /// 
    /// Registers the authentication handler for local APIs.
    /// 
    /// The builder.
    /// The configure options.
    /// 
    public static AuthenticationBuilder AddLocalApi(this AuthenticationBuilder builder, Action configureOptions)
        => builder.AddLocalApi(IdentityServerConstants.LocalApi.AuthenticationScheme, configureOptions);

    /// 
    /// Registers the authentication handler for local APIs.
    /// 
    /// The builder.
    /// The authentication scheme.
    /// The configure options.
    /// 
    public static AuthenticationBuilder AddLocalApi(this AuthenticationBuilder builder, string authenticationScheme, Action configureOptions)
        => builder.AddLocalApi(authenticationScheme, displayName: null, configureOptions: configureOptions);

    /// 
    /// Registers the authentication handler for local APIs.
    /// 
    /// The builder.
    /// The authentication scheme.
    /// The display name of this scheme.
    /// The configure options.
    /// 
    public static AuthenticationBuilder AddLocalApi(this AuthenticationBuilder builder, string authenticationScheme, string displayName, Action configureOptions)
    {
        return builder.AddScheme(authenticationScheme, displayName, configureOptions);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/LocalApiAuthentication/LocalApiAuthenticationHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.LocalApiAuthentication;

/// 
/// Authentication handler for validating access token from the local IdentityServer
/// 
public class LocalApiAuthenticationHandler : AuthenticationHandler
{
    private readonly ITokenValidator _tokenValidator;
    private readonly ILogger _logger;

    /// 
    public LocalApiAuthenticationHandler(IOptionsMonitor options, ILoggerFactory logger, UrlEncoder encoder, ISystemClock clock, ITokenValidator tokenValidator)
        : base(options, logger, encoder, clock)
    {
        _tokenValidator = tokenValidator;
        _logger = logger.CreateLogger();
    }

    /// 
    /// The handler calls methods on the events which give the application control at certain points where processing is occurring. 
    /// If it is not provided a default instance is supplied which does nothing when the methods are called.
    /// 
    protected new LocalApiAuthenticationEvents Events
    {
        get => (LocalApiAuthenticationEvents)base.Events;
        set => base.Events = value;
    }

    /// 
    protected override Task CreateEventsAsync() => Task.FromResult(new LocalApiAuthenticationEvents());

    /// 
    protected override async Task HandleAuthenticateAsync()
    {
        _logger.LogTrace("HandleAuthenticateAsync called");

        string token = null;

        string authorization = Request.Headers["Authorization"];

        if (string.IsNullOrEmpty(authorization))
        {
            return AuthenticateResult.NoResult();
        }

        if (authorization.StartsWith("Bearer ", StringComparison.OrdinalIgnoreCase))
        {
            token = authorization.Substring("Bearer ".Length).Trim();
        }

        if (string.IsNullOrEmpty(token))
        {
            return AuthenticateResult.Fail("No Access Token is sent.");
        }

        _logger.LogTrace("Token found: {token}", Ioc.Sanitizer.Log.Sanitize(token));

        TokenValidationResult result = await _tokenValidator.ValidateAccessTokenAsync(token, Options.ExpectedScope);

        if (result.IsError)
        {
            _logger.LogTrace("Failed to validate the token");

            return AuthenticateResult.Fail(result.Error);
        }

        _logger.LogTrace("Successfully validated the token.");

        ClaimsIdentity claimsIdentity = new ClaimsIdentity(result.Claims, Scheme.Name, JwtClaimTypes.Name, JwtClaimTypes.Role);
        ClaimsPrincipal claimsPrincipal = new ClaimsPrincipal(claimsIdentity);
        AuthenticationProperties authenticationProperties = new AuthenticationProperties();

        if (Options.SaveToken)
        {
            authenticationProperties.StoreTokens(new[]
            {
                new AuthenticationToken { Name = "access_token", Value = token }
            });
        }

        var claimsTransformationContext = new ClaimsTransformationContext
        {
            Principal = claimsPrincipal,
            HttpContext = Context
        };

        await Events.ClaimsTransformation(claimsTransformationContext);

        AuthenticationTicket authenticationTicket = new AuthenticationTicket(claimsTransformationContext.Principal, authenticationProperties, Scheme.Name);
        return AuthenticateResult.Success(authenticationTicket);
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/LocalApiAuthentication/LocalApiAuthenticationOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting.LocalApiAuthentication;

/// 
/// Options for local API authentication
/// 
/// 
public class LocalApiAuthenticationOptions : AuthenticationSchemeOptions
{
    /// 
    /// Allows setting a specific required scope (optional)
    /// 
    public string ExpectedScope { get; set; }

    /// 
    /// Specifies whether the token should be saved in the authentication properties
    /// 
    public bool SaveToken { get; set; } = true;

    /// 
    /// Allows implementing events
    /// 
    public new LocalApiAuthenticationEvents Events
    {
        get { return (LocalApiAuthenticationEvents)base.Events; }
        set { base.Events = value; }
    }
}


================================================
FILE: src/IdentityServer8/src/Hosting/MutualTlsEndpointMiddleware.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Hosting;

/// 
///     Middleware for re-writing the MTLS enabled endpoints to the standard protocol endpoints
/// 
public class MutualTlsEndpointMiddleware
{
    private readonly ILogger _logger;
    private readonly RequestDelegate _next;
    private readonly IdentityServerOptions _options;

    /// 
    ///     ctor
    /// 
    /// 
    /// 
    /// 
    public MutualTlsEndpointMiddleware(RequestDelegate next, IdentityServerOptions options,
        ILogger logger)
    {
        _next = next;
        _options = options;
        _logger = logger;
    }

    /// 
    public async Task Invoke(HttpContext context, IAuthenticationSchemeProvider schemes)
    {
        if (_options.MutualTls.Enabled)
        {
            // domain-based MTLS
            if (_options.MutualTls.DomainName.IsPresent())
            {
                // separate domain
                if (_options.MutualTls.DomainName.Contains("."))
                {
                    if (context.Request.Host.Host.Equals(_options.MutualTls.DomainName,
                        StringComparison.OrdinalIgnoreCase))
                    {
                        var result = await TriggerCertificateAuthentication(context);
                        if (!result.Succeeded)
                        {
                            return;
                        }
                    }
                }
                // sub-domain
                else
                {
                    if (context.Request.Host.Host.StartsWith(_options.MutualTls.DomainName + ".", StringComparison.OrdinalIgnoreCase))
                    {
                        var result = await TriggerCertificateAuthentication(context);
                        if (!result.Succeeded)
                        {
                            return;
                        }
                    }
                }
            }
            // path based MTLS
            else if (context.Request.Path.StartsWithSegments(Constants.ProtocolRoutePaths.MtlsPathPrefix.EnsureLeadingSlash(), out var subPath))
            {
                var result = await TriggerCertificateAuthentication(context);

                if (result.Succeeded)
                {
                    var path = Constants.ProtocolRoutePaths.ConnectPathPrefix +
                               subPath.ToString().EnsureLeadingSlash();
                    path = path.EnsureLeadingSlash();

                    _logger.LogDebug("Rewriting MTLS request from: {oldPath} to: {newPath}",
                        context.Request.Path.ToString(), path);
                    context.Request.Path = path;
                }
                else
                {
                    return;
                }
            }
        }
        
        await _next(context);
    }

    private async Task TriggerCertificateAuthentication(HttpContext context)
    {
        var x509AuthResult =
            await context.AuthenticateAsync(_options.MutualTls.ClientCertificateAuthenticationScheme);

        if (!x509AuthResult.Succeeded)
        {
            _logger.LogDebug("MTLS authentication failed, error: {error}.",
                x509AuthResult.Failure?.Message);
            await context.ForbidAsync(_options.MutualTls.ClientCertificateAuthenticationScheme);
        }

        return x509AuthResult;
    }
}


================================================
FILE: src/IdentityServer8/src/IdentityServer8.csproj
================================================


    
        true
        true
    

    
        True
        True
    

    
        
        
        
    

    
        
        
    


================================================
FILE: src/IdentityServer8/src/IdentityServerConstants.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8;

public static class IdentityServerConstants
{
    public const string LocalIdentityProvider = "local";
    public const string DefaultCookieAuthenticationScheme = "idsrv";
    public const string SignoutScheme = "idsrv";
    public const string ExternalCookieAuthenticationScheme = "idsrv.external";
    public const string DefaultCheckSessionCookieName = "idsrv.session";
    public const string AccessTokenAudience = "{0}resources";

    public const string JwtRequestClientKey = "idsrv.jwtrequesturi.client";

    /// 
    /// Constants for local IdentityServer access token authentication.
    /// 
    public static class LocalApi
    {
        /// 
        /// The authentication scheme when using the AddLocalApi helper.
        /// 
        public const string AuthenticationScheme = "IdentityServerAccessToken";

        /// 
        /// The API scope name when using the AddLocalApiAuthentication helper.
        /// 
        public const string ScopeName = "IdentityServerApi";

        /// 
        /// The authorization policy name when using the AddLocalApiAuthentication helper.
        /// 
        public const string PolicyName = AuthenticationScheme;
    }

    public static class ProtocolTypes
    {
        public const string OpenIdConnect = "oidc";
        public const string WsFederation = "wsfed";
        public const string Saml2p = "saml2p";
    }

    public static class TokenTypes
    {
        public const string IdentityToken = "id_token";
        public const string AccessToken = "access_token";
    }

    public static class ClaimValueTypes
    {
        public const string Json = "json";
    }

    public static class ParsedSecretTypes
    {
        public const string NoSecret = "NoSecret";
        public const string SharedSecret = "SharedSecret";
        public const string X509Certificate = "X509Certificate";
        public const string JwtBearer = "urn:ietf:params:oauth:client-assertion-type:jwt-bearer";
    }

    public static class SecretTypes
    {
        public const string SharedSecret = "SharedSecret";
        public const string X509CertificateThumbprint = "X509Thumbprint";
        public const string X509CertificateName = "X509Name";
        public const string X509CertificateBase64 = "X509CertificateBase64";
        public const string JsonWebKey = "JWK";
    }

    public static class ProfileDataCallers
    {
        public const string UserInfoEndpoint = "UserInfoEndpoint";
        public const string ClaimsProviderIdentityToken = "ClaimsProviderIdentityToken";
        public const string ClaimsProviderAccessToken = "ClaimsProviderAccessToken";
    }

    public static class ProfileIsActiveCallers
    {
        public const string AuthorizeEndpoint = "AuthorizeEndpoint";
        public const string IdentityTokenValidation = "IdentityTokenValidation";
        public const string AccessTokenValidation = "AccessTokenValidation";
        public const string ResourceOwnerValidation = "ResourceOwnerValidation";
        public const string ExtensionGrantValidation = "ExtensionGrantValidation";
        public const string RefreshTokenValidation = "RefreshTokenValidation";
        public const string AuthorizationCodeValidation = "AuthorizationCodeValidation";
        public const string UserInfoRequestValidation = "UserInfoRequestValidation";
        public const string DeviceCodeValidation = "DeviceCodeValidation";
    }

    public static IEnumerable SupportedSigningAlgorithms = new List
    {
        SecurityAlgorithms.RsaSha256,
        SecurityAlgorithms.RsaSha384,
        SecurityAlgorithms.RsaSha512,

        SecurityAlgorithms.RsaSsaPssSha256,
        SecurityAlgorithms.RsaSsaPssSha384,
        SecurityAlgorithms.RsaSsaPssSha512,

        SecurityAlgorithms.EcdsaSha256,
        SecurityAlgorithms.EcdsaSha384,
        SecurityAlgorithms.EcdsaSha512
    };

    public enum RsaSigningAlgorithm
    {
        RS256,
        RS384,
        RS512,

        PS256,
        PS384,
        PS512
    }

    public enum ECDsaSigningAlgorithm
    {
        ES256,
        ES384,
        ES512
    }

    public static class StandardScopes
    {
        /// REQUIRED. Informs the Authorization Server that the Client is making an OpenID Connect request. If the openid scope value is not present, the behavior is entirely unspecified.
        public const string OpenId = "openid";
        /// OPTIONAL. This scope value requests access to the End-User's default profile Claims, which are: name, family_name, given_name, middle_name, nickname, preferred_username, profile, picture, website, gender, birthdate, zoneinfo, locale, and updated_at.
        public const string Profile = "profile";
        /// OPTIONAL. This scope value requests access to the email and email_verified Claims.
        public const string Email = "email";
        /// OPTIONAL. This scope value requests access to the address Claim.
        public const string Address = "address";
        /// OPTIONAL. This scope value requests access to the phone_number and phone_number_verified Claims.
        public const string Phone = "phone";
        /// This scope value MUST NOT be used with the OpenID Connect Implicit Client Implementer's Guide 1.0. See the OpenID Connect Basic Client Implementer's Guide 1.0 (http://openid.net/specs/openid-connect-implicit-1_0.html#OpenID.Basic) for its usage in that subset of OpenID Connect.
        public const string OfflineAccess = "offline_access";
    }

    public static class PersistedGrantTypes
    {
        public const string AuthorizationCode = "authorization_code";
        public const string ReferenceToken = "reference_token";
        public const string RefreshToken = "refresh_token";
        public const string UserConsent = "user_consent";
        public const string DeviceCode = "device_code";
        public const string UserCode = "user_code";
    }

    public static class UserCodeTypes
    {
        public const string Numeric = "Numeric";
    }

    public static class HttpClients
    {
        public const int DefaultTimeoutSeconds = 10;
        public const string JwtRequestUriHttpClient = "IdentityServer:JwtRequestUriClient";
        public const string BackChannelLogoutHttpClient = "IdentityServer:BackChannelLogoutClient";
    }
}


================================================
FILE: src/IdentityServer8/src/IdentityServerTools.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

/// 
/// Class for useful helpers for interacting with IdentityServer
/// 
public class IdentityServerTools
{
    internal readonly IHttpContextAccessor ContextAccessor;
    private readonly ITokenCreationService _tokenCreation;
    private readonly ISystemClock _clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The context accessor.
    /// The token creation service.
    /// The clock.
    public IdentityServerTools(IHttpContextAccessor contextAccessor, ITokenCreationService tokenCreation, ISystemClock clock)
    {
        ContextAccessor = contextAccessor;
        _tokenCreation = tokenCreation;
        _clock = clock;
    }

    /// 
    /// Issues a JWT.
    /// 
    /// The lifetime.
    /// The claims.
    /// 
    /// claims
    public virtual async Task IssueJwtAsync(int lifetime, IEnumerable claims)
    {
        if (claims == null) throw new ArgumentNullException(nameof(claims));

        var issuer = ContextAccessor.HttpContext.GetIdentityServerIssuerUri();

        var token = new Token
        {
            CreationTime = _clock.UtcNow.UtcDateTime,
            Issuer = issuer,
            Lifetime = lifetime,

            Claims = new HashSet(claims, new ClaimComparer())
        };

        return await _tokenCreation.CreateTokenAsync(token);
    }

    /// 
    /// Issues a JWT.
    /// 
    /// The lifetime.
    /// The issuer.
    /// The claims.
    /// 
    /// claims
    public virtual async Task IssueJwtAsync(int lifetime, string issuer, IEnumerable claims)
    {
        if (String.IsNullOrWhiteSpace(issuer)) throw new ArgumentNullException(nameof(issuer));
        if (claims == null) throw new ArgumentNullException(nameof(claims));

        var token = new Token
        {
            CreationTime = _clock.UtcNow.UtcDateTime,
            Issuer = issuer,
            Lifetime = lifetime,

            Claims = new HashSet(claims, new ClaimComparer())
        };

        return await _tokenCreation.CreateTokenAsync(token);
    }
}


================================================
FILE: src/IdentityServer8/src/IdentityServerUser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

/// 
/// Model properties of an IdentityServer user
/// 
public class IdentityServerUser
{
    /// 
    /// Subject ID (mandatory)
    /// 
    public string SubjectId { get; }

    /// 
    /// Display name (optional)
    /// 
    public string DisplayName { get; set; }

    /// 
    /// Identity provider (optional)
    /// 
    public string IdentityProvider { get; set; }

    /// 
    /// Authentication methods
    /// 
    public ICollection AuthenticationMethods { get; set; } = new HashSet();

    /// 
    /// Authentication time
    /// 
    public DateTime? AuthenticationTime { get; set; }

    /// 
    /// Additional claims
    /// 
    public ICollection AdditionalClaims { get; set; } = new HashSet(new ClaimComparer());

    /// 
    /// Initializes a user identity
    /// 
    /// The subject ID
    public IdentityServerUser(string subjectId)
    {
        if (subjectId.IsMissing()) throw new ArgumentException("SubjectId is mandatory", nameof(subjectId));

        SubjectId = subjectId;
    }

    /// 
    /// Creates an IdentityServer claims principal
    /// 
    /// 
    /// 
    public ClaimsPrincipal CreatePrincipal()
    {
        if (SubjectId.IsMissing()) throw new ArgumentException("SubjectId is mandatory", nameof(SubjectId));
        var claims = new List { new Claim(JwtClaimTypes.Subject, SubjectId) };

        if (DisplayName.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.Name, DisplayName));
        }

        if (IdentityProvider.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.IdentityProvider, IdentityProvider));
        }

        if (AuthenticationTime.HasValue)
        {
            claims.Add(new Claim(JwtClaimTypes.AuthenticationTime, new DateTimeOffset(AuthenticationTime.Value).ToUnixTimeSeconds().ToString()));
        }

        if (AuthenticationMethods.Any())
        {
            foreach (var amr in AuthenticationMethods)
            {
                claims.Add(new Claim(JwtClaimTypes.AuthenticationMethod, amr));
            }
        }

        claims.AddRange(AdditionalClaims);

        var id = new ClaimsIdentity(claims.Distinct(new ClaimComparer()), Constants.IdentityServerAuthenticationType, JwtClaimTypes.Name, JwtClaimTypes.Role);
        return new ClaimsPrincipal(id);
    }
}


================================================
FILE: src/IdentityServer8/src/Infrastructure/DistributedCacheStateDataFormatter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.DataProtection;

namespace IdentityServer8.Infrastructure;

/// 
/// State formatter using IDistributedCache
/// 
public class DistributedCacheStateDataFormatter : ISecureDataFormat
{
    private readonly IHttpContextAccessor _httpContext;
    private readonly string _name;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The HTTP context accessor.
    /// The scheme name.
    public DistributedCacheStateDataFormatter(IHttpContextAccessor httpContext, string name)
    {
        _httpContext = httpContext;
        _name = name;
    }

    private string CacheKeyPrefix => "DistributedCacheStateDataFormatter";

    private IDistributedCache Cache => _httpContext.HttpContext.RequestServices.GetRequiredService();
    private IDataProtector Protector => _httpContext.HttpContext.RequestServices.GetRequiredService().CreateProtector(CacheKeyPrefix, _name);

    /// 
    /// Protects the specified data.
    /// 
    /// The data.
    /// 
    public string Protect(AuthenticationProperties data)
    {
        return Protect(data, null);
    }

    /// 
    /// Protects the specified data.
    /// 
    /// The data.
    /// The purpose.
    /// 
    public string Protect(AuthenticationProperties data, string purpose)
    {
        var key = Guid.NewGuid().ToString();
        var cacheKey = $"{CacheKeyPrefix}-{_name}-{purpose}-{key}";
        var json = ObjectSerializer.ToString(data.Items);

        var options = new DistributedCacheEntryOptions();
        if (data.ExpiresUtc.HasValue)
        {
            options.SetAbsoluteExpiration(data.ExpiresUtc.Value);
        }
        else
        {
            options.SetSlidingExpiration(Constants.DefaultCacheDuration);
        }
        
        // Rather than encrypt the full AuthenticationProperties
        // cache the data and encrypt the key that points to the data
        Cache.SetString(cacheKey, json, options);

        return Protector.Protect(key);
    }

    /// 
    /// Unprotects the specified protected text.
    /// 
    /// The protected text.
    /// 
    public AuthenticationProperties Unprotect(string protectedText)
    {
        return Unprotect(protectedText, null);
    }

    /// 
    /// Unprotects the specified protected text.
    /// 
    /// The protected text.
    /// The purpose.
    /// 
    public AuthenticationProperties Unprotect(string protectedText, string purpose)
    {
        if (String.IsNullOrWhiteSpace(protectedText))
        {
            return null;
        }

        // Decrypt the key and retrieve the data from the cache.
        var key = Protector.Unprotect(protectedText);
        var cacheKey = $"{CacheKeyPrefix}-{_name}-{purpose}-{key}";
        var json = Cache.GetString(cacheKey);

        if (json == null)
        {
            return null;
        }

        var items = ObjectSerializer.FromString>(json);
        var props = new AuthenticationProperties(items);
        return props;
    }
}


================================================
FILE: src/IdentityServer8/src/Infrastructure/MessageCookie.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.DataProtection;

namespace IdentityServer8;

internal class MessageCookie
{
    private readonly ILogger _logger;
    private readonly IdentityServerOptions _options;
    private readonly IHttpContextAccessor _context;
    private readonly IDataProtector _protector;

    public MessageCookie(
        ILogger> logger, 
        IdentityServerOptions options,
        IHttpContextAccessor context, 
        IDataProtectionProvider provider)
    {
        _logger = logger;
        _options = options;
        _context = context;
        _protector = provider.CreateProtector(MessageType);
    }

    private string MessageType => typeof(TModel).Name;

    private string Protect(Message message)
    {
        var json = ObjectSerializer.ToString(message);
        _logger.LogTrace("Protecting message: {0}", json);

        return _protector.Protect(json);
    }

    private Message Unprotect(string data)
    {
        var json = _protector.Unprotect(data);
        var message = ObjectSerializer.FromString>(json);
        return message;
    }

    private string CookiePrefix => MessageType + ".";

    private string GetCookieFullName(string id)
    {
        return CookiePrefix + id;
    }

    private string CookiePath => _context.HttpContext.GetIdentityServerBasePath().CleanUrlPath();

    private IEnumerable GetCookieNames()
    {
        var key = CookiePrefix;
        foreach ((string name, var _) in _context.HttpContext.Request.Cookies)
        {
            if (name.StartsWith(key))
            {
                yield return name;
            }
        }
    }

    private bool Secure => _context.HttpContext.Request.IsHttps;

    public void Write(string id, Message message)
    {
        ClearOverflow();

        if (message == null) throw new ArgumentNullException(nameof(message));

        var name = GetCookieFullName(id);
        var data = Protect(message);

        _context.HttpContext.Response.Cookies.Append(
            name,
            data,
            new CookieOptions
            {
                HttpOnly = true,
                Secure = Secure,
                Path = CookiePath,
                IsEssential = true
                // don't need to set same-site since cookie is expected to be sent
                // to only another page in this host. 
            });
    }

    public Message Read(string id)
    {
        if (id.IsMissing()) return null;

        var name = GetCookieFullName(id);
        return ReadByCookieName(name);
    }

    private Message ReadByCookieName(string name)
    {
        var data = _context.HttpContext.Request.Cookies[name];
        if (data.IsPresent())
        {
            try
            {
                return Unprotect(data);
            }
            catch(Exception ex)
            {
                _logger.LogError(ex, "Error unprotecting message cookie");
                ClearByCookieName(name);
            }
        }
        return null;
    }

    protected internal void Clear(string id)
    {
        var name = GetCookieFullName(id);
        ClearByCookieName(name);
    }

    private void ClearByCookieName(string name)
    {
        _context.HttpContext.Response.Cookies.Append(
            name,
            ".",
            new CookieOptions
            {
                Expires = new DateTime(2000, 1, 1),
                HttpOnly = true,
                Secure = Secure,
                Path = CookiePath,
                IsEssential = true
            });
    }

    private long GetCookieRank(string name)
    {   
        // empty and invalid cookies are considered to be the oldest:
        var rank = DateTime.MinValue.Ticks;

        try
        {
            var message = ReadByCookieName(name);
            if (message != null)
            {
                // valid cookies are ranked based on their creation time:
                rank = message.Created;
            }
        }
        catch (CryptographicException e)
        {   
            // cookie was protected with a different key/algorithm
            _logger.LogDebug(e, "Unable to unprotect cookie {0}", name);
        }
        
        return rank;
    }

    private void ClearOverflow()
    {
        var names = GetCookieNames();
        var toKeep = _options.UserInteraction.CookieMessageThreshold;

        if (names.Count() >= toKeep)
        {
            var rankedCookieNames =
                from name in names
                let rank = GetCookieRank(name)
                orderby rank descending
                select name;

            var purge = rankedCookieNames.Skip(Math.Max(0, toKeep - 1));
            foreach (var name in purge)
            {
                _logger.LogTrace("Purging stale cookie: {cookieName}", name);
                ClearByCookieName(name);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Infrastructure/ObjectSerializer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServer8;

internal static class ObjectSerializer
{
    private static readonly JsonSerializerOptions Options = new JsonSerializerOptions
    {
        IgnoreNullValues = true
    };
    
    public static string ToString(object o)
    {
        return JsonSerializer.Serialize(o, Options);
    }

    public static T FromString(string value)
    {
        return JsonSerializer.Deserialize(value, Options);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/LogSerializer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using JsonSerializer = System.Text.Json.JsonSerializer;

namespace IdentityServer8.Logging;

/// 
/// Helper to JSON serialize object data for logging.
/// 
internal static class LogSerializer
{
    static readonly JsonSerializerOptions Options = new JsonSerializerOptions
    {
        IgnoreNullValues = true,
        WriteIndented = true
    };

    static LogSerializer()
    {
        Options.Converters.Add(new JsonStringEnumConverter());
    }

    /// 
    /// Serializes the specified object.
    /// 
    /// The object.
    /// 
    public static string Serialize(object logObject)
    {
        return JsonSerializer.Serialize(logObject, Options);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/AuthorizeRequestValidationLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging.Models;

internal class AuthorizeRequestValidationLog
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string RedirectUri { get; set; }
    public IEnumerable AllowedRedirectUris { get; set; }
    public string SubjectId { get; set; }

    public string ResponseType { get; set; }
    public string ResponseMode { get; set; }
    public string GrantType { get; set; }
    public string RequestedScopes { get; set; }

    public string State { get; set; }
    public string UiLocales { get; set; }
    public string Nonce { get; set; }
    public IEnumerable AuthenticationContextReferenceClasses { get; set; }
    public string DisplayMode { get; set; }
    public string PromptMode { get; set; }
    public int? MaxAge { get; set; }
    public string LoginHint { get; set; }
    public string SessionId { get; set; }

    public Dictionary Raw { get; set; }

    public AuthorizeRequestValidationLog(ValidatedAuthorizeRequest request, IEnumerable sensitiveValuesFilter)
    {
        Raw = request.Raw.ToScrubbedDictionary(sensitiveValuesFilter.ToArray());

        if (request.Client != null)
        {
            ClientId = request.Client.ClientId;
            ClientName = request.Client.ClientName;

            AllowedRedirectUris = request.Client.RedirectUris;
        }

        if (request.Subject != null)
        {
            var subjectClaim = request.Subject.FindFirst(JwtClaimTypes.Subject);
            if (subjectClaim != null)
            {
                SubjectId = subjectClaim.Value;
            }
            else
            {
                SubjectId = "anonymous";
            }
        }

        if (request.AuthenticationContextReferenceClasses.Any())
        {
            AuthenticationContextReferenceClasses = request.AuthenticationContextReferenceClasses;
        }

        RedirectUri = request.RedirectUri;
        ResponseType = request.ResponseType;
        ResponseMode = request.ResponseMode;
        GrantType = request.GrantType;
        RequestedScopes = request.RequestedScopes.ToSpaceSeparatedString();
        State = request.State;
        UiLocales = request.UiLocales;
        Nonce = request.Nonce;

        DisplayMode = request.DisplayMode;
        PromptMode = request.PromptModes.ToSpaceSeparatedString();
        LoginHint = request.LoginHint;
        MaxAge = request.MaxAge;
        SessionId = request.SessionId;
    }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/AuthorizeResponseLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging.Models;

internal class AuthorizeResponseLog
{
    public string SubjectId { get; set; }
    public string ClientId { get; set; }
    public string RedirectUri { get; set; }
    public string State { get; set; }

    public string Scope { get; set; }
    public string Error { get; set; }
    public string ErrorDescription { get; set; }


    public AuthorizeResponseLog(AuthorizeResponse response)
    {
        ClientId = response.Request?.Client?.ClientId;
        SubjectId = response.Request?.Subject?.GetSubjectId();
        RedirectUri = response.RedirectUri;
        State = response.State;
        Scope = response.Scope;
        Error = response.Error;
        ErrorDescription = response.ErrorDescription;
    }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/DeviceAuthorizationRequestValidationLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging;

internal class DeviceAuthorizationRequestValidationLog
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string Scopes { get; set; }

    public Dictionary Raw { get; set; }

    private static readonly string[] SensitiveValuesFilter = {
        OidcConstants.TokenRequest.ClientSecret,
        OidcConstants.TokenRequest.ClientAssertion
    };

    public DeviceAuthorizationRequestValidationLog(ValidatedDeviceAuthorizationRequest request)
    {
        Raw = request.Raw.ToScrubbedDictionary(SensitiveValuesFilter);

        if (request.Client != null)
        {
            ClientId = request.Client.ClientId;
            ClientName = request.Client.ClientName;
        }

        if (request.RequestedScopes != null)
        {
            Scopes = request.RequestedScopes.ToSpaceSeparatedString();
        }
    }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/EndSessionRequestValidationLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging.Models;

internal class EndSessionRequestValidationLog
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string SubjectId { get; set; }

    public string PostLogOutUri { get; set; }
    public string State { get; set; }

    public Dictionary Raw { get; set; }

    public EndSessionRequestValidationLog(ValidatedEndSessionRequest request)
    {
        Raw = request.Raw.ToScrubbedDictionary(OidcConstants.EndSessionRequest.IdTokenHint);

        SubjectId = "unknown";
        
        var subjectClaim = request.Subject?.FindFirst(JwtClaimTypes.Subject);
        if (subjectClaim != null)
        {
            SubjectId = subjectClaim.Value;
        }

        if (request.Client != null)
        {
            ClientId = request.Client.ClientId;
            ClientName = request.Client.ClientName;
        }

        PostLogOutUri = request.PostLogOutUri;
        State = request.State;
    }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/TokenRequestValidationLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging.Models;

internal class TokenRequestValidationLog
{
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public string GrantType { get; set; }
    public string Scopes { get; set; }

    public string AuthorizationCode { get; set; }
    public string RefreshToken { get; set; }

    public string UserName { get; set; }
    public IEnumerable AuthenticationContextReferenceClasses { get; set; }
    public string Tenant { get; set; }
    public string IdP { get; set; }

    public Dictionary Raw { get; set; }

    public TokenRequestValidationLog(ValidatedTokenRequest request, IEnumerable sensitiveValuesFilter)
    {
        Raw = request.Raw.ToScrubbedDictionary(sensitiveValuesFilter.ToArray());

        if (request.Client != null)
        {
            ClientId = request.Client.ClientId;
            ClientName = request.Client.ClientName;
        }

        if (request.RequestedScopes != null)
        {
            Scopes = request.RequestedScopes.ToSpaceSeparatedString();
        }

        GrantType = request.GrantType;
        AuthorizationCode = request.AuthorizationCodeHandle.Obfuscate();
        RefreshToken = request.RefreshTokenHandle.Obfuscate();
        UserName = request.UserName;
    }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Logging/Models/TokenValidationLog.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Logging.Models;

internal class TokenValidationLog
{
    // identity token
    public string ClientId { get; set; }
    public string ClientName { get; set; }
    public bool ValidateLifetime { get; set; }

    // access token
    public string AccessTokenType { get; set; }
    public string ExpectedScope { get; set; }
    public string TokenHandle { get; set; }
    public string JwtId { get; set; }

    // both
    public Dictionary Claims { get; set; }

    public override string ToString()
    {
        return LogSerializer.Serialize(this);
    }
}


================================================
FILE: src/IdentityServer8/src/Models/Contexts/IsActiveContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Context describing the is-active check
/// 
public class IsActiveContext
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public IsActiveContext(ClaimsPrincipal subject, Client client, string caller)
    {
        if (subject == null) throw new ArgumentNullException(nameof(subject));
        if (client == null) throw new ArgumentNullException(nameof(client));
        if (caller.IsMissing()) throw new ArgumentNullException(nameof(caller));

        Subject = subject;
        Client = client;
        Caller = caller;
        
        IsActive = true;
    }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// Gets or sets the caller.
    /// 
    /// 
    /// The caller.
    /// 
    public string Caller { get; set; }

    /// 
    /// Gets or sets a value indicating whether the subject is active and can recieve tokens.
    /// 
    /// 
    ///   true if the subject is active; otherwise, false.
    /// 
    public bool IsActive { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/Contexts/LogoutNotificationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Provides the context necessary to construct a logout notificaiton.
/// 
public class LogoutNotificationContext
{
    /// 
    ///  The SubjectId of the user.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// The session Id of the user's authentication session.
    /// 
    public string SessionId { get; set; }

    /// 
    /// The list of client Ids that the user has authenticated to.
    /// 
    public IEnumerable ClientIds { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/Contexts/ProfileDataRequestContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Class describing the profile data request
/// 
public class ProfileDataRequestContext
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public ProfileDataRequestContext()
    { }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject.
    /// The client.
    /// The caller.
    /// The requested claim types.
    public ProfileDataRequestContext(ClaimsPrincipal subject, Client client, string caller, IEnumerable requestedClaimTypes)
    {
        Subject = subject ?? throw new ArgumentNullException(nameof(subject));
        Client = client ?? throw new ArgumentNullException(nameof(client));
        Caller = caller ?? throw new ArgumentNullException(nameof(caller));
        RequestedClaimTypes = requestedClaimTypes ?? throw new ArgumentNullException(nameof(requestedClaimTypes));
    }

    /// 
    /// Gets or sets the validatedRequest.
    /// 
    /// 
    /// The validatedRequest.
    /// 
    public ValidatedRequest ValidatedRequest { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets the requested claim types.
    /// 
    /// 
    /// The requested claim types.
    /// 
    public IEnumerable RequestedClaimTypes { get; set; }

    /// 
    /// Gets or sets the client id.
    /// 
    /// 
    /// The client id.
    /// 
    public Client Client { get; set; }

    /// 
    /// Gets or sets the caller.
    /// 
    /// 
    /// The caller.
    /// 
    public string Caller { get; set; }

    /// 
    /// Gets or sets the requested resources (if available).
    /// 
    /// 
    /// The resources.
    /// 
    public ResourceValidationResult RequestedResources { get; set; }

    /// 
    /// Gets or sets the issued claims.
    /// 
    /// 
    /// The issued claims.
    /// 
    public List IssuedClaims { get; set; } = new List();
}


================================================
FILE: src/IdentityServer8/src/Models/DeviceFlowAuthorizationRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Represents contextual information about a device flow authorization request.
/// 
public class DeviceFlowAuthorizationRequest
{
    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// Gets or sets the validated resources.
    /// 
    /// 
    /// The scopes requested.
    /// 
    public ResourceValidationResult ValidatedResources { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/DeviceFlowInteractionResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Request object for device flow interaction
/// 
public class DeviceFlowInteractionResult
{
    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; private set; }

    /// 
    /// Gets a value indicating whether this instance is error.
    /// 
    /// 
    ///   true if this instance is error; otherwise, false.
    /// 
    public bool IsError { get; private set; }

    /// 
    /// Gets or sets a value indicating whether this instance is access denied.
    /// 
    /// 
    ///   true if this instance is access denied; otherwise, false.
    /// 
    public bool IsAccessDenied { get; set; }

    /// 
    /// Create failure result
    /// 
    /// The error description.
    /// 
    public static DeviceFlowInteractionResult Failure(string errorDescription = null)
    {
        return new DeviceFlowInteractionResult
        {
            IsError = true,
            ErrorDescription = errorDescription
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Models/DiscoveryDocument.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Models;

public class DiscoveryDocument
{
    public string issuer { get; set; }
    public string jwks_uri { get; set; }
    public string authorization_endpoint { get; set; }
    public string token_endpoint { get; set; }
    public string userinfo_endpoint { get; set; }
    public string end_session_endpoint { get; set; }
    public string check_session_iframe { get; set; }
    public string revocation_endpoint { get; set; }
    public string introspection_endpoint { get; set; }
    public bool? frontchannel_logout_supported { get; set; }
    public bool? frontchannel_logout_session_supported { get; set; }
    public string[] scopes_supported { get; set; }
    public string[] claims_supported { get; set; }
    public string[] response_types_supported { get; set; }
    public string[] response_modes_supported { get; set; }
    public string[] grant_types_supported { get; set; }
    public string[] subject_types_supported { get; set; }
    public string[] id_token_signing_alg_values_supported { get; set; }
    public string[] token_endpoint_auth_methods_supported { get; set; }
    public string[] code_challenge_methods_supported { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/Grant.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a grant the user has given.
/// 
public class Grant
{
    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable Scopes { get; set; }

    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the expiration.
    /// 
    /// 
    /// The expiration.
    /// 
    public DateTime? Expiration { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/GrantTypes.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Models;

public class GrantTypes
{
    public static ICollection Implicit =>
        new[] { GrantType.Implicit };

    public static ICollection ImplicitAndClientCredentials =>
        new[]  { GrantType.Implicit, GrantType.ClientCredentials };

    public static ICollection Code =>
        new[] { GrantType.AuthorizationCode };

    public static ICollection CodeAndClientCredentials =>
        new[] { GrantType.AuthorizationCode, GrantType.ClientCredentials };

    public static ICollection Hybrid =>
        new[] { GrantType.Hybrid };

    public static ICollection HybridAndClientCredentials =>
        new[] { GrantType.Hybrid, GrantType.ClientCredentials };

    public static ICollection ClientCredentials =>
        new[] { GrantType.ClientCredentials };

    public static ICollection ResourceOwnerPassword =>
        new[] { GrantType.ResourceOwnerPassword };

    public static ICollection ResourceOwnerPasswordAndClientCredentials =>
        new[] { GrantType.ResourceOwnerPassword, GrantType.ClientCredentials };

    public static ICollection DeviceFlow =>
        new[] { GrantType.DeviceFlow };
}


================================================
FILE: src/IdentityServer8/src/Models/IdentityResources.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Convenience class that defines standard identity resources.
/// 
public static class IdentityResources
{
    /// 
    /// Models the standard openid scope
    /// 
    /// 
    public class OpenId : IdentityResource
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public OpenId()
        {
            Name = IdentityServerConstants.StandardScopes.OpenId;
            DisplayName = "Your user identifier";
            Required = true;
            UserClaims.Add(JwtClaimTypes.Subject);
        }
    }

    /// 
    /// Models the standard profile scope
    /// 
    /// 
    public class Profile : IdentityResource
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public Profile()
        {
            Name = IdentityServerConstants.StandardScopes.Profile;
            DisplayName = "User profile";
            Description = "Your user profile information (first name, last name, etc.)";
            Emphasize = true;
            UserClaims = Constants.ScopeToClaimsMapping[IdentityServerConstants.StandardScopes.Profile].ToList();
        }
    }

    /// 
    /// Models the standard email scope
    /// 
    /// 
    public class Email : IdentityResource
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public Email()
        {
            Name = IdentityServerConstants.StandardScopes.Email;
            DisplayName = "Your email address";
            Emphasize = true;
            UserClaims = (Constants.ScopeToClaimsMapping[IdentityServerConstants.StandardScopes.Email].ToList());
        }
    }

    /// 
    /// Models the standard phone scope
    /// 
    /// 
    public class Phone : IdentityResource
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public Phone()
        {
            Name = IdentityServerConstants.StandardScopes.Phone;
            DisplayName = "Your phone number";
            Emphasize = true;
            UserClaims = Constants.ScopeToClaimsMapping[IdentityServerConstants.StandardScopes.Phone].ToList();
        }
    }

    /// 
    /// Models the standard address scope
    /// 
    /// 
    public class Address : IdentityResource
    {
        /// 
        /// Initializes a new instance of the  class.
        /// 
        public Address()
        {
            Name = IdentityServerConstants.StandardScopes.Address;
            DisplayName = "Your postal address";
            Emphasize = true;
            UserClaims = Constants.ScopeToClaimsMapping[IdentityServerConstants.StandardScopes.Address].ToList();
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Models/JsonWebKey.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Models;

public class JsonWebKey
{
    public string kty { get; set; }
    public string use { get; set; }
    public string kid { get; set; }
    public string x5t { get; set; }
    public string e { get; set; }
    public string n { get; set; }
    public string[] x5c { get; set; }
    public string alg { get; set; }

    public string x { get; set; }
    public string y { get; set; }
    public string crv { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/AuthorizationRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Represents contextual information about a authorization request.
/// 
public class AuthorizationRequest
{
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// The display mode passed from the authorization request.
    /// 
    /// 
    /// The display mode.
    /// 
    public string DisplayMode { get; set; }

    /// 
    /// Gets or sets the redirect URI.
    /// 
    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }

    /// 
    /// The UI locales passed from the authorization request.
    /// 
    /// 
    /// The UI locales.
    /// 
    public string UiLocales { get; set; }

    /// 
    /// The external identity provider requested. This is used to bypass home realm 
    /// discovery (HRD). This is provided via the "idp:" prefix to the acr 
    /// parameter on the authorize request.
    /// 
    /// 
    /// The external identity provider identifier.
    /// 
    public string IdP { get; set; }

    /// 
    /// The tenant requested. This is provided via the "tenant:" prefix to 
    /// the acr parameter on the authorize request.
    /// 
    /// 
    /// The tenant.
    /// 
    public string Tenant { get; set; }

    /// 
    /// The expected username the user will use to login. This is requested from the client 
    /// via the login_hint parameter on the authorize request.
    /// 
    /// 
    /// The LoginHint.
    /// 
    public string LoginHint { get; set; }

    /// 
    /// Gets or sets the collection of prompt modes.
    /// 
    /// 
    /// The collection of prompt modes.
    /// 
    public IEnumerable PromptModes { get; set; } = Enumerable.Empty();

    /// 
    /// The acr values passed from the authorization request.
    /// 
    /// 
    /// The acr values.
    /// 
    public IEnumerable AcrValues { get; set; }

    /// 
    /// The validated resources.
    /// 
    public ResourceValidationResult ValidatedResources { get; set; }

    /// 
    /// Gets the entire parameter collection.
    /// 
    /// 
    /// The parameters.
    /// 
    public NameValueCollection Parameters { get; }

    /// 
    /// Gets the validated contents of the request object (if present)
    /// 
    /// 
    /// The request object values
    /// 
    public Dictionary RequestObjectValues { get; } = new Dictionary();


    /// 
    /// Initializes a new instance of the  class.
    /// 
    public AuthorizationRequest()
    {
        // public for testing
        Parameters = new NameValueCollection();
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    internal AuthorizationRequest(ValidatedAuthorizeRequest request)
    {
        Client = request.Client;
        RedirectUri = request.RedirectUri;
        DisplayMode = request.DisplayMode;
        UiLocales = request.UiLocales;
        IdP = request.GetIdP();
        Tenant = request.GetTenant();
        LoginHint = request.LoginHint;
        PromptModes = request.PromptModes;
        AcrValues = request.GetAcrValues();
        ValidatedResources = request.ValidatedResources;
        Parameters = request.Raw;
        RequestObjectValues = request.RequestObjectValues;
    }
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/ConsentRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the parameters to identify a request for consent.
/// 
public class ConsentRequest
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// The subject.
    public ConsentRequest(AuthorizationRequest request, string subject)
    {
        ClientId = request.Client.ClientId;
        Nonce = request.Parameters[OidcConstants.AuthorizeRequest.Nonce];
        ScopesRequested = request.Parameters[OidcConstants.AuthorizeRequest.Scope].ParseScopesString();
        Subject = subject;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The parameters.
    /// The subject.
    public ConsentRequest(NameValueCollection parameters, string subject)
    {
        ClientId = parameters[OidcConstants.AuthorizeRequest.ClientId];
        Nonce = parameters[OidcConstants.AuthorizeRequest.Nonce];
        ScopesRequested = parameters[OidcConstants.AuthorizeRequest.Scope].ParseScopesString();
        Subject = subject;
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the nonce.
    /// 
    /// 
    /// The nonce.
    /// 
    public string Nonce { get; set; }

    /// 
    /// Gets or sets the scopes requested.
    /// 
    /// 
    /// The scopes requested.
    /// 
    public IEnumerable ScopesRequested { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public string Subject { get; set; }

    /// 
    /// Gets the identifier.
    /// 
    /// 
    /// The identifier.
    /// 
    public string Id
    {
        get
        {
            var normalizedScopes = ScopesRequested?.OrderBy(x => x).Distinct().Aggregate((x, y) => x + "," + y);
            var value = $"{ClientId}:{Subject}:{Nonce}:{normalizedScopes}";

            using (var sha = SHA256.Create())
            {
                var bytes = Encoding.UTF8.GetBytes(value);
                var hash = sha.ComputeHash(bytes);

                return Base64Url.Encode(hash);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/ConsentResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the user's response to the consent screen.
/// 
public class ConsentResponse
{
    /// 
    /// Error, if any, for the consent response.
    /// 
    public AuthorizationError? Error { get; set; }

    /// 
    /// Error description.
    /// 
    public string ErrorDescription { get; set; }

    /// 
    /// Gets if consent was granted.
    /// 
    /// 
    ///   true if consent was granted; otherwise, false.
    /// 
    public bool Granted => ScopesValuesConsented != null && ScopesValuesConsented.Any() && Error == null;

    /// 
    /// Gets or sets the scope values consented to.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable ScopesValuesConsented { get; set; }

    /// 
    /// Gets or sets a value indicating whether the user wishes the consent to be remembered.
    /// 
    /// 
    ///   true if consent is to be remembered; otherwise, false.
    /// 
    public bool RememberConsent { get; set; }

    /// 
    /// Gets the description of the device.
    /// 
    /// 
    /// The description of the device.
    /// 
    public string Description { get; set; }
}

/// 
/// Enum to model interaction authorization errors.
/// 
public enum AuthorizationError
{
    /// 
    /// Access denied
    /// 
    AccessDenied,

    /// 
    /// Interaction required
    /// 
    InteractionRequired,

    /// 
    /// Login required
    /// 
    LoginRequired,

    /// 
    /// Account selection required
    /// 
    AccountSelectionRequired,

    /// 
    /// Consent required
    /// 
    ConsentRequired
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/ErrorMessage.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the data for the error page.
/// 
public class ErrorMessage
{
    /// 
    /// The display mode passed from the authorization request.
    /// 
    /// 
    /// The display mode.
    /// 
    public string DisplayMode { get; set; }

    /// 
    /// The UI locales passed from the authorization request.
    /// 
    /// 
    /// The UI locales.
    /// 
    public string UiLocales { get; set; }

    /// 
    /// Gets or sets the error code.
    /// 
    /// 
    /// The error code.
    /// 
    public string Error { get; set; }

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }

    /// 
    /// The per-request identifier. This can be used to display to the end user and can be used in diagnostics.
    /// 
    /// 
    /// The request identifier.
    /// 
    public string RequestId { get; set; }

    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }
    
    /// 
    /// The response mode.
    /// 
    public string ResponseMode { get; set; }

    /// 
    /// The client id making the request (if available).
    /// 
    public string ClientId { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/LogoutRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the validated singout context.
/// 
public class LogoutMessage
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public LogoutMessage()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    public LogoutMessage(ValidatedEndSessionRequest request)
    {
        if (request != null)
        {
            if (request.Raw != null)
            {
                Parameters = request.Raw.ToFullDictionary();
            }

            // optimize params sent to logout page, since we'd like to send them in URL (not as cookie)
            Parameters.Remove(OidcConstants.EndSessionRequest.IdTokenHint);
            Parameters.Remove(OidcConstants.EndSessionRequest.PostLogoutRedirectUri);
            Parameters.Remove(OidcConstants.EndSessionRequest.State);

            ClientId = request.Client?.ClientId;
            ClientName = request.Client?.ClientName;
            SubjectId = request.Subject?.GetSubjectId();
            SessionId = request.SessionId;
            ClientIds = request.ClientIds;

            if (request.PostLogOutUri != null)
            {
                PostLogoutRedirectUri = request.PostLogOutUri;
                if (request.State != null)
                {
                    PostLogoutRedirectUri = PostLogoutRedirectUri.AddQueryString(OidcConstants.EndSessionRequest.State, request.State);
                }
            }
        }
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the client name.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the post logout redirect URI.
    /// 
    public string PostLogoutRedirectUri { get; set; }

    /// 
    /// Gets or sets the subject identifier for the user at logout time.
    /// 
    public string SubjectId { get; set; }
    
    /// 
    /// Gets or sets the session identifier for the user at logout time.
    /// 
    public string SessionId { get; set; }

    /// 
    ///  Ids of clients known to have an authentication session for user at end session time
    /// 
    public IEnumerable ClientIds { get; set; }

    /// 
    /// Gets the entire parameter collection.
    /// 
    public IDictionary Parameters { get; set; } = new Dictionary();

    /// 
    ///  Flag to indicate if the payload contains useful information or not to avoid serailization.
    /// 
    internal bool ContainsPayload => ClientId.IsPresent() || ClientIds?.Any() == true;
}

/// 
/// Models the request from a client to sign the user out.
/// 
public class LogoutRequest
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The iframe URL.
    /// The message.
    public LogoutRequest(string iframeUrl, LogoutMessage message)
    {
        if (message != null)
        {
            ClientId = message.ClientId;
            ClientName = message.ClientName;
            PostLogoutRedirectUri = message.PostLogoutRedirectUri;
            SubjectId = message.SubjectId;
            SessionId = message.SessionId;
            ClientIds = message.ClientIds;
            Parameters = message.Parameters.FromFullDictionary();
        }

        SignOutIFrameUrl = iframeUrl;
    }

    /// 
    /// Gets or sets the client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the client name.
    /// 
    public string ClientName { get; set; }

    /// 
    /// Gets or sets the post logout redirect URI.
    /// 
    public string PostLogoutRedirectUri { get; set; }

    /// 
    /// Gets or sets the subject identifier for the user at logout time.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the session identifier for the user at logout time.
    /// 
    public string SessionId { get; set; }

    /// 
    ///  Ids of clients known to have an authentication session for user at end session time
    /// 
    public IEnumerable ClientIds { get; set; }

    /// 
    /// Gets the entire parameter collection.
    /// 
    public NameValueCollection Parameters { get; } = new NameValueCollection();

    /// 
    /// Gets or sets the sign out iframe URL.
    /// 
    /// 
    /// The sign out iframe URL.
    /// 
    public string SignOutIFrameUrl { get; set; }

    /// 
    /// Gets or sets a value indicating whether the user should be prompted for signout.
    /// 
    /// 
    ///   true if the signout prompt should be shown; otherwise, false.
    /// 
    public bool ShowSignoutPrompt => ClientId.IsMissing();
}


================================================
FILE: src/IdentityServer8/src/Models/Messages/Message.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Base class for data that needs to be written out as cookies.
/// 
public class Message
{
    /// 
    /// Should only be used from unit tests
    /// 
    /// 
    internal Message(TModel data) : this(data, DateTime.UtcNow)
    {
    }

    /// 
    /// For JSON serializer. 
    /// System.Text.Json.JsonSerializer requires public, parameterless constructor
    /// 
    public Message()
    {
    }
    
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The data.
    /// The current UTC date/time.
    public Message(TModel data, DateTime now)
    {
        Created = now.Ticks;
        Data = data;
    }

    /// 
    /// Gets or sets the UTC ticks the  was created.
    /// 
    /// 
    /// The created UTC ticks.
    /// 
    public long Created { get; set; }

    /// 
    /// Gets or sets the data.
    /// 
    /// 
    /// The data.
    /// 
    public TModel Data { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/ParsedSecret.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Represents a secret extracted from the HttpContext
/// 
public class ParsedSecret
{
    /// 
    /// Gets or sets the identifier associated with this secret
    /// 
    /// 
    /// The identifier.
    /// 
    public string Id { get; set; }

    /// 
    /// Gets or sets the credential to verify the secret
    /// 
    /// 
    /// The credential.
    /// 
    public object Credential { get; set; }

    /// 
    /// Gets or sets the type of the secret
    /// 
    /// 
    /// The type.
    /// 
    public string Type { get; set; }

    /// 
    /// Gets or sets additional properties.
    /// 
    /// 
    /// The properties.
    /// 
    public Dictionary Properties { get; set; } = new Dictionary();
}


================================================
FILE: src/IdentityServer8/src/Models/SecurityKeyInfo.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Models;

/// 
/// Information about a security key
/// 
public class SecurityKeyInfo
{
    /// 
    /// The key
    /// 
    public SecurityKey Key { get; set; }

    /// 
    /// The signing algorithm
    /// 
    public string SigningAlgorithm { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Models/TokenCreationRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the data to create a token from a validated request.
/// 
public class TokenCreationRequest
{
    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets the validated resources.
    /// 
    /// 
    /// The resources.
    /// 
    public ResourceValidationResult ValidatedResources { get; set; }

    /// 
    /// Gets or sets the validated request.
    /// 
    /// 
    /// The validated request.
    /// 
    public ValidatedRequest ValidatedRequest { get; set; }

    /// 
    /// Gets or sets a value indicating whether [include all identity claims].
    /// 
    /// 
    /// true if [include all identity claims]; otherwise, false.
    /// 
    public bool IncludeAllIdentityClaims { get; set; }

    /// 
    /// Gets or sets the access token to hash.
    /// 
    /// 
    /// The access token to hash.
    /// 
    public string AccessTokenToHash { get; set; }

    /// 
    /// Gets or sets the authorization code to hash.
    /// 
    /// 
    /// The authorization code to hash.
    /// 
    public string AuthorizationCodeToHash { get; set; }

    /// 
    /// Gets or sets pre-hashed state
    /// 
    /// 
    /// The pre-hashed state
    /// 
    public string StateHash { get; set; }

    /// 
    /// Gets or sets the nonce.
    /// 
    /// 
    /// The nonce.
    /// 
    public string Nonce { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Called to validate the  before it is processed.
    /// 
    public void Validate()
    {
        if (ValidatedResources == null) throw new ArgumentNullException(nameof(ValidatedResources));
        if (ValidatedRequest == null) throw new ArgumentNullException(nameof(ValidatedRequest));
    }
}


================================================
FILE: src/IdentityServer8/src/Models/TokenRequestErrors.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Token request errors
/// 
public enum TokenRequestErrors
{
    /// 
    /// invalid_request
    /// 
    InvalidRequest,

    /// 
    /// invalid_client
    /// 
    InvalidClient,

    /// 
    /// invalid_grant
    /// 
    InvalidGrant,

    /// 
    /// unauthorized_client
    /// 
    UnauthorizedClient,

    /// 
    /// unsupported_grant_type
    /// 
    UnsupportedGrantType,

    /// 
    /// invalid_scope
    /// 
    InvalidScope,

    /// 
    /// invalid_target
    /// 
    InvalidTarget
}


================================================
FILE: src/IdentityServer8/src/Properties/AssemblyInfo.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

[assembly: InternalsVisibleTo("IdentityServer.UnitTests, PublicKey = 002400000480000094000000060200000024000052534131000400000100010057b24455efc2a317afb0644a2169c05644e439985c42cf4eb98706779651801add1da073da8b5e253e8d4335d59b3197bb941ebe943c63f7efbc3005c428f0d69b809e86bdc828fa431fae4b71005f26b52a26a3ee5cf0f6fdf744d4534a7a503683123f58e1082828b018245d2e40d8542f72a623c01490d73a5d3ff94a88c5")]
[assembly: InternalsVisibleTo("IdentityServer.IntegrationTests, PublicKey = 002400000480000094000000060200000024000052534131000400000100010057b24455efc2a317afb0644a2169c05644e439985c42cf4eb98706779651801add1da073da8b5e253e8d4335d59b3197bb941ebe943c63f7efbc3005c428f0d69b809e86bdc828fa431fae4b71005f26b52a26a3ee5cf0f6fdf744d4534a7a503683123f58e1082828b018245d2e40d8542f72a623c01490d73a5d3ff94a88c5")]


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/AuthorizeInteractionResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Default logic for determining if user must login or consent when making requests to the authorization endpoint.
/// 
/// 
public class AuthorizeInteractionResponseGenerator : IAuthorizeInteractionResponseGenerator
{
    /// 
    /// The logger.
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The consent service.
    /// 
    protected readonly IConsentService Consent;

    /// 
    /// The profile service.
    /// 
    protected readonly IProfileService Profile;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clock.
    /// The logger.
    /// The consent.
    /// The profile.
    public AuthorizeInteractionResponseGenerator(
        ISystemClock clock,
        ILogger logger,
        IConsentService consent, 
        IProfileService profile)
    {
        Clock = clock;
        Logger = logger;
        Consent = consent;
        Profile = profile;
    }

    /// 
    /// Processes the interaction logic.
    /// 
    /// The request.
    /// The consent.
    /// 
    public virtual async Task ProcessInteractionAsync(ValidatedAuthorizeRequest request, ConsentResponse consent = null)
    {
        Logger.LogTrace("ProcessInteractionAsync");

        if (consent != null && consent.Granted == false && consent.Error.HasValue && request.Subject.IsAuthenticated() == false)
        {
            // special case when anonymous user has issued an error prior to authenticating
            Logger.LogInformation("Error: User consent result: {error}", consent.Error);

            var error = consent.Error switch
            {
                AuthorizationError.AccountSelectionRequired => OidcConstants.AuthorizeErrors.AccountSelectionRequired,
                AuthorizationError.ConsentRequired => OidcConstants.AuthorizeErrors.ConsentRequired,
                AuthorizationError.InteractionRequired => OidcConstants.AuthorizeErrors.InteractionRequired,
                AuthorizationError.LoginRequired => OidcConstants.AuthorizeErrors.LoginRequired,
                _ => OidcConstants.AuthorizeErrors.AccessDenied
            };
            
            return new InteractionResponse
            {
                Error = error,
                ErrorDescription = consent.ErrorDescription
            };
        }

        var result = await ProcessLoginAsync(request);
        
        if (!result.IsLogin && !result.IsError && !result.IsRedirect)
        {
            result = await ProcessConsentAsync(request, consent);
        }

        if ((result.IsLogin || result.IsConsent || result.IsRedirect) && request.PromptModes.Contains(OidcConstants.PromptModes.None))
        {
            // prompt=none means do not show the UI
            Logger.LogInformation("Changing response to LoginRequired: prompt=none was requested");
            result = new InteractionResponse
            {
                Error = result.IsLogin ? OidcConstants.AuthorizeErrors.LoginRequired :
                            result.IsConsent ? OidcConstants.AuthorizeErrors.ConsentRequired : 
                                OidcConstants.AuthorizeErrors.InteractionRequired
            };
        }

        return result;
    }

    /// 
    /// Processes the login logic.
    /// 
    /// The request.
    /// 
    protected internal virtual async Task ProcessLoginAsync(ValidatedAuthorizeRequest request)
    {
        if (request.PromptModes.Contains(OidcConstants.PromptModes.Login) ||
            request.PromptModes.Contains(OidcConstants.PromptModes.SelectAccount))
        {
            Logger.LogInformation("Showing login: request contains prompt={0}", request.PromptModes.ToSpaceSeparatedString());

            // remove prompt so when we redirect back in from login page
            // we won't think we need to force a prompt again
            request.RemovePrompt();
            
            return new InteractionResponse { IsLogin = true };
        }

        // unauthenticated user
        var isAuthenticated = request.Subject.IsAuthenticated();
        
        // user de-activated
        bool isActive = false;

        if (isAuthenticated)
        {
            var isActiveCtx = new IsActiveContext(request.Subject, request.Client, IdentityServerConstants.ProfileIsActiveCallers.AuthorizeEndpoint);
            await Profile.IsActiveAsync(isActiveCtx);
            
            isActive = isActiveCtx.IsActive;
        }

        if (!isAuthenticated || !isActive)
        {
            if (!isAuthenticated)
            {
                Logger.LogInformation("Showing login: User is not authenticated");
            }
            else if (!isActive)
            {
                Logger.LogInformation("Showing login: User is not active");
            }

            return new InteractionResponse { IsLogin = true };
        }

        // check current idp
        var currentIdp = request.Subject.GetIdentityProvider();

        // check if idp login hint matches current provider
        var idp = request.GetIdP();
        if (idp.IsPresent())
        {
            if (idp != currentIdp)
            {
                Logger.LogInformation("Showing login: Current IdP ({currentIdp}) is not the requested IdP ({idp})", currentIdp, idp);
                return new InteractionResponse { IsLogin = true };
            }
        }

        // check authentication freshness
        if (request.MaxAge.HasValue)
        {
            var authTime = request.Subject.GetAuthenticationTime();
            if (Clock.UtcNow > authTime.AddSeconds(request.MaxAge.Value))
            {
                Logger.LogInformation("Showing login: Requested MaxAge exceeded.");

                return new InteractionResponse { IsLogin = true };
            }
        }

        // check local idp restrictions
        if (currentIdp == IdentityServerConstants.LocalIdentityProvider)
        {
            if (!request.Client.EnableLocalLogin)
            {
                Logger.LogInformation("Showing login: User logged in locally, but client does not allow local logins");
                return new InteractionResponse { IsLogin = true };
            }
        }
        // check external idp restrictions if user not using local idp
        else if (request.Client.IdentityProviderRestrictions != null && 
            request.Client.IdentityProviderRestrictions.Any() &&
            !request.Client.IdentityProviderRestrictions.Contains(currentIdp))
        {
            Logger.LogInformation("Showing login: User is logged in with idp: {idp}, but idp not in client restriction list.", currentIdp);
            return new InteractionResponse { IsLogin = true };
        }

        // check client's user SSO timeout
        if (request.Client.UserSsoLifetime.HasValue)
        {
            var authTimeEpoch = request.Subject.GetAuthenticationTimeEpoch();
            var nowEpoch = Clock.UtcNow.ToUnixTimeSeconds();

            var diff = nowEpoch - authTimeEpoch;
            if (diff > request.Client.UserSsoLifetime.Value)
            {
                Logger.LogInformation("Showing login: User's auth session duration: {sessionDuration} exceeds client's user SSO lifetime: {userSsoLifetime}.", diff, request.Client.UserSsoLifetime);
                return new InteractionResponse { IsLogin = true };
            }
        }

        return new InteractionResponse();
    }

    /// 
    /// Processes the consent logic.
    /// 
    /// The request.
    /// The consent.
    /// 
    /// 
    /// Invalid PromptMode
    protected internal virtual async Task ProcessConsentAsync(ValidatedAuthorizeRequest request, ConsentResponse consent = null)
    {
        if (request == null) throw new ArgumentNullException(nameof(request));

        if (request.PromptModes.Any() &&
            !request.PromptModes.Contains(OidcConstants.PromptModes.None) &&
            !request.PromptModes.Contains(OidcConstants.PromptModes.Consent))
        {
            Logger.LogError("Invalid prompt mode: {promptMode}", request.PromptModes.ToSpaceSeparatedString());
            throw new ArgumentException("Invalid PromptMode");
        }

        var consentRequired = await Consent.RequiresConsentAsync(request.Subject, request.Client, request.ValidatedResources.ParsedScopes);

        if (consentRequired && request.PromptModes.Contains(OidcConstants.PromptModes.None))
        {
            Logger.LogInformation("Error: prompt=none requested, but consent is required.");

            return new InteractionResponse
            {
                Error = OidcConstants.AuthorizeErrors.ConsentRequired
            };
        }

        if (request.PromptModes.Contains(OidcConstants.PromptModes.Consent) || consentRequired)
        {
            var response = new InteractionResponse();

            // did user provide consent
            if (consent == null)
            {
                // user was not yet shown conset screen
                response.IsConsent = true;
                Logger.LogInformation("Showing consent: User has not yet consented");
            }
            else
            {
                request.WasConsentShown = true;
                Logger.LogTrace("Consent was shown to user");

                // user was shown consent -- did they say yes or no
                if (consent.Granted == false)
                {
                    // no need to show consent screen again
                    // build error to return to client
                    Logger.LogInformation("Error: User consent result: {error}", consent.Error);

                    var error = consent.Error switch
                    {
                        AuthorizationError.AccountSelectionRequired => OidcConstants.AuthorizeErrors.AccountSelectionRequired,
                        AuthorizationError.ConsentRequired => OidcConstants.AuthorizeErrors.ConsentRequired,
                        AuthorizationError.InteractionRequired => OidcConstants.AuthorizeErrors.InteractionRequired,
                        AuthorizationError.LoginRequired => OidcConstants.AuthorizeErrors.LoginRequired,
                        _ => OidcConstants.AuthorizeErrors.AccessDenied
                    };
                    
                    response.Error = error;
                    response.ErrorDescription = consent.ErrorDescription;
                }
                else
                {
                    // double check that required scopes are in the list of consented scopes
                    var requiredScopes = request.ValidatedResources.GetRequiredScopeValues();
                    var valid = requiredScopes.All(x => consent.ScopesValuesConsented.Contains(x));
                    if (valid == false)
                    {
                        response.Error = OidcConstants.AuthorizeErrors.AccessDenied;
                        Logger.LogInformation("Error: User denied consent to required scopes");
                    }
                    else
                    {
                        // they said yes, set scopes they chose
                        request.Description = consent.Description;
                        request.ValidatedResources = request.ValidatedResources.Filter(consent.ScopesValuesConsented);
                        Logger.LogInformation("User consented to scopes: {scopes}", consent.ScopesValuesConsented);

                        if (request.Client.AllowRememberConsent)
                        {
                            // remember consent
                            var parsedScopes = Enumerable.Empty();
                            if (consent.RememberConsent)
                            {
                                // remember what user actually selected
                                parsedScopes = request.ValidatedResources.ParsedScopes;
                                Logger.LogDebug("User indicated to remember consent for scopes: {scopes}", request.ValidatedResources.RawScopeValues);
                            }

                            await Consent.UpdateConsentAsync(request.Subject, request.Client, parsedScopes);
                        }
                    }
                }
            }

            return response;
        }

        return new InteractionResponse();
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/AuthorizeResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// The authorize response generator
/// 
/// 
public class AuthorizeResponseGenerator : IAuthorizeResponseGenerator
{
    /// 
    /// The token service
    /// 
    protected readonly ITokenService TokenService;

    /// 
    /// The authorization code store
    /// 
    protected readonly IAuthorizationCodeStore AuthorizationCodeStore;

    /// 
    /// The event service
    /// 
    protected readonly IEventService Events;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The key material service
    /// 
    protected readonly IKeyMaterialService KeyMaterialService;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clock.
    /// The logger.
    /// The token service.
    /// 
    /// The authorization code store.
    /// The events.
    public AuthorizeResponseGenerator(
        ISystemClock clock,
        ITokenService tokenService,
        IKeyMaterialService keyMaterialService,
        IAuthorizationCodeStore authorizationCodeStore,
        ILogger logger,
        IEventService events)
    {
        Clock = clock;
        TokenService = tokenService;
        KeyMaterialService = keyMaterialService;
        AuthorizationCodeStore = authorizationCodeStore;
        Events = events;
        Logger = logger;
    }

    /// 
    /// Creates the response
    /// 
    /// The request.
    /// 
    /// invalid grant type: " + request.GrantType
    public virtual async Task CreateResponseAsync(ValidatedAuthorizeRequest request)
    {
        if (request.GrantType == GrantType.AuthorizationCode)
        {
            return await CreateCodeFlowResponseAsync(request);
        }
        if (request.GrantType == GrantType.Implicit)
        {
            return await CreateImplicitFlowResponseAsync(request);
        }
        if (request.GrantType == GrantType.Hybrid)
        {
            return await CreateHybridFlowResponseAsync(request);
        }

        Logger.LogError("Unsupported grant type: " + request.GrantType);
        throw new InvalidOperationException("invalid grant type: " + request.GrantType);
    }

    /// 
    /// Creates the response for a hybrid flow request
    /// 
    /// 
    /// 
    protected virtual async Task CreateHybridFlowResponseAsync(ValidatedAuthorizeRequest request)
    {
        Logger.LogDebug("Creating Hybrid Flow response.");

        var code = await CreateCodeAsync(request);
        var id = await AuthorizationCodeStore.StoreAuthorizationCodeAsync(code);

        var response = await CreateImplicitFlowResponseAsync(request, id);
        response.Code = id;

        return response;
    }

    /// 
    /// Creates the response for a code flow request
    /// 
    /// 
    /// 
    protected virtual async Task CreateCodeFlowResponseAsync(ValidatedAuthorizeRequest request)
    {
        Logger.LogDebug("Creating Authorization Code Flow response.");

        var code = await CreateCodeAsync(request);
        var id = await AuthorizationCodeStore.StoreAuthorizationCodeAsync(code);

        var response = new AuthorizeResponse
        {
            Request = request,
            Code = id,
            SessionState = request.GenerateSessionStateValue()
        };

        return response;
    }

    /// 
    /// Creates the response for a implicit flow request
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task CreateImplicitFlowResponseAsync(ValidatedAuthorizeRequest request, string authorizationCode = null)
    {
        Logger.LogDebug("Creating Implicit Flow response.");

        string accessTokenValue = null;
        int accessTokenLifetime = 0;

        var responseTypes = request.ResponseType.FromSpaceSeparatedString();

        if (responseTypes.Contains(OidcConstants.ResponseTypes.Token))
        {
            var tokenRequest = new TokenCreationRequest
            {
                Subject = request.Subject,
                ValidatedResources = request.ValidatedResources,

                ValidatedRequest = request
            };

            var accessToken = await TokenService.CreateAccessTokenAsync(tokenRequest);
            accessTokenLifetime = accessToken.Lifetime;

            accessTokenValue = await TokenService.CreateSecurityTokenAsync(accessToken);
        }

        string jwt = null;
        if (responseTypes.Contains(OidcConstants.ResponseTypes.IdToken))
        {
            string stateHash = null;
            if (request.State.IsPresent())
            {
                var credential = await KeyMaterialService.GetSigningCredentialsAsync(request.Client.AllowedIdentityTokenSigningAlgorithms);
                if (credential == null)
                {
                    throw new InvalidOperationException("No signing credential is configured.");
                }

                var algorithm = credential.Algorithm;
                stateHash = CryptoHelper.CreateHashClaimValue(request.State, algorithm);
            }

            var tokenRequest = new TokenCreationRequest
            {
                ValidatedRequest = request,
                Subject = request.Subject,
                ValidatedResources = request.ValidatedResources,
                Nonce = request.Raw.Get(OidcConstants.AuthorizeRequest.Nonce),
                IncludeAllIdentityClaims = !request.AccessTokenRequested,
                AccessTokenToHash = accessTokenValue,
                AuthorizationCodeToHash = authorizationCode,
                StateHash = stateHash
            };

            var idToken = await TokenService.CreateIdentityTokenAsync(tokenRequest);
            jwt = await TokenService.CreateSecurityTokenAsync(idToken);
        }

        var response = new AuthorizeResponse
        {
            Request = request,
            AccessToken = accessTokenValue,
            AccessTokenLifetime = accessTokenLifetime,
            IdentityToken = jwt,
            SessionState = request.GenerateSessionStateValue()
        };

        return response;
    }

    /// 
    /// Creates an authorization code
    /// 
    /// 
    /// 
    protected virtual async Task CreateCodeAsync(ValidatedAuthorizeRequest request)
    {
        string stateHash = null;
        if (request.State.IsPresent())
        {
            var credential = await KeyMaterialService.GetSigningCredentialsAsync(request.Client.AllowedIdentityTokenSigningAlgorithms);
            if (credential == null)
            {
                throw new InvalidOperationException("No signing credential is configured.");
            }

            var algorithm = credential.Algorithm;
            stateHash = CryptoHelper.CreateHashClaimValue(request.State, algorithm);
        }

        var code = new AuthorizationCode
        {
            CreationTime = Clock.UtcNow.UtcDateTime,
            ClientId = request.Client.ClientId,
            Lifetime = request.Client.AuthorizationCodeLifetime,
            Subject = request.Subject,
            SessionId = request.SessionId,
            Description = request.Description,
            CodeChallenge = request.CodeChallenge.Sha256(),
            CodeChallengeMethod = request.CodeChallengeMethod,

            IsOpenId = request.IsOpenIdRequest,
            RequestedScopes = request.ValidatedResources.RawScopeValues,
            RedirectUri = request.RedirectUri,
            Nonce = request.Nonce,
            StateHash = stateHash,

            WasConsentShown = request.WasConsentShown
        };

        return code;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/DeviceAuthorizationResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// The device authorizaiton response generator
/// 
/// 
public class DeviceAuthorizationResponseGenerator : IDeviceAuthorizationResponseGenerator
{
    /// 
    /// The options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// The user code service
    /// 
    protected readonly IUserCodeService UserCodeService;

    /// 
    /// The device flow code service
    /// 
    protected readonly IDeviceFlowCodeService DeviceFlowCodeService;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The user code service.
    /// The device flow code service.
    /// The clock.
    /// The logger.
    public DeviceAuthorizationResponseGenerator(IdentityServerOptions options, IUserCodeService userCodeService, IDeviceFlowCodeService deviceFlowCodeService, ISystemClock clock, ILogger logger)
    {
        Options = options;
        UserCodeService = userCodeService;
        DeviceFlowCodeService = deviceFlowCodeService;
        Clock = clock;
        Logger = logger;
    }

    /// 
    /// Processes the response.
    /// 
    /// The validation result.
    /// The base URL.
    /// 
    /// validationResult or Client
    /// Value cannot be null or whitespace. - baseUrl
    public virtual async Task ProcessAsync(DeviceAuthorizationRequestValidationResult validationResult, string baseUrl)
    {
        if (validationResult == null) throw new ArgumentNullException(nameof(validationResult));
        if (validationResult.ValidatedRequest.Client == null) throw new ArgumentNullException(nameof(validationResult.ValidatedRequest.Client));
        if (string.IsNullOrWhiteSpace(baseUrl)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(baseUrl));

        Logger.LogTrace("Creating response for device authorization request");

        var response = new DeviceAuthorizationResponse();
        
        // generate user_code
        var userCodeGenerator = await UserCodeService.GetGenerator(
            validationResult.ValidatedRequest.Client.UserCodeType ??
            Options.DeviceFlow.DefaultUserCodeType);
        
        var retryCount = 0;

        while (retryCount < userCodeGenerator.RetryLimit)
        {
            var userCode = await userCodeGenerator.GenerateAsync();
            
            var deviceCode = await DeviceFlowCodeService.FindByUserCodeAsync(userCode);
            if (deviceCode == null)
            {
                response.UserCode = userCode;
                break;
            }

            retryCount++;
        }

        if (response.UserCode == null)
        {
            throw new InvalidOperationException("Unable to create unique device flow user code");
        }

        // generate verification URIs
        response.VerificationUri = Options.UserInteraction.DeviceVerificationUrl;
        if (response.VerificationUri.IsLocalUrl())
        {
            // if url is relative, parse absolute URL
            response.VerificationUri = baseUrl.RemoveTrailingSlash() + Options.UserInteraction.DeviceVerificationUrl;
        }
        
        if (!string.IsNullOrWhiteSpace(Options.UserInteraction.DeviceVerificationUserCodeParameter))
        {
            response.VerificationUriComplete =
                $"{response.VerificationUri}?{Options.UserInteraction.DeviceVerificationUserCodeParameter}={response.UserCode}";
        }

        // expiration
        response.DeviceCodeLifetime = validationResult.ValidatedRequest.Client.DeviceCodeLifetime;

        // interval
        response.Interval = Options.DeviceFlow.Interval;

        // store device request (device code & user code)
        response.DeviceCode = await DeviceFlowCodeService.StoreDeviceAuthorizationAsync(response.UserCode, new DeviceCode
        {
            Description = validationResult.ValidatedRequest.Description,
            ClientId = validationResult.ValidatedRequest.Client.ClientId,
            IsOpenId = validationResult.ValidatedRequest.IsOpenIdRequest,
            Lifetime = response.DeviceCodeLifetime,
            CreationTime = Clock.UtcNow.UtcDateTime,
            RequestedScopes = validationResult.ValidatedRequest.ValidatedResources.RawScopeValues
        });

        return response;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/DiscoveryResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;
using JsonWebKey = Microsoft.IdentityModel.Tokens.JsonWebKey;

namespace IdentityServer8.ResponseHandling;

/// 
/// Default implementation of the discovery endpoint response generator
/// 
/// 
public class DiscoveryResponseGenerator : IDiscoveryResponseGenerator
{
    /// 
    /// The options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// The extension grants validator
    /// 
    protected readonly ExtensionGrantValidator ExtensionGrants;

    /// 
    /// The key material service
    /// 
    protected readonly IKeyMaterialService Keys;

    /// 
    /// The resource owner validator
    /// 
    protected readonly IResourceOwnerPasswordValidator ResourceOwnerValidator;

    /// 
    /// The resource store
    /// 
    protected readonly IResourceStore ResourceStore;

    /// 
    /// The secret parsers
    /// 
    protected readonly ISecretsListParser SecretParsers;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The resource store.
    /// The keys.
    /// The extension grants.
    /// The secret parsers.
    /// The resource owner validator.
    /// The logger.
    public DiscoveryResponseGenerator(
        IdentityServerOptions options,
        IResourceStore resourceStore,
        IKeyMaterialService keys,
        ExtensionGrantValidator extensionGrants,
        ISecretsListParser secretParsers,
        IResourceOwnerPasswordValidator resourceOwnerValidator,
        ILogger logger)
    {
        Options = options;
        ResourceStore = resourceStore;
        Keys = keys;
        ExtensionGrants = extensionGrants;
        SecretParsers = secretParsers;
        ResourceOwnerValidator = resourceOwnerValidator;
        Logger = logger;
    }

    /// 
    /// Creates the discovery document.
    /// 
    /// The base URL.
    /// The issuer URI.
    public virtual async Task> CreateDiscoveryDocumentAsync(string baseUrl, string issuerUri)
    {
        var entries = new Dictionary
        {
            { OidcConstants.Discovery.Issuer, issuerUri }
        };

        // jwks
        if (Options.Discovery.ShowKeySet)
        {
            if ((await Keys.GetValidationKeysAsync()).Any())
            {
                entries.Add(OidcConstants.Discovery.JwksUri, baseUrl + Constants.ProtocolRoutePaths.DiscoveryWebKeys);
            }
        }

        // endpoints
        if (Options.Discovery.ShowEndpoints)
        {
            if (Options.Endpoints.EnableAuthorizeEndpoint)
            {
                entries.Add(OidcConstants.Discovery.AuthorizationEndpoint, baseUrl + Constants.ProtocolRoutePaths.Authorize);
            }

            if (Options.Endpoints.EnableTokenEndpoint)
            {
                entries.Add(OidcConstants.Discovery.TokenEndpoint, baseUrl + Constants.ProtocolRoutePaths.Token);
            }

            if (Options.Endpoints.EnableUserInfoEndpoint)
            {
                entries.Add(OidcConstants.Discovery.UserInfoEndpoint, baseUrl + Constants.ProtocolRoutePaths.UserInfo);
            }

            if (Options.Endpoints.EnableEndSessionEndpoint)
            {
                entries.Add(OidcConstants.Discovery.EndSessionEndpoint, baseUrl + Constants.ProtocolRoutePaths.EndSession);
            }

            if (Options.Endpoints.EnableCheckSessionEndpoint)
            {
                entries.Add(OidcConstants.Discovery.CheckSessionIframe, baseUrl + Constants.ProtocolRoutePaths.CheckSession);
            }

            if (Options.Endpoints.EnableTokenRevocationEndpoint)
            {
                entries.Add(OidcConstants.Discovery.RevocationEndpoint, baseUrl + Constants.ProtocolRoutePaths.Revocation);
            }

            if (Options.Endpoints.EnableIntrospectionEndpoint)
            {
                entries.Add(OidcConstants.Discovery.IntrospectionEndpoint, baseUrl + Constants.ProtocolRoutePaths.Introspection);
            }

            if (Options.Endpoints.EnableDeviceAuthorizationEndpoint)
            {
                entries.Add(OidcConstants.Discovery.DeviceAuthorizationEndpoint, baseUrl + Constants.ProtocolRoutePaths.DeviceAuthorization);
            }

            if (Options.MutualTls.Enabled)
            {
                var mtlsEndpoints = new Dictionary();

                if (Options.Endpoints.EnableTokenEndpoint)
                {
                    mtlsEndpoints.Add(OidcConstants.Discovery.TokenEndpoint, ConstructMtlsEndpoint(Constants.ProtocolRoutePaths.Token));
                }
                if (Options.Endpoints.EnableTokenRevocationEndpoint)
                {
                    mtlsEndpoints.Add(OidcConstants.Discovery.RevocationEndpoint, ConstructMtlsEndpoint(Constants.ProtocolRoutePaths.Revocation));
                }
                if (Options.Endpoints.EnableIntrospectionEndpoint)
                {
                    mtlsEndpoints.Add(OidcConstants.Discovery.IntrospectionEndpoint, ConstructMtlsEndpoint(Constants.ProtocolRoutePaths.Introspection));
                }
                if (Options.Endpoints.EnableDeviceAuthorizationEndpoint)
                {
                    mtlsEndpoints.Add(OidcConstants.Discovery.DeviceAuthorizationEndpoint, ConstructMtlsEndpoint(Constants.ProtocolRoutePaths.DeviceAuthorization));
                }

                if (mtlsEndpoints.Any())
                {
                    entries.Add(OidcConstants.Discovery.MtlsEndpointAliases, mtlsEndpoints);
                }

                string ConstructMtlsEndpoint(string endpoint)
                {
                    // path based
                    if (Options.MutualTls.DomainName.IsMissing())
                    {
                        return baseUrl + endpoint.Replace(Constants.ProtocolRoutePaths.ConnectPathPrefix, Constants.ProtocolRoutePaths.MtlsPathPrefix);
                    }

                    // domain based
                    if (Options.MutualTls.DomainName.Contains("."))
                    {
                        return $"https://{Options.MutualTls.DomainName}/{endpoint}";
                    }
                    // sub-domain based
                    else
                    {
                        var parts = baseUrl.Split("://");
                        return $"https://{Options.MutualTls.DomainName}.{parts[1]}{endpoint}";
                    }
                }
            }
        }

        // logout
        if (Options.Endpoints.EnableEndSessionEndpoint)
        {
            entries.Add(OidcConstants.Discovery.FrontChannelLogoutSupported, true);
            entries.Add(OidcConstants.Discovery.FrontChannelLogoutSessionSupported, true);
            entries.Add(OidcConstants.Discovery.BackChannelLogoutSupported, true);
            entries.Add(OidcConstants.Discovery.BackChannelLogoutSessionSupported, true);
        }

        // scopes and claims
        if (Options.Discovery.ShowIdentityScopes ||
            Options.Discovery.ShowApiScopes ||
            Options.Discovery.ShowClaims)
        {
            var resources = await ResourceStore.GetAllEnabledResourcesAsync();
            var scopes = new List();

            // scopes
            if (Options.Discovery.ShowIdentityScopes)
            {
                scopes.AddRange(resources.IdentityResources.Where(x => x.ShowInDiscoveryDocument).Select(x => x.Name));
            }

            if (Options.Discovery.ShowApiScopes)
            {
                var apiScopes = from scope in resources.ApiScopes
                                where scope.ShowInDiscoveryDocument
                                select scope.Name;

                scopes.AddRange(apiScopes);
                scopes.Add(IdentityServerConstants.StandardScopes.OfflineAccess);
            }

            if (scopes.Any())
            {
                entries.Add(OidcConstants.Discovery.ScopesSupported, scopes.ToArray());
            }

            // claims
            if (Options.Discovery.ShowClaims)
            {
                var claims = new List();

                // add non-hidden identity scopes related claims
                claims.AddRange(resources.IdentityResources.Where(x => x.ShowInDiscoveryDocument).SelectMany(x => x.UserClaims));
                claims.AddRange(resources.ApiResources.Where(x => x.ShowInDiscoveryDocument).SelectMany(x => x.UserClaims));
                claims.AddRange(resources.ApiScopes.Where(x => x.ShowInDiscoveryDocument).SelectMany(x => x.UserClaims));

                entries.Add(OidcConstants.Discovery.ClaimsSupported, claims.Distinct().ToArray());
            }
        }

        // grant types
        if (Options.Discovery.ShowGrantTypes)
        {
            var standardGrantTypes = new List
            {
                OidcConstants.GrantTypes.AuthorizationCode,
                OidcConstants.GrantTypes.ClientCredentials,
                OidcConstants.GrantTypes.RefreshToken,
                OidcConstants.GrantTypes.Implicit
            };

            if (!(ResourceOwnerValidator is NotSupportedResourceOwnerPasswordValidator))
            {
                standardGrantTypes.Add(OidcConstants.GrantTypes.Password);
            }

            if (Options.Endpoints.EnableDeviceAuthorizationEndpoint)
            {
                standardGrantTypes.Add(OidcConstants.GrantTypes.DeviceCode);
            }

            var showGrantTypes = new List(standardGrantTypes);

            if (Options.Discovery.ShowExtensionGrantTypes)
            {
                showGrantTypes.AddRange(ExtensionGrants.GetAvailableGrantTypes());
            }

            entries.Add(OidcConstants.Discovery.GrantTypesSupported, showGrantTypes.ToArray());
        }

        // response types
        if (Options.Discovery.ShowResponseTypes)
        {
            entries.Add(OidcConstants.Discovery.ResponseTypesSupported, Constants.SupportedResponseTypes.ToArray());
        }

        // response modes
        if (Options.Discovery.ShowResponseModes)
        {
            entries.Add(OidcConstants.Discovery.ResponseModesSupported, Constants.SupportedResponseModes.ToArray());
        }

        // misc
        if (Options.Discovery.ShowTokenEndpointAuthenticationMethods)
        {
            var types = SecretParsers.GetAvailableAuthenticationMethods().ToList();
            if (Options.MutualTls.Enabled)
            {
                types.Add(OidcConstants.EndpointAuthenticationMethods.TlsClientAuth);
                types.Add(OidcConstants.EndpointAuthenticationMethods.SelfSignedTlsClientAuth);
            }

            entries.Add(OidcConstants.Discovery.TokenEndpointAuthenticationMethodsSupported, types);
        }

        var signingCredentials = await Keys.GetAllSigningCredentialsAsync();
        if (signingCredentials.Any())
        {
            var signingAlgorithms = signingCredentials.Select(c => c.Algorithm).Distinct();
            entries.Add(OidcConstants.Discovery.IdTokenSigningAlgorithmsSupported, signingAlgorithms);
        }

        entries.Add(OidcConstants.Discovery.SubjectTypesSupported, new[] { "public" });
        entries.Add(OidcConstants.Discovery.CodeChallengeMethodsSupported, new[] { OidcConstants.CodeChallengeMethods.Plain, OidcConstants.CodeChallengeMethods.Sha256 });

        if (Options.Endpoints.EnableAuthorizeEndpoint)
        {
            entries.Add(OidcConstants.Discovery.RequestParameterSupported, true);

            if (Options.Endpoints.EnableJwtRequestUri)
            {
                entries.Add(OidcConstants.Discovery.RequestUriParameterSupported, true);
            }
        }

        if (Options.MutualTls.Enabled)
        {
            entries.Add(OidcConstants.Discovery.TlsClientCertificateBoundAccessTokens, true);
        }

        // custom entries
        if (!Options.Discovery.CustomEntries.EnumerableIsNullOrEmpty())
        {
            foreach ((string key, object value) in Options.Discovery.CustomEntries)
            {
                if (entries.ContainsKey(key))
                {
                    Logger.LogError("Discovery custom entry {key} cannot be added, because it already exists.", key);
                }
                else
                {
                    if (value is string customValueString)
                    {
                        if (customValueString.StartsWith("~/") && Options.Discovery.ExpandRelativePathsInCustomEntries)
                        {
                            entries.Add(key, baseUrl + customValueString.Substring(2));
                            continue;
                        }
                    }

                    entries.Add(key, value);
                }
            }
        }

        return entries;
    }

    /// 
    /// Creates the JWK document.
    /// 
    public virtual async Task> CreateJwkDocumentAsync()
    {
        var webKeys = new List();

        foreach (var key in await Keys.GetValidationKeysAsync())
        {
            if (key.Key is X509SecurityKey x509Key)
            {
                var cert64 = Convert.ToBase64String(x509Key.Certificate.RawData);
                var thumbprint = Base64Url.Encode(x509Key.Certificate.GetCertHash());

                if (x509Key.PublicKey is RSA rsa)
                {
                    var parameters = rsa.ExportParameters(false);
                    var exponent = Base64Url.Encode(parameters.Exponent);
                    var modulus = Base64Url.Encode(parameters.Modulus);

                    var rsaJsonWebKey = new Models.JsonWebKey
                    {
                        kty = "RSA",
                        use = "sig",
                        kid = x509Key.KeyId,
                        x5t = thumbprint,
                        e = exponent,
                        n = modulus,
                        x5c = new[] { cert64 },
                        alg = key.SigningAlgorithm
                    };
                    webKeys.Add(rsaJsonWebKey);
                }
                else if (x509Key.PublicKey is ECDsa ecdsa)
                {
                    var parameters = ecdsa.ExportParameters(false);
                    var x = Base64Url.Encode(parameters.Q.X);
                    var y = Base64Url.Encode(parameters.Q.Y);

                    var ecdsaJsonWebKey = new Models.JsonWebKey
                    {
                        kty = "EC",
                        use = "sig",
                        kid = x509Key.KeyId,
                        x5t = thumbprint,
                        x = x,
                        y = y,
                        crv = CryptoHelper.GetCrvValueFromCurve(parameters.Curve),
                        x5c = new[] { cert64 },
                        alg = key.SigningAlgorithm
                    };
                    webKeys.Add(ecdsaJsonWebKey);
                }
                else
                {
                    throw new InvalidOperationException($"key type: {x509Key.PublicKey.GetType().Name} not supported.");
                }
            }
            else if (key.Key is RsaSecurityKey rsaKey)
            {
                var parameters = rsaKey.Rsa?.ExportParameters(false) ?? rsaKey.Parameters;
                var exponent = Base64Url.Encode(parameters.Exponent);
                var modulus = Base64Url.Encode(parameters.Modulus);

                var webKey = new Models.JsonWebKey
                {
                    kty = "RSA",
                    use = "sig",
                    kid = rsaKey.KeyId,
                    e = exponent,
                    n = modulus,
                    alg = key.SigningAlgorithm
                };

                webKeys.Add(webKey);
            }
            else if (key.Key is ECDsaSecurityKey ecdsaKey)
            {
                var parameters = ecdsaKey.ECDsa.ExportParameters(false);
                var x = Base64Url.Encode(parameters.Q.X);
                var y = Base64Url.Encode(parameters.Q.Y);

                var ecdsaJsonWebKey = new Models.JsonWebKey
                {
                    kty = "EC",
                    use = "sig",
                    kid = ecdsaKey.KeyId,
                    x = x,
                    y = y,
                    crv = CryptoHelper.GetCrvValueFromCurve(parameters.Curve),
                    alg = key.SigningAlgorithm
                };
                webKeys.Add(ecdsaJsonWebKey);
            }
            else if (key.Key is JsonWebKey jsonWebKey)
            {
                var webKey = new Models.JsonWebKey
                {
                    kty = jsonWebKey.Kty,
                    use = jsonWebKey.Use ?? "sig",
                    kid = jsonWebKey.Kid,
                    x5t = jsonWebKey.X5t,
                    e = jsonWebKey.E,
                    n = jsonWebKey.N,
                    x5c = jsonWebKey.X5c?.Count == 0 ? null : jsonWebKey.X5c.ToArray(),
                    alg = jsonWebKey.Alg,
                    crv = jsonWebKey.Crv,
                    x = jsonWebKey.X,
                    y = jsonWebKey.Y
                };

                webKeys.Add(webKey);
            }
        }

        return webKeys;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/IntrospectionResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// The introspection response generator
/// 
/// 
public class IntrospectionResponseGenerator : IIntrospectionResponseGenerator
{
    /// 
    /// Gets the events.
    /// 
    /// 
    /// The events.
    /// 
    protected readonly IEventService Events;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The events.
    /// The logger.
    public IntrospectionResponseGenerator(IEventService events, ILogger logger)
    {
        Events = events;
        Logger = logger;
    }

    /// 
    /// Processes the response.
    /// 
    /// The validation result.
    /// 
    public virtual async Task> ProcessAsync(IntrospectionRequestValidationResult validationResult)
    {
        Logger.LogTrace("Creating introspection response");

        // standard response
        var response = new Dictionary
        {
            { "active", false }
        };

        // token is invalid
        if (validationResult.IsActive == false)
        {
            Logger.LogDebug("Creating introspection response for inactive token.");
            await Events.RaiseAsync(new TokenIntrospectionSuccessEvent(validationResult));

            return response;
        }

        // expected scope not present
        if (await AreExpectedScopesPresentAsync(validationResult) == false)
        {
            return response;
        }

        Logger.LogDebug("Creating introspection response for active token.");

        // get all claims (without scopes)
        response = validationResult.Claims.Where(c => c.Type != JwtClaimTypes.Scope).ToClaimsDictionary();

        // add active flag
        response.Add("active", true);

        // calculate scopes the caller is allowed to see
        var allowedScopes = validationResult.Api.Scopes;
        var scopes = validationResult.Claims.Where(c => c.Type == JwtClaimTypes.Scope).Select(x => x.Value);
        scopes = scopes.Where(x => allowedScopes.Contains(x));
        response.Add("scope", scopes.ToSpaceSeparatedString());

        await Events.RaiseAsync(new TokenIntrospectionSuccessEvent(validationResult));
        return response;
    }

    /// 
    /// Checks if the API resource is allowed to introspect the scopes.
    /// 
    /// The validation result.
    /// 
    protected virtual async Task AreExpectedScopesPresentAsync(IntrospectionRequestValidationResult validationResult)
    {
        var apiScopes = validationResult.Api.Scopes;
        var tokenScopes = validationResult.Claims.Where(c => c.Type == JwtClaimTypes.Scope);

        var tokenScopesThatMatchApi = tokenScopes.Where(c => apiScopes.Contains(c.Value));

        var result = false;

        if (tokenScopesThatMatchApi.Any())
        {
            // at least one of the scopes the API supports is in the token
            result = true;
        }
        else
        {
            // no scopes for this API are found in the token
            Logger.LogError("Expected scope {scopes} is missing in token", apiScopes);
            await Events.RaiseAsync(new TokenIntrospectionFailureEvent(validationResult.Api.Name, "Expected scopes are missing", validationResult.Token, apiScopes, tokenScopes.Select(s => s.Value)));
        }

        return result;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/TokenResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// The default token response generator
/// 
/// 
public class TokenResponseGenerator : ITokenResponseGenerator
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The token service
    /// 
    protected readonly ITokenService TokenService;

    /// 
    /// The refresh token service
    /// 
    protected readonly IRefreshTokenService RefreshTokenService;

    /// 
    /// The scope parser
    /// 
    public IScopeParser ScopeParser { get; }

    /// 
    /// The resource store
    /// 
    protected readonly IResourceStore Resources;

    /// 
    /// The clients store
    /// 
    protected readonly IClientStore Clients;

    /// 
    ///  The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clock.
    /// The token service.
    /// The refresh token service.
    /// The scope parser.
    /// The resources.
    /// The clients.
    /// The logger.
    public TokenResponseGenerator(ISystemClock clock, ITokenService tokenService, IRefreshTokenService refreshTokenService, IScopeParser scopeParser, IResourceStore resources, IClientStore clients, ILogger logger)
    {
        Clock = clock;
        TokenService = tokenService;
        RefreshTokenService = refreshTokenService;
        ScopeParser = scopeParser;
        Resources = resources;
        Clients = clients;
        Logger = logger;
    }

    /// 
    /// Processes the response.
    /// 
    /// The request.
    /// 
    public virtual async Task ProcessAsync(TokenRequestValidationResult request)
    {
        switch (request.ValidatedRequest.GrantType)
        {
            case OidcConstants.GrantTypes.ClientCredentials:
                return await ProcessClientCredentialsRequestAsync(request);
            case OidcConstants.GrantTypes.Password:
                return await ProcessPasswordRequestAsync(request);
            case OidcConstants.GrantTypes.AuthorizationCode:
                return await ProcessAuthorizationCodeRequestAsync(request);
            case OidcConstants.GrantTypes.RefreshToken:
                return await ProcessRefreshTokenRequestAsync(request);
            case OidcConstants.GrantTypes.DeviceCode:
                return await ProcessDeviceCodeRequestAsync(request);
            default:
                return await ProcessExtensionGrantRequestAsync(request);
        }
    }

    /// 
    /// Creates the response for an client credentials request.
    /// 
    /// The request.
    /// 
    protected virtual Task ProcessClientCredentialsRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for client credentials request");

        return ProcessTokenRequestAsync(request);
    }

    /// 
    /// Creates the response for a password request.
    /// 
    /// The request.
    /// 
    protected virtual Task ProcessPasswordRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for password request");

        return ProcessTokenRequestAsync(request);
    }

    /// 
    /// Creates the response for an authorization code request.
    /// 
    /// The request.
    /// 
    /// Client does not exist anymore.
    protected virtual async Task ProcessAuthorizationCodeRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for authorization code request");

        //////////////////////////
        // access token
        /////////////////////////
        var (accessToken, refreshToken) = await CreateAccessTokenAsync(request.ValidatedRequest);
        var response = new TokenResponse
        {
            AccessToken = accessToken,
            AccessTokenLifetime = request.ValidatedRequest.AccessTokenLifetime,
            Custom = request.CustomResponse,
            Scope = request.ValidatedRequest.AuthorizationCode.RequestedScopes.ToSpaceSeparatedString()
        };

        //////////////////////////
        // refresh token
        /////////////////////////
        if (refreshToken.IsPresent())
        {
            response.RefreshToken = refreshToken;
        }

        //////////////////////////
        // id token
        /////////////////////////
        if (request.ValidatedRequest.AuthorizationCode.IsOpenId)
        {
            // load the client that belongs to the authorization code
            Client client = null;
            if (request.ValidatedRequest.AuthorizationCode.ClientId != null)
            {
                client = await Clients.FindEnabledClientByIdAsync(request.ValidatedRequest.AuthorizationCode.ClientId);
            }
            if (client == null)
            {
                throw new InvalidOperationException("Client does not exist anymore.");
            }

            var parsedScopesResult = ScopeParser.ParseScopeValues(request.ValidatedRequest.AuthorizationCode.RequestedScopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);

            var tokenRequest = new TokenCreationRequest
            {
                Subject = request.ValidatedRequest.AuthorizationCode.Subject,
                ValidatedResources = validatedResources,
                Nonce = request.ValidatedRequest.AuthorizationCode.Nonce,
                AccessTokenToHash = response.AccessToken,
                StateHash = request.ValidatedRequest.AuthorizationCode.StateHash,
                ValidatedRequest = request.ValidatedRequest
            };

            var idToken = await TokenService.CreateIdentityTokenAsync(tokenRequest);
            var jwt = await TokenService.CreateSecurityTokenAsync(idToken);
            response.IdentityToken = jwt;
        }

        return response;
    }

    /// 
    /// Creates the response for a refresh token request.
    /// 
    /// The request.
    /// 
    protected virtual async Task ProcessRefreshTokenRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for refresh token request");

        var oldAccessToken = request.ValidatedRequest.RefreshToken.AccessToken;
        string accessTokenString;

        if (request.ValidatedRequest.Client.UpdateAccessTokenClaimsOnRefresh)
        {
            var subject = request.ValidatedRequest.RefreshToken.Subject;

            // todo: do we want to just parse here and build up validated result
            // or do we want to fully re-run validation here.
            var parsedScopesResult = ScopeParser.ParseScopeValues(oldAccessToken.Scopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);

            var creationRequest = new TokenCreationRequest
            {
                Subject = subject,
                Description = request.ValidatedRequest.RefreshToken.Description,
                ValidatedRequest = request.ValidatedRequest,
                ValidatedResources = validatedResources
            };

            var newAccessToken = await TokenService.CreateAccessTokenAsync(creationRequest);
            accessTokenString = await TokenService.CreateSecurityTokenAsync(newAccessToken);
        }
        else
        {
            oldAccessToken.CreationTime = Clock.UtcNow.UtcDateTime;
            oldAccessToken.Lifetime = request.ValidatedRequest.AccessTokenLifetime;

            accessTokenString = await TokenService.CreateSecurityTokenAsync(oldAccessToken);
        }

        var handle = await RefreshTokenService.UpdateRefreshTokenAsync(request.ValidatedRequest.RefreshTokenHandle, request.ValidatedRequest.RefreshToken, request.ValidatedRequest.Client);

        return new TokenResponse
        {
            IdentityToken = await CreateIdTokenFromRefreshTokenRequestAsync(request.ValidatedRequest, accessTokenString),
            AccessToken = accessTokenString,
            AccessTokenLifetime = request.ValidatedRequest.AccessTokenLifetime,
            RefreshToken = handle,
            Custom = request.CustomResponse,
            Scope = request.ValidatedRequest.RefreshToken.Scopes.ToSpaceSeparatedString()
        };
    }

    /// 
    /// Processes the response for device code grant request.
    /// 
    /// The request.
    /// 
    protected virtual async Task ProcessDeviceCodeRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for device code request");

        //////////////////////////
        // access token
        /////////////////////////
        var (accessToken, refreshToken) = await CreateAccessTokenAsync(request.ValidatedRequest);
        var response = new TokenResponse
        {
            AccessToken = accessToken,
            AccessTokenLifetime = request.ValidatedRequest.AccessTokenLifetime,
            Custom = request.CustomResponse,
            Scope = request.ValidatedRequest.DeviceCode.AuthorizedScopes.ToSpaceSeparatedString()
        };

        //////////////////////////
        // refresh token
        /////////////////////////
        if (refreshToken.IsPresent())
        {
            response.RefreshToken = refreshToken;
        }

        //////////////////////////
        // id token
        /////////////////////////
        if (request.ValidatedRequest.DeviceCode.IsOpenId)
        {
            // load the client that belongs to the device code
            Client client = null;
            if (request.ValidatedRequest.DeviceCode.ClientId != null)
            {
                client = await Clients.FindEnabledClientByIdAsync(request.ValidatedRequest.DeviceCode.ClientId);
            }
            if (client == null)
            {
                throw new InvalidOperationException("Client does not exist anymore.");
            }

            var parsedScopesResult = ScopeParser.ParseScopeValues(request.ValidatedRequest.DeviceCode.AuthorizedScopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);
            
            var tokenRequest = new TokenCreationRequest
            {
                Subject = request.ValidatedRequest.DeviceCode.Subject,
                ValidatedResources = validatedResources,
                AccessTokenToHash = response.AccessToken,
                ValidatedRequest = request.ValidatedRequest
            };

            var idToken = await TokenService.CreateIdentityTokenAsync(tokenRequest);
            var jwt = await TokenService.CreateSecurityTokenAsync(idToken);
            response.IdentityToken = jwt;
        }

        return response;
    }

    /// 
    /// Creates the response for an extension grant request.
    /// 
    /// The request.
    /// 
    protected virtual Task ProcessExtensionGrantRequestAsync(TokenRequestValidationResult request)
    {
        Logger.LogTrace("Creating response for extension grant request");

        return ProcessTokenRequestAsync(request);
    }

    /// 
    /// Creates the response for a token request.
    /// 
    /// The validation result.
    /// 
    protected virtual async Task ProcessTokenRequestAsync(TokenRequestValidationResult validationResult)
    {
        (var accessToken, var refreshToken) = await CreateAccessTokenAsync(validationResult.ValidatedRequest);
        var response = new TokenResponse
        {
            AccessToken = accessToken,
            AccessTokenLifetime = validationResult.ValidatedRequest.AccessTokenLifetime,
            Custom = validationResult.CustomResponse,
            Scope = validationResult.ValidatedRequest.ValidatedResources.RawScopeValues.ToSpaceSeparatedString()
        };

        if (refreshToken.IsPresent())
        {
            response.RefreshToken = refreshToken;
        }

        return response;
    }

    /// 
    /// Creates the access/refresh token.
    /// 
    /// The request.
    /// 
    /// Client does not exist anymore.
    protected virtual async Task<(string accessToken, string refreshToken)> CreateAccessTokenAsync(ValidatedTokenRequest request)
    {
        TokenCreationRequest tokenRequest;
        bool createRefreshToken;

        if (request.AuthorizationCode != null)
        {
            createRefreshToken = request.AuthorizationCode.RequestedScopes.Contains(IdentityServerConstants.StandardScopes.OfflineAccess);

            // load the client that belongs to the authorization code
            Client client = null;
            if (request.AuthorizationCode.ClientId != null)
            {
                client = await Clients.FindEnabledClientByIdAsync(request.AuthorizationCode.ClientId);
            }
            if (client == null)
            {
                throw new InvalidOperationException("Client does not exist anymore.");
            }

            var parsedScopesResult = ScopeParser.ParseScopeValues(request.AuthorizationCode.RequestedScopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);

            tokenRequest = new TokenCreationRequest
            {
                Subject = request.AuthorizationCode.Subject,
                Description = request.AuthorizationCode.Description,
                ValidatedResources = validatedResources,
                ValidatedRequest = request
            };
        }
        else if (request.DeviceCode != null)
        {
            createRefreshToken = request.DeviceCode.AuthorizedScopes.Contains(IdentityServerConstants.StandardScopes.OfflineAccess);

            Client client = null;
            if (request.DeviceCode.ClientId != null)
            {
                client = await Clients.FindEnabledClientByIdAsync(request.DeviceCode.ClientId);
            }
            if (client == null)
            {
                throw new InvalidOperationException("Client does not exist anymore.");
            }

            var parsedScopesResult = ScopeParser.ParseScopeValues(request.DeviceCode.AuthorizedScopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);

            tokenRequest = new TokenCreationRequest
            {
                Subject = request.DeviceCode.Subject,
                Description = request.DeviceCode.Description,
                ValidatedResources = validatedResources,
                ValidatedRequest = request
            };
        }
        else
        {
            createRefreshToken = request.ValidatedResources.Resources.OfflineAccess;

            tokenRequest = new TokenCreationRequest
            {
                Subject = request.Subject,
                ValidatedResources = request.ValidatedResources,
                ValidatedRequest = request
            };
        }

        var at = await TokenService.CreateAccessTokenAsync(tokenRequest);
        var accessToken = await TokenService.CreateSecurityTokenAsync(at);

        if (createRefreshToken)
        {
            var refreshToken = await RefreshTokenService.CreateRefreshTokenAsync(tokenRequest.Subject, at, request.Client);
            return (accessToken, refreshToken);
        }

        return (accessToken, null);
    }

    /// 
    /// Creates an id_token for a refresh token request if identity resources have been requested.
    /// 
    /// The request.
    /// The new access token.
    /// 
    protected virtual async Task CreateIdTokenFromRefreshTokenRequestAsync(ValidatedTokenRequest request, string newAccessToken)
    {
        // todo: can we just check for "openid" scope?
        //var identityResources = await Resources.FindEnabledIdentityResourcesByScopeAsync(request.RefreshToken.Scopes);
        //if (identityResources.Any())
        
        if (request.RefreshToken.Scopes.Contains(OidcConstants.StandardScopes.OpenId))
        {
            var oldAccessToken = request.RefreshToken.AccessToken;

            var parsedScopesResult = ScopeParser.ParseScopeValues(oldAccessToken.Scopes);
            var validatedResources = await Resources.CreateResourceValidationResult(parsedScopesResult);

            var tokenRequest = new TokenCreationRequest
            {
                Subject = request.RefreshToken.Subject,
                ValidatedResources = validatedResources,
                ValidatedRequest = request,
                AccessTokenToHash = newAccessToken
            };

            var idToken = await TokenService.CreateIdentityTokenAsync(tokenRequest);
            return await TokenService.CreateSecurityTokenAsync(idToken);
        }

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/TokenRevocationResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Default revocation response generator
/// 
/// 
public class TokenRevocationResponseGenerator : ITokenRevocationResponseGenerator
{
    /// 
    /// Gets the reference token store.
    /// 
    /// 
    /// The reference token store.
    /// 
    protected readonly IReferenceTokenStore ReferenceTokenStore;

    /// 
    /// Gets the refresh token store.
    /// 
    /// 
    /// The refresh token store.
    /// 
    protected readonly IRefreshTokenStore RefreshTokenStore;

    /// 
    /// Gets the logger.
    /// 
    /// 
    /// The logger.
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The reference token store.
    /// The refresh token store.
    /// The logger.
    public TokenRevocationResponseGenerator(IReferenceTokenStore referenceTokenStore, IRefreshTokenStore refreshTokenStore, ILogger logger)
    {
        ReferenceTokenStore = referenceTokenStore;
        RefreshTokenStore = refreshTokenStore;
        Logger = logger;
    }

    /// 
    /// Creates the revocation endpoint response and processes the revocation request.
    /// 
    /// The userinfo request validation result.
    /// 
    public virtual async Task ProcessAsync(TokenRevocationRequestValidationResult validationResult)
    {
        var response = new TokenRevocationResponse
        {
            Success = false,
            TokenType = validationResult.TokenTypeHint
        };

        // revoke tokens
        if (validationResult.TokenTypeHint == Constants.TokenTypeHints.AccessToken)
        {
            Logger.LogTrace("Hint was for access token");
            response.Success = await RevokeAccessTokenAsync(validationResult);
        }
        else if (validationResult.TokenTypeHint == Constants.TokenTypeHints.RefreshToken)
        {
            Logger.LogTrace("Hint was for refresh token");
            response.Success = await RevokeRefreshTokenAsync(validationResult);
        }
        else
        {
            Logger.LogTrace("No hint for token type");

            response.Success = await RevokeAccessTokenAsync(validationResult);

            if (!response.Success)
            {
                response.Success = await RevokeRefreshTokenAsync(validationResult);
                response.TokenType = Constants.TokenTypeHints.RefreshToken;
            }
            else
            {
                response.TokenType = Constants.TokenTypeHints.AccessToken;
            }
        }

        return response;
    }

    /// 
    /// Revoke access token only if it belongs to client doing the request.
    /// 
    protected virtual async Task RevokeAccessTokenAsync(TokenRevocationRequestValidationResult validationResult)
    {
        var token = await ReferenceTokenStore.GetReferenceTokenAsync(validationResult.Token);

        if (token != null)
        {
            if (token.ClientId == validationResult.Client.ClientId)
            {
                Logger.LogDebug("Access token revoked");
                await ReferenceTokenStore.RemoveReferenceTokenAsync(validationResult.Token);
            }
            else
            {
                Logger.LogWarning("Client {clientId} denied from revoking access token belonging to Client {tokenClientId}", validationResult.Client.ClientId, token.ClientId);
            }

            return true;
        }

        return false;
    }

    /// 
    /// Revoke refresh token only if it belongs to client doing the request
    /// 
    protected virtual async Task RevokeRefreshTokenAsync(TokenRevocationRequestValidationResult validationResult)
    {
        var token = await RefreshTokenStore.GetRefreshTokenAsync(validationResult.Token);

        if (token != null)
        {
            if (token.ClientId == validationResult.Client.ClientId)
            {
                Logger.LogDebug("Refresh token revoked");
                await RefreshTokenStore.RemoveRefreshTokenAsync(validationResult.Token);
                await ReferenceTokenStore.RemoveReferenceTokensAsync(token.SubjectId, token.ClientId);
            }
            else
            {
                Logger.LogWarning("Client {clientId} denied from revoking a refresh token belonging to Client {tokenClientId}", validationResult.Client.ClientId, token.ClientId);
            }

            return true;
        }

        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Default/UserInfoResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// The userinfo response generator
/// 
/// 
public class UserInfoResponseGenerator : IUserInfoResponseGenerator
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The profile service
    /// 
    protected readonly IProfileService Profile;

    /// 
    /// The resource store
    /// 
    protected readonly IResourceStore Resources;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The profile.
    /// The resource store.
    /// The logger.
    public UserInfoResponseGenerator(IProfileService profile, IResourceStore resourceStore, ILogger logger)
    {
        Profile = profile;
        Resources = resourceStore;
        Logger = logger;
    }

    /// 
    /// Creates the response.
    /// 
    /// The userinfo request validation result.
    /// 
    /// Profile service returned incorrect subject value
    public virtual async Task> ProcessAsync(UserInfoRequestValidationResult validationResult)
    {
        Logger.LogDebug("Creating userinfo response");

        // extract scopes and turn into requested claim types
        var scopes = validationResult.TokenValidationResult.Claims.Where(c => c.Type == JwtClaimTypes.Scope).Select(c => c.Value);

        var validatedResources = await GetRequestedResourcesAsync(scopes);
        var requestedClaimTypes = await GetRequestedClaimTypesAsync(validatedResources);

        Logger.LogDebug("Requested claim types: {claimTypes}", requestedClaimTypes.ToSpaceSeparatedString());

        // call profile service
        var context = new ProfileDataRequestContext(
            validationResult.Subject,
            validationResult.TokenValidationResult.Client,
            IdentityServerConstants.ProfileDataCallers.UserInfoEndpoint,
            requestedClaimTypes);
        context.RequestedResources = validatedResources;

        await Profile.GetProfileDataAsync(context);
        var profileClaims = context.IssuedClaims;

        // construct outgoing claims
        var outgoingClaims = new List();

        if (profileClaims == null)
        {
            Logger.LogInformation("Profile service returned no claims (null)");
        }
        else
        {
            outgoingClaims.AddRange(profileClaims);
            Logger.LogInformation("Profile service returned the following claim types: {types}", profileClaims.Select(c => c.Type).ToSpaceSeparatedString());
        }

        var subClaim = outgoingClaims.SingleOrDefault(x => x.Type == JwtClaimTypes.Subject);
        if (subClaim == null)
        {
            outgoingClaims.Add(new Claim(JwtClaimTypes.Subject, validationResult.Subject.GetSubjectId()));
        }
        else if (subClaim.Value != validationResult.Subject.GetSubjectId())
        {
            Logger.LogError("Profile service returned incorrect subject value: {sub}", subClaim);
            throw new InvalidOperationException("Profile service returned incorrect subject value");
        }

        return outgoingClaims.ToClaimsDictionary();
    }

    /// 
    ///  Gets the identity resources from the scopes.
    /// 
    /// 
    /// 
    protected internal virtual async Task GetRequestedResourcesAsync(IEnumerable scopes)
    {
        if (scopes == null || !scopes.Any())
        {
            return null;
        }

        var scopeString = string.Join(" ", scopes);
        Logger.LogDebug("Scopes in access token: {scopes}", scopeString);

        // if we ever parameterize identity scopes, then we would need to invoke the resource validator's parse API here
        var identityResources = await Resources.FindEnabledIdentityResourcesByScopeAsync(scopes);
        
        var resources = new Resources(identityResources, Enumerable.Empty(), Enumerable.Empty());
        var result = new ResourceValidationResult(resources);
        
        return result;
    }

    /// 
    /// Gets the requested claim types.
    /// 
    /// 
    /// 
    protected internal virtual Task> GetRequestedClaimTypesAsync(ResourceValidationResult resourceValidationResult)
    {
        IEnumerable result = null;

        if (resourceValidationResult == null)
        {
            result = Enumerable.Empty();
        }
        else
        {
            var identityResources = resourceValidationResult.Resources.IdentityResources;
            result = identityResources.SelectMany(x => x.UserClaims).Distinct();
        }

        return Task.FromResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IAuthorizeInteractionResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for determining if user must login or consent when making requests to the authorization endpoint.
/// 
public interface IAuthorizeInteractionResponseGenerator
{
    /// 
    /// Processes the interaction logic.
    /// 
    /// The request.
    /// The consent.
    /// 
    Task ProcessInteractionAsync(ValidatedAuthorizeRequest request, ConsentResponse consent = null);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IAuthorizeResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for the authorize response generator
/// 
public interface IAuthorizeResponseGenerator
{
    /// 
    /// Creates the response
    /// 
    /// The request.
    /// 
    Task CreateResponseAsync(ValidatedAuthorizeRequest request);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IDeviceAuthorizationResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for the device authorization response generator
/// 
public interface IDeviceAuthorizationResponseGenerator
{
    /// 
    /// Processes the response.
    /// 
    /// The validation result.
    /// The base URL.
    /// 
    Task ProcessAsync(DeviceAuthorizationRequestValidationResult validationResult, string baseUrl);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IDiscoveryResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for discovery endpoint response generator
/// 
public interface IDiscoveryResponseGenerator
{
    /// 
    /// Creates the discovery document.
    /// 
    /// The base URL.
    /// The issuer URI.
    Task> CreateDiscoveryDocumentAsync(string baseUrl, string issuerUri);

    /// 
    /// Creates the JWK document.
    /// 
    Task> CreateJwkDocumentAsync();
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IIntrospectionResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for introspection response generator
/// 
public interface IIntrospectionResponseGenerator
{
    /// 
    /// Processes the response.
    /// 
    /// The validation result.
    /// 
    Task> ProcessAsync(IntrospectionRequestValidationResult validationResult);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/ITokenResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface the token response generator
/// 
public interface ITokenResponseGenerator
{
    /// 
    /// Processes the response.
    /// 
    /// The validation result.
    /// 
    Task ProcessAsync(TokenRequestValidationResult validationResult);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/ITokenRevocationResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for the userinfo response generator
/// 
public interface ITokenRevocationResponseGenerator
{
    /// 
    /// Creates the revocation endpoint response and processes the revocation request.
    /// 
    /// The userinfo request validation result.
    /// 
    Task ProcessAsync(TokenRevocationRequestValidationResult validationResult);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/IUserInfoResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Interface for the userinfo response generator
/// 
public interface IUserInfoResponseGenerator
{
    /// 
    /// Creates the response.
    /// 
    /// The userinfo request validation result.
    /// 
    Task> ProcessAsync(UserInfoRequestValidationResult validationResult);
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/AuthorizeResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.ResponseHandling;

public class AuthorizeResponse
{
    public ValidatedAuthorizeRequest Request { get; set; }
    public string RedirectUri => Request?.RedirectUri;
    public string State => Request?.State;
    public string Scope => Request?.ValidatedResources?.RawScopeValues.ToSpaceSeparatedString();

    public string IdentityToken { get; set; }
    public string AccessToken { get; set; }
    public int AccessTokenLifetime { get; set; }
    public string Code { get; set; }
    public string SessionState { get; set; }

    public string Error { get; set; }
    public string ErrorDescription { get; set; }
    public bool IsError => Error.IsPresent();
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/DeviceAuthorizationResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.ResponseHandling;

public class DeviceAuthorizationResponse
{
    public string DeviceCode { get; set; }
    public string UserCode { get; set; }
    public string VerificationUri { get; set; }

    public string VerificationUriComplete { get; set; }
    public int DeviceCodeLifetime { get; set; }
    public int Interval { get; set; }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/InteractionResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Indicates interaction outcome for user on authorization endpoint.
/// 
public class InteractionResponse
{
    /// 
    /// Gets or sets a value indicating whether the user must login.
    /// 
    /// 
    ///   true if this instance is login; otherwise, false.
    /// 
    public bool IsLogin { get; set; }

    /// 
    /// Gets or sets a value indicating whether the user must consent.
    /// 
    /// 
    /// true if this instance is consent; otherwise, false.
    /// 
    public bool IsConsent { get; set; }

    /// 
    /// Gets a value indicating whether the result is an error.
    /// 
    /// 
    ///   true if this instance is error; otherwise, false.
    /// 
    public bool IsError => Error != null;

    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }

    /// 
    /// Gets a value indicating whether the user must be redirected to a custom page.
    /// 
    /// 
    /// true if this instance is redirect; otherwise, false.
    /// 
    public bool IsRedirect => RedirectUrl.IsPresent();

    /// 
    /// Gets or sets the URL for the custom page.
    /// 
    /// 
    /// The redirect URL.
    /// 
    public string RedirectUrl { get; set; }
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/TokenErrorResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Models a token error response
/// 
public class TokenErrorResponse
{
    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; } = OidcConstants.TokenErrors.InvalidRequest;

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }

    /// 
    /// Gets or sets the custom entries.
    /// 
    /// 
    /// The custom.
    /// 
    public Dictionary Custom { get; set; } = new Dictionary();
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/TokenResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Models a token response
/// 
public class TokenResponse
{
    /// 
    /// Gets or sets the identity token.
    /// 
    /// 
    /// The identity token.
    /// 
    public string IdentityToken { get; set; }

    /// 
    /// Gets or sets the access token.
    /// 
    /// 
    /// The access token.
    /// 
    public string AccessToken { get; set; }

    /// 
    /// Gets or sets the access token lifetime.
    /// 
    /// 
    /// The access token lifetime.
    /// 
    public int AccessTokenLifetime { get; set; }

    /// 
    /// Gets or sets the refresh token.
    /// 
    /// 
    /// The refresh token.
    /// 
    public string RefreshToken { get; set; }

    /// 
    /// Gets or sets the scope.
    /// 
    /// 
    /// The scope.
    /// 
    public string Scope { get; set; }

    /// 
    /// Gets or sets the custom entries.
    /// 
    /// 
    /// The custom entries.
    /// 
    public Dictionary Custom { get; set; } = new Dictionary();
}


================================================
FILE: src/IdentityServer8/src/ResponseHandling/Models/TokenRevocationResponse.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.ResponseHandling;

/// 
/// Models a token revocation response
/// 
public class TokenRevocationResponse
{
    /// 
    /// Gets or sets a value indicating whether the token revocation was successful.
    /// 
    /// 
    ///   true if success; otherwise, false.
    /// 
    public bool Success { get; set; }

    /// 
    /// Gets or sets the type of the token that was revoked.
    /// 
    /// 
    /// The type of the token.
    /// 
    public string TokenType { get; set; }

    /// 
    /// Gets or sets an error (if present).
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/BackChannelLogoutHttpClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Models making HTTP requests for back-channel logout notification.
/// 
public class DefaultBackChannelLogoutHttpClient : IBackChannelLogoutHttpClient
{
    private readonly HttpClient _client;
    private readonly ILogger _logger;

    /// 
    /// Constructor for BackChannelLogoutHttpClient.
    /// 
    /// 
    /// 
    public DefaultBackChannelLogoutHttpClient(HttpClient client, ILoggerFactory loggerFactory)
    {
        _client = client;
        _logger = loggerFactory.CreateLogger();
    }

    /// 
    /// Posts the payload to the url.
    /// 
    /// 
    /// 
    /// 
    public async Task PostAsync(string url, Dictionary payload)
    {
        try
        {
            var response = await _client.PostAsync(url, new FormUrlEncodedContent(payload));
            if (response.IsSuccessStatusCode)
            {
                _logger.LogDebug("Response from back-channel logout endpoint: {url} status code: {status}", url, (int)response.StatusCode);
            }
            else
            {
                _logger.LogWarning("Response from back-channel logout endpoint: {url} status code: {status}", url, (int)response.StatusCode);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Exception invoking back-channel logout for url: {url}", url);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultBackChannelLogoutService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default back-channel logout notification implementation.
/// 
public class DefaultBackChannelLogoutService : IBackChannelLogoutService
{
    /// 
    /// Default value for the back-channel JWT lifetime.
    /// 
    protected const int DefaultLogoutTokenLifetime = 5 * 60;

    /// 
    /// The system clock;
    /// 
    protected ISystemClock Clock { get; }
    
    /// 
    /// The IdentityServerTools used to create and the JWT.
    /// 
    protected IdentityServerTools Tools { get; }

    /// 
    /// The ILogoutNotificationService to build the back channel logout requests.
    /// 
    public ILogoutNotificationService LogoutNotificationService { get; }

    /// 
    /// HttpClient to make the outbound HTTP calls.
    /// 
    protected IBackChannelLogoutHttpClient HttpClient { get; }

    /// 
    /// The logger.
    /// 
    protected ILogger Logger { get; }

    /// 
    /// Constructor.
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    public DefaultBackChannelLogoutService(
        ISystemClock clock,
        IdentityServerTools tools,
        ILogoutNotificationService logoutNotificationService,
        IBackChannelLogoutHttpClient backChannelLogoutHttpClient,
        ILogger logger)
    {
        Clock = clock;
        Tools = tools;
        LogoutNotificationService = logoutNotificationService;
        HttpClient = backChannelLogoutHttpClient;
        Logger = logger;
    }

    /// 
    public virtual async Task SendLogoutNotificationsAsync(LogoutNotificationContext context)
    {
        var backChannelRequests = await LogoutNotificationService.GetBackChannelLogoutNotificationsAsync(context);
        if (backChannelRequests.Any())
        {
            await SendLogoutNotificationsAsync(backChannelRequests);
        }
    }

    /// 
    /// Sends the logout notifications for the collection of clients.
    /// 
    /// 
    /// 
    protected virtual Task SendLogoutNotificationsAsync(IEnumerable requests)
    {
        requests = requests ?? Enumerable.Empty();
        var tasks = requests.Select(SendLogoutNotificationAsync).ToArray();
        return Task.WhenAll(tasks);
    }

    /// 
    /// Performs the back-channel logout for a single client.
    /// 
    /// 
    protected virtual async Task SendLogoutNotificationAsync(BackChannelLogoutRequest request)
    {
        var data = await CreateFormPostPayloadAsync(request);
        await PostLogoutJwt(request, data);
    }

    /// 
    /// Performs the HTTP POST of the logout payload to the client.
    /// 
    /// 
    /// 
    /// 
    protected virtual Task PostLogoutJwt(BackChannelLogoutRequest client, Dictionary data)
    {
        return HttpClient.PostAsync(client.LogoutUri, data);
    }

    /// 
    /// Creates the form-url-encoded payload (as a dictionary) to send to the client.
    /// 
    /// 
    /// 
    protected async Task> CreateFormPostPayloadAsync(BackChannelLogoutRequest request)
    {
        var token = await CreateTokenAsync(request);

        var data = new Dictionary
        {
            { OidcConstants.BackChannelLogoutRequest.LogoutToken, token }
        };
        return data;
    }

    /// 
    /// Creates the JWT used for the back-channel logout notification.
    /// 
    /// 
    /// The token.
    protected virtual async Task CreateTokenAsync(BackChannelLogoutRequest request)
    {
        var claims = await CreateClaimsForTokenAsync(request);
        if (claims.Any(x => x.Type == JwtClaimTypes.Nonce))
        {
            throw new InvalidOperationException("nonce claim is not allowed in the back-channel signout token.");
        }

        return await Tools.IssueJwtAsync(DefaultLogoutTokenLifetime, claims);
    }

    /// 
    /// Create the claims to be used in the back-channel logout token.
    /// 
    /// 
    /// The claims to include in the token.
    protected Task> CreateClaimsForTokenAsync(BackChannelLogoutRequest request)
    {
        if (request.SessionIdRequired && request.SessionId == null)
        {
            throw new ArgumentException("Client requires SessionId", nameof(request.SessionId));
        }

        var json = "{\"" + OidcConstants.Events.BackChannelLogout + "\":{} }";

        var claims = new List
        {
            new Claim(JwtClaimTypes.Subject, request.SubjectId),
            new Claim(JwtClaimTypes.Audience, request.ClientId),
            new Claim(JwtClaimTypes.IssuedAt, Clock.UtcNow.ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64),
            new Claim(JwtClaimTypes.JwtId, CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex)),
            new Claim(JwtClaimTypes.Events, json, IdentityServerConstants.ClaimValueTypes.Json)
        };

        if (request.SessionId != null)
        {
            claims.Add(new Claim(JwtClaimTypes.SessionId, request.SessionId));
        }

        return Task.FromResult(claims.AsEnumerable());
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultCache.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// IMemoryCache-based implementation of the cache
/// 
/// 
/// 
public class DefaultCache : ICache
    where T : class
{
    private const string KeySeparator = ":";

    private readonly IMemoryCache _cache;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The cache.
    public DefaultCache(IMemoryCache cache)
    {
        _cache = cache;
    }

    private string GetKey(string key)
    {
        return typeof(T).FullName + KeySeparator + key;
    }

    /// 
    /// Gets the cached data based upon a key index.
    /// 
    /// The key.
    /// 
    /// The cached item, or null if no item matches the key.
    /// 
    public Task GetAsync(string key)
    {
        key = GetKey(key);
        var item = _cache.Get(key);
        return Task.FromResult(item);
    }

    /// 
    /// Caches the data based upon a key
    /// 
    /// The key.
    /// The item.
    /// The expiration.
    /// 
    public Task SetAsync(string key, T item, TimeSpan expiration)
    {
        key = GetKey(key);
        _cache.Set(key, item, expiration);
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultClaimsService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default claims provider implementation
/// 
public class DefaultClaimsService : IClaimsService
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The user service
    /// 
    protected readonly IProfileService Profile;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The profile service
    /// The logger
    public DefaultClaimsService(IProfileService profile, ILogger logger)
    {
        Logger = logger;
        Profile = profile;
    }

    /// 
    /// Returns claims for an identity token
    /// 
    /// The subject
    /// The requested resources
    /// Specifies if all claims should be included in the token, or if the userinfo endpoint can be used to retrieve them
    /// The raw request
    /// 
    /// Claims for the identity token
    /// 
    public virtual async Task> GetIdentityTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resources, bool includeAllIdentityClaims, ValidatedRequest request)
    {
        Logger.LogDebug("Getting claims for identity token for subject: {subject} and client: {clientId}",
            subject.GetSubjectId(),
            request.Client.ClientId);

        var outputClaims = new List(GetStandardSubjectClaims(subject));
        outputClaims.AddRange(GetOptionalClaims(subject));

        // fetch all identity claims that need to go into the id token
        if (includeAllIdentityClaims || request.Client.AlwaysIncludeUserClaimsInIdToken)
        {
            var additionalClaimTypes = new List();

            foreach (var identityResource in resources.Resources.IdentityResources)
            {
                foreach (var userClaim in identityResource.UserClaims)
                {
                    additionalClaimTypes.Add(userClaim);
                }
            }

            // filter so we don't ask for claim types that we will eventually filter out
            additionalClaimTypes = FilterRequestedClaimTypes(additionalClaimTypes).ToList();

            var context = new ProfileDataRequestContext(
                subject,
                request.Client,
                IdentityServerConstants.ProfileDataCallers.ClaimsProviderIdentityToken,
                additionalClaimTypes)
            {
                RequestedResources = resources,
                ValidatedRequest = request
            };

            await Profile.GetProfileDataAsync(context);

            var claims = FilterProtocolClaims(context.IssuedClaims);
            if (claims != null)
            {
                outputClaims.AddRange(claims);
            }
        }
        else
        {
            Logger.LogDebug("In addition to an id_token, an access_token was requested. No claims other than sub are included in the id_token. To obtain more user claims, either use the user info endpoint or set AlwaysIncludeUserClaimsInIdToken on the client configuration.");
        }

        return outputClaims;
    }

    /// 
    /// Returns claims for an access token.
    /// 
    /// The subject.
    /// The validated resource result
    /// The raw request.
    /// 
    /// Claims for the access token
    /// 
    public virtual async Task> GetAccessTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resourceResult, ValidatedRequest request)
    {
        Logger.LogDebug("Getting claims for access token for client: {clientId}", request.Client.ClientId);

        var outputClaims = new List
        {
            new Claim(JwtClaimTypes.ClientId, request.ClientId)
        };

        // log if client ID is overwritten
        if (!string.Equals(request.ClientId, request.Client.ClientId))
        {
            Logger.LogDebug("Client {clientId} is impersonating {impersonatedClientId}", request.Client.ClientId, request.ClientId);
        }

        // check for client claims
        if (request.ClientClaims != null && request.ClientClaims.Any())
        {
            if (subject == null || request.Client.AlwaysSendClientClaims)
            {
                foreach (var claim in request.ClientClaims)
                {
                    var claimType = claim.Type;

                    if (request.Client.ClientClaimsPrefix.IsPresent())
                    {
                        claimType = request.Client.ClientClaimsPrefix + claimType;
                    }

                    outputClaims.Add(new Claim(claimType, claim.Value, claim.ValueType));
                }
            }
        }

        // add scopes (filter offline_access)
        // we use the ScopeValues collection rather than the Resources.Scopes because we support dynamic scope values 
        // from the request, so this issues those in the token.
        foreach (var scope in resourceResult.RawScopeValues.Where(x => x != IdentityServerConstants.StandardScopes.OfflineAccess))
        {
            outputClaims.Add(new Claim(JwtClaimTypes.Scope, scope));
        }

        // a user is involved
        if (subject != null)
        {
            if (resourceResult.Resources.OfflineAccess)
            {
                outputClaims.Add(new Claim(JwtClaimTypes.Scope, IdentityServerConstants.StandardScopes.OfflineAccess));
            }

            Logger.LogDebug("Getting claims for access token for subject: {subject}", subject.GetSubjectId());

            outputClaims.AddRange(GetStandardSubjectClaims(subject));
            outputClaims.AddRange(GetOptionalClaims(subject));

            // fetch all resource claims that need to go into the access token
            var additionalClaimTypes = new List();
            foreach (var api in resourceResult.Resources.ApiResources)
            {
                // add claims configured on api resource
                if (api.UserClaims != null)
                {
                    foreach (var claim in api.UserClaims)
                    {
                        additionalClaimTypes.Add(claim);
                    }
                }
            }

            foreach(var scope in resourceResult.Resources.ApiScopes)
            {
                // add claims configured on scopes
                if (scope.UserClaims != null)
                {
                    foreach (var claim in scope.UserClaims)
                    {
                        additionalClaimTypes.Add(claim);
                    }
                }
            }

            // filter so we don't ask for claim types that we will eventually filter out
            additionalClaimTypes = FilterRequestedClaimTypes(additionalClaimTypes).ToList();

            var context = new ProfileDataRequestContext(
                subject,
                request.Client,
                IdentityServerConstants.ProfileDataCallers.ClaimsProviderAccessToken,
                additionalClaimTypes.Distinct())
            {
                RequestedResources = resourceResult,
                ValidatedRequest = request
            };

            await Profile.GetProfileDataAsync(context);

            var claims = FilterProtocolClaims(context.IssuedClaims);
            if (claims != null)
            {
                outputClaims.AddRange(claims);
            }
        }

        return outputClaims;
    }

    /// 
    /// Gets the standard subject claims.
    /// 
    /// The subject.
    /// A list of standard claims
    protected virtual IEnumerable GetStandardSubjectClaims(ClaimsPrincipal subject)
    {
        var claims = new List
        {
            new Claim(JwtClaimTypes.Subject, subject.GetSubjectId()),
            new Claim(JwtClaimTypes.AuthenticationTime, subject.GetAuthenticationTimeEpoch().ToString(), ClaimValueTypes.Integer64),
            new Claim(JwtClaimTypes.IdentityProvider, subject.GetIdentityProvider())
        };

        claims.AddRange(subject.GetAuthenticationMethods());

        return claims;
    }

    /// 
    /// Gets additional (and optional) claims from the cookie or incoming subject.
    /// 
    /// The subject.
    /// Additional claims
    protected virtual IEnumerable GetOptionalClaims(ClaimsPrincipal subject)
    {
        var claims = new List();

        var acr = subject.FindFirst(JwtClaimTypes.AuthenticationContextClassReference);
        if (acr != null) claims.Add(acr);

        return claims;
    }

    /// 
    /// Filters out protocol claims like amr, nonce etc..
    /// 
    /// The claims.
    /// 
    protected virtual IEnumerable FilterProtocolClaims(IEnumerable claims)
    {
        var claimsToFilter = claims.Where(x => Constants.Filters.ClaimsServiceFilterClaimTypes.Contains(x.Type));
        if (claimsToFilter.Any())
        {
            var types = claimsToFilter.Select(x => x.Type);
            Logger.LogDebug("Claim types from profile service that were filtered: {claimTypes}", types);
        }
        return claims.Except(claimsToFilter);
    }

    /// 
    /// Filters out protocol claims like amr, nonce etc..
    /// 
    /// The claim types.
    protected virtual IEnumerable FilterRequestedClaimTypes(IEnumerable claimTypes)
    {
        var claimTypesToFilter = claimTypes.Where(x => Constants.Filters.ClaimsServiceFilterClaimTypes.Contains(x));
        return claimTypes.Except(claimTypesToFilter);
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultConsentService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default consent service
/// 
public class DefaultConsentService : IConsentService
{
    /// 
    /// The user consent store
    /// 
    protected readonly IUserConsentStore UserConsentStore;

    /// 
    ///  The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clock.
    /// The user consent store.
    /// The logger.
    /// store
    public DefaultConsentService(ISystemClock clock, IUserConsentStore userConsentStore, ILogger logger)
    {
        Clock = clock;
        UserConsentStore = userConsentStore;
        Logger = logger;
    }

    /// 
    /// Checks if consent is required.
    /// 
    /// The user.
    /// The client.
    /// The parsed scopes.
    /// 
    /// Boolean if consent is required.
    /// 
    /// 
    /// client
    /// or
    /// subject
    /// 
    public virtual async Task RequiresConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes)
    {
        if (client == null) throw new ArgumentNullException(nameof(client));
        if (subject == null) throw new ArgumentNullException(nameof(subject));

        if (!client.RequireConsent)
        {
            Logger.LogDebug("Client is configured to not require consent, no consent is required");
            return false;
        }

        if (parsedScopes == null || !parsedScopes.Any())
        {
            Logger.LogDebug("No scopes being requested, no consent is required");
            return false;
        }

        if (!client.AllowRememberConsent)
        {
            Logger.LogDebug("Client is configured to not allow remembering consent, consent is required");
            return true;
        }
        
        if (parsedScopes.Any(x => x.ParsedName != x.RawValue))
        {
            Logger.LogDebug("Scopes contains parameterized values, consent is required");
            return true;
        }

        var scopes = parsedScopes.Select(x => x.RawValue).ToArray();

        // we always require consent for offline access if
        // the client has not disabled RequireConsent 
        if (scopes.Contains(IdentityServerConstants.StandardScopes.OfflineAccess))
        {
            Logger.LogDebug("Scopes contains offline_access, consent is required");
            return true;
        }

        var consent = await UserConsentStore.GetUserConsentAsync(subject.GetSubjectId(), client.ClientId);

        if (consent == null)
        {
            Logger.LogDebug("Found no prior consent from consent store, consent is required");
            return true;
        }

        if (consent.Expiration.HasExpired(Clock.UtcNow.UtcDateTime))
        {
            Logger.LogDebug("Consent found in consent store is expired, consent is required");
            await UserConsentStore.RemoveUserConsentAsync(consent.SubjectId, consent.ClientId);
            return true;
        }

        if (consent.Scopes != null)
        {
            var intersect = scopes.Intersect(consent.Scopes);
            var different = scopes.Count() != intersect.Count();

            if (different)
            {
                Logger.LogDebug("Consent found in consent store is different than current request, consent is required");
            }
            else
            {
                Logger.LogDebug("Consent found in consent store is same as current request, consent is not required");
            }

            return different;
        }

        Logger.LogDebug("Consent found in consent store has no scopes, consent is required");

        return true;
    }

    /// 
    /// Updates the consent asynchronous.
    /// 
    /// The client.
    /// The subject.
    /// The parsed scopes.
    /// 
    /// 
    /// client
    /// or
    /// subject
    /// 
    public virtual async Task UpdateConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes)
    {
        if (client == null) throw new ArgumentNullException(nameof(client));
        if (subject == null) throw new ArgumentNullException(nameof(subject));

        if (client.AllowRememberConsent)
        {
            var subjectId = subject.GetSubjectId();
            var clientId = client.ClientId;

            var scopes = parsedScopes?.Select(x => x.RawValue).ToArray();
            if (scopes != null && scopes.Any())
            {
                Logger.LogDebug("Client allows remembering consent, and consent given. Updating consent store for subject: {subject}", subject.GetSubjectId());

                var consent = new Consent
                {
                    CreationTime = Clock.UtcNow.UtcDateTime,
                    SubjectId = subjectId,
                    ClientId = clientId,
                    Scopes = scopes
                };

                if (client.ConsentLifetime.HasValue)
                {
                    consent.Expiration = consent.CreationTime.AddSeconds(client.ConsentLifetime.Value);
                }

                await UserConsentStore.StoreUserConsentAsync(consent);
            }
            else
            {
                Logger.LogDebug("Client allows remembering consent, and no scopes provided. Removing consent from consent store for subject: {subject}", subject.GetSubjectId());

                await UserConsentStore.RemoveUserConsentAsync(subjectId, clientId);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultCorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default CORS policy service.
/// 
public class DefaultCorsPolicyService : ICorsPolicyService
{
    /// 
    /// Logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public DefaultCorsPolicyService(ILogger logger)
    {
        Logger = logger;
        AllowedOrigins = new HashSet();
    }

    /// 
    /// The list allowed origins that are allowed.
    /// 
    /// 
    /// The allowed origins.
    /// 
    public ICollection AllowedOrigins { get; set; }

    /// 
    /// Gets or sets a value indicating whether all origins are allowed.
    /// 
    /// 
    ///   true if allow all; otherwise, false.
    /// 
    public bool AllowAll { get; set; }

    /// 
    /// Determines whether the origin allowed.
    /// 
    /// The origin.
    /// 
    public virtual Task IsOriginAllowedAsync(string origin)
    {
        if (!String.IsNullOrWhiteSpace(origin))
        {
            if (AllowAll)
            {
                Logger.LogDebug("AllowAll true, so origin: {0} is allowed", Ioc.Sanitizer.Log.Sanitize(origin));
                return Task.FromResult(true);
            }

            if (AllowedOrigins != null)
            {
                if (AllowedOrigins.Contains(origin, StringComparer.OrdinalIgnoreCase))
                {
                    Logger.LogDebug("AllowedOrigins configured and origin {0} is allowed", Ioc.Sanitizer.Log.Sanitize(origin));
                    return Task.FromResult(true);
                }
                else
                {
                    Logger.LogDebug("AllowedOrigins configured and origin {0} is not allowed", Ioc.Sanitizer.Log.Sanitize(origin));
                }
            }

            Logger.LogDebug("Exiting; origin {0} is not allowed", Ioc.Sanitizer.Log.Sanitize(origin));
        }

        return Task.FromResult(false);
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultDeviceFlowCodeService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services.Default;

/// 
/// Default wrapper service for IDeviceFlowStore, handling key hashing
/// 
/// 
public class DefaultDeviceFlowCodeService : IDeviceFlowCodeService
{
    private readonly IDeviceFlowStore _store;
    private readonly IHandleGenerationService _handleGenerationService;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The handle generation service.
    public DefaultDeviceFlowCodeService(IDeviceFlowStore store,
        IHandleGenerationService handleGenerationService)
    {
        _store = store;
        _handleGenerationService = handleGenerationService;
    }

    /// 
    /// Stores the device authorization request.
    /// 
    /// The user code.
    /// The data.
    /// 
    public async Task StoreDeviceAuthorizationAsync(string userCode, DeviceCode data)
    {
        var deviceCode = await _handleGenerationService.GenerateAsync();

        await _store.StoreDeviceAuthorizationAsync(deviceCode.Sha256(), userCode.Sha256(), data);

        return deviceCode;
    }

    /// 
    /// Finds device authorization by user code.
    /// 
    /// The user code.
    /// 
    public Task FindByUserCodeAsync(string userCode)
    {
        return _store.FindByUserCodeAsync(userCode.Sha256());
    }

    /// 
    /// Finds device authorization by device code.
    /// 
    /// The device code.
    /// 
    public Task FindByDeviceCodeAsync(string deviceCode)
    {
        return _store.FindByDeviceCodeAsync(deviceCode.Sha256());
    }

    /// 
    /// Updates device authorization, searching by user code.
    /// 
    /// The user code.
    /// The data.
    /// 
    public Task UpdateByUserCodeAsync(string userCode, DeviceCode data)
    {
        return _store.UpdateByUserCodeAsync(userCode.Sha256(), data);
    }

    /// 
    /// Removes the device authorization, searching by device code.
    /// 
    /// The device code.
    /// 
    public Task RemoveByDeviceCodeAsync(string deviceCode)
    {
        return _store.RemoveByDeviceCodeAsync(deviceCode.Sha256());
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultDeviceFlowInteractionService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

internal class DefaultDeviceFlowInteractionService : IDeviceFlowInteractionService
{
    private readonly IClientStore _clients;
    private readonly IUserSession _session;
    private readonly IDeviceFlowCodeService _devices;
    private readonly IResourceStore _resourceStore;
    private readonly IScopeParser _scopeParser;
    private readonly ILogger _logger;

    public DefaultDeviceFlowInteractionService(
        IClientStore clients,
        IUserSession session,
        IDeviceFlowCodeService devices,
        IResourceStore resourceStore,
        IScopeParser scopeParser,
        ILogger logger)
    {
        _clients = clients;
        _session = session;
        _devices = devices;
        _resourceStore = resourceStore;
        _scopeParser = scopeParser;
        _logger = logger;
    }

    public async Task GetAuthorizationContextAsync(string userCode)
    {
        var deviceAuth = await _devices.FindByUserCodeAsync(userCode);
        if (deviceAuth == null) return null;

        var client = await _clients.FindClientByIdAsync(deviceAuth.ClientId);
        if (client == null) return null;

        var parsedScopesResult = _scopeParser.ParseScopeValues(deviceAuth.RequestedScopes);
        var validatedResources = await _resourceStore.CreateResourceValidationResult(parsedScopesResult);

        return new DeviceFlowAuthorizationRequest
        {
            Client = client,
            ValidatedResources = validatedResources
        };
    }

    public async Task HandleRequestAsync(string userCode, ConsentResponse consent)
    {
        if (userCode == null) throw new ArgumentNullException(nameof(userCode));
        if (consent == null) throw new ArgumentNullException(nameof(consent));
        
        var deviceAuth = await _devices.FindByUserCodeAsync(userCode);
        if (deviceAuth == null) return LogAndReturnError("Invalid user code", "Device authorization failure - user code is invalid");

        var client = await _clients.FindClientByIdAsync(deviceAuth.ClientId);
        if (client == null) return LogAndReturnError("Invalid client", "Device authorization failure - requesting client is invalid");

        var subject = await _session.GetUserAsync();
        if (subject == null) return LogAndReturnError("No user present in device flow request", "Device authorization failure - no user found");
        
        var sid = await _session.GetSessionIdAsync();

        deviceAuth.IsAuthorized = true;
        deviceAuth.Subject = subject;
        deviceAuth.SessionId = sid;
        deviceAuth.Description = consent.Description;
        deviceAuth.AuthorizedScopes = consent.ScopesValuesConsented;

        // TODO: Device Flow - Record consent template
        if (consent.RememberConsent)
        {
            //var consentRequest = new ConsentRequest(request, subject);
            //await _consentMessageStore.WriteAsync(consentRequest.Id, new Message(consent, _clock.UtcNow.UtcDateTime));
        }

        await _devices.UpdateByUserCodeAsync(userCode, deviceAuth);

        return new DeviceFlowInteractionResult();
    }

    private DeviceFlowInteractionResult LogAndReturnError(string error, string errorDescription = null)
    {
        _logger.LogError(errorDescription);
        return DeviceFlowInteractionResult.Failure(error);
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultEventService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Events;

/// 
/// The default event service
/// 
/// 
public class DefaultEventService : IEventService
{
    /// 
    /// The options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// The context
    /// 
    protected readonly IHttpContextAccessor Context;

    /// 
    /// The sink
    /// 
    protected readonly IEventSink Sink;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The context.
    /// The sink.
    /// The clock.
    public DefaultEventService(IdentityServerOptions options, IHttpContextAccessor context, IEventSink sink, ISystemClock clock)
    {
        Options = options;
        Context = context;
        Sink = sink;
        Clock = clock;
    }

    /// 
    /// Raises the specified event.
    /// 
    /// The event.
    /// 
    /// evt
    public async Task RaiseAsync(Event evt)
    {
        if (evt == null) throw new ArgumentNullException(nameof(evt));

        if (CanRaiseEvent(evt))
        {
            await PrepareEventAsync(evt);
            await Sink.PersistAsync(evt);
        }
    }

    /// 
    /// Indicates if the type of event will be persisted.
    /// 
    /// 
    /// 
    /// 
    public bool CanRaiseEventType(EventTypes evtType)
    {
        switch (evtType)
        {
            case EventTypes.Failure:
                return Options.Events.RaiseFailureEvents;
            case EventTypes.Information:
                return Options.Events.RaiseInformationEvents;
            case EventTypes.Success:
                return Options.Events.RaiseSuccessEvents;
            case EventTypes.Error:
                return Options.Events.RaiseErrorEvents;
            default:
                throw new ArgumentOutOfRangeException(nameof(evtType));
        }
    }

    /// 
    /// Determines whether this event would be persisted.
    /// 
    /// The evt.
    /// 
    ///   true if this event would be persisted; otherwise, false.
    /// 
    protected virtual bool CanRaiseEvent(Event evt)
    {
        return CanRaiseEventType(evt.EventType);
    }

    /// 
    /// Prepares the event.
    /// 
    /// The evt.
    /// 
    protected virtual async Task PrepareEventAsync(Event evt)
    {
        evt.ActivityId = Context.HttpContext.TraceIdentifier;
        evt.TimeStamp = Clock.UtcNow.UtcDateTime;
        evt.ProcessId = Process.GetCurrentProcess().Id;

        if (Context.HttpContext.Connection.LocalIpAddress != null)
        {
            evt.LocalIpAddress = Context.HttpContext.Connection.LocalIpAddress.ToString() + ":" + Context.HttpContext.Connection.LocalPort;
        }
        else
        {
            evt.LocalIpAddress = "unknown";
        }

        if (Context.HttpContext.Connection.RemoteIpAddress != null)
        {
            evt.RemoteIpAddress = Context.HttpContext.Connection.RemoteIpAddress.ToString();
        }
        else
        {
            evt.RemoteIpAddress = "unknown";
        }

        await evt.PrepareAsync();
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultEventSink.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default implementation of the event service. Write events raised to the log.
/// 
public class DefaultEventSink : IEventSink
{
    /// 
    /// The logger
    /// 
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public DefaultEventSink(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Raises the specified event.
    /// 
    /// The event.
    /// evt
    public virtual Task PersistAsync(Event evt)
    {
        if (evt == null) throw new ArgumentNullException(nameof(evt));

        _logger.LogInformation("{@event}", evt);

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultHandleGenerationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default handle generation service
/// 
/// 
public class DefaultHandleGenerationService : IHandleGenerationService
{
    /// 
    /// Generates a handle.
    /// 
    /// The length.
    /// 
    public Task GenerateAsync(int length)
    {
        return Task.FromResult(CryptoRandom.CreateUniqueId(length, CryptoRandom.OutputFormat.Hex));
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultIdentityServerInteractionService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

internal class DefaultIdentityServerInteractionService : IIdentityServerInteractionService
{
    private readonly ISystemClock _clock;
    private readonly IHttpContextAccessor _context;
    private readonly IMessageStore _logoutMessageStore;
    private readonly IMessageStore _errorMessageStore;
    private readonly IConsentMessageStore _consentMessageStore;
    private readonly IPersistedGrantService _grants;
    private readonly IUserSession _userSession;
    private readonly ILogger _logger;
    private readonly ReturnUrlParser _returnUrlParser;

    public DefaultIdentityServerInteractionService(
        ISystemClock clock,
        IHttpContextAccessor context,
        IMessageStore logoutMessageStore,
        IMessageStore errorMessageStore,
        IConsentMessageStore consentMessageStore,
        IPersistedGrantService grants,
        IUserSession userSession,
        ReturnUrlParser returnUrlParser,
        ILogger logger)
    {
        _clock = clock;
        _context = context;
        _logoutMessageStore = logoutMessageStore;
        _errorMessageStore = errorMessageStore;
        _consentMessageStore = consentMessageStore;
        _grants = grants;
        _userSession = userSession;
        _returnUrlParser = returnUrlParser;
        _logger = logger;
    }

    public async Task GetAuthorizationContextAsync(string returnUrl)
    {
        var result = await _returnUrlParser.ParseAsync(returnUrl);

        if (result != null)
        {
            _logger.LogTrace("AuthorizationRequest being returned");
        }
        else
        {
            _logger.LogTrace("No AuthorizationRequest being returned");
        }

        return result;
    }

    public async Task GetLogoutContextAsync(string logoutId)
    {
        var msg = await _logoutMessageStore.ReadAsync(logoutId);
        var iframeUrl = await _context.HttpContext.GetIdentityServerSignoutFrameCallbackUrlAsync(msg?.Data);
        return new LogoutRequest(iframeUrl, msg?.Data);
    }

    public async Task CreateLogoutContextAsync()
    {
        var user = await _userSession.GetUserAsync();
        if (user != null)
        {
            var clientIds = await _userSession.GetClientListAsync();
            if (clientIds.Any())
            {
                var sid = await _userSession.GetSessionIdAsync();
                var msg = new Message(new LogoutMessage
                {
                    SubjectId = user?.GetSubjectId(),
                    SessionId = sid,
                    ClientIds = clientIds
                }, _clock.UtcNow.UtcDateTime);
                var id = await _logoutMessageStore.WriteAsync(msg);
                return id;
            }
        }

        return null;
    }

    public async Task GetErrorContextAsync(string errorId)
    {
        if (errorId != null)
        { 
            var result = await _errorMessageStore.ReadAsync(errorId);
            var data = result?.Data;
            if (data != null)
            {
                _logger.LogTrace("Error context loaded");
            }
            else
            {
                _logger.LogTrace("No error context found");
            }
            return data;
        }

        _logger.LogTrace("No error context found");

        return null;
    }

    public async Task GrantConsentAsync(AuthorizationRequest request, ConsentResponse consent, string subject = null)
    {
        if (subject == null)
        {
            var user = await _userSession.GetUserAsync();
            subject = user?.GetSubjectId();
        }

        if (subject == null && consent.Granted)
        {
            throw new ArgumentNullException(nameof(subject), "User is not currently authenticated, and no subject id passed");
        }

        var consentRequest = new ConsentRequest(request, subject);
        await _consentMessageStore.WriteAsync(consentRequest.Id, new Message(consent, _clock.UtcNow.UtcDateTime));
    }

    public Task DenyAuthorizationAsync(AuthorizationRequest request, AuthorizationError error, string errorDescription = null)
    {
        var response = new ConsentResponse 
        {
            Error = error,
            ErrorDescription = errorDescription
        };
        return GrantConsentAsync(request, response);
    }

    public bool IsValidReturnUrl(string returnUrl)
    {
        var result = _returnUrlParser.IsValidReturnUrl(returnUrl);

        if (result)
        {
            _logger.LogTrace("IsValidReturnUrl true");
        }
        else
        {
            _logger.LogTrace("IsValidReturnUrl false");
        }

        return result;
    }

    public async Task> GetAllUserGrantsAsync()
    {
        var user = await _userSession.GetUserAsync();
        if (user != null)
        {
            var subject = user.GetSubjectId();
            return await _grants.GetAllGrantsAsync(subject);
        }

        return Enumerable.Empty();
    }

    public async Task RevokeUserConsentAsync(string clientId)
    {
        var user = await _userSession.GetUserAsync();
        if (user != null)
        {
            var subject = user.GetSubjectId();
            await _grants.RemoveAllGrantsAsync(subject, clientId);
        }
    }

    public async Task RevokeTokensForCurrentSessionAsync()
    {
        var user = await _userSession.GetUserAsync();
        if (user != null)
        {
            var subject = user.GetSubjectId();
            var sessionId = await _userSession.GetSessionIdAsync();
            await _grants.RemoveAllGrantsAsync(subject, sessionId: sessionId);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultJwtRequestUriHttpClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default JwtRequest client
/// 
public class DefaultJwtRequestUriHttpClient : IJwtRequestUriHttpClient
{
    private readonly HttpClient _client;
    private readonly IdentityServerOptions _options;
    private readonly ILogger _logger;

    /// 
    /// ctor
    /// 
    /// An HTTP client
    /// The options.
    /// The logger factory
    public DefaultJwtRequestUriHttpClient(HttpClient client, IdentityServerOptions options, ILoggerFactory loggerFactory)
    {
        _client = client;
        _options = options;
        _logger = loggerFactory.CreateLogger();
    }


    /// 
    public async Task GetJwtAsync(string url, Client client)
    {
        var req = new HttpRequestMessage(HttpMethod.Get, url);
        req.Properties.Add(IdentityServerConstants.JwtRequestClientKey, client);

        var response = await _client.SendAsync(req);
        if (response.StatusCode == System.Net.HttpStatusCode.OK)
        {
            if (_options.StrictJarValidation)
            {
                if (!string.Equals(response.Content.Headers.ContentType.MediaType,
                    $"application/{JwtClaimTypes.JwtTypes.AuthorizationRequest}", StringComparison.Ordinal))
                {
                    _logger.LogError("Invalid content type {type} from jwt url {url}", response.Content.Headers.ContentType.MediaType, url);
                    return null;
                }
            }

            _logger.LogDebug("Success http response from jwt url {url}", url);
            
            var json = await response.Content.ReadAsStringAsync();
            return json;
        }
            
        _logger.LogError("Invalid http status code {status} from jwt url {url}", response.StatusCode, url);
        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultKeyMaterialService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Services;

/// 
/// The default key material service
/// 
/// 
public class DefaultKeyMaterialService : IKeyMaterialService
{
    private readonly IEnumerable _signingCredentialStores;
    private readonly IEnumerable _validationKeysStores;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The validation keys stores.
    /// The signing credential store.
    public DefaultKeyMaterialService(IEnumerable validationKeysStores, IEnumerable signingCredentialStores)
    {
        _signingCredentialStores = signingCredentialStores;
        _validationKeysStores = validationKeysStores;
    }

    /// 
    public async Task GetSigningCredentialsAsync(IEnumerable allowedAlgorithms = null)
    {
        if (_signingCredentialStores.Any())
        {
            if (allowedAlgorithms.EnumerableIsNullOrEmpty())
            {
                return await _signingCredentialStores.First().GetSigningCredentialsAsync();
            }

            var credential = (await GetAllSigningCredentialsAsync()).FirstOrDefault(c => allowedAlgorithms.Contains(c.Algorithm));
            if (credential is null)
            {
                throw new InvalidOperationException($"No signing credential for algorithms ({allowedAlgorithms.ToSpaceSeparatedString()}) registered.");
            }

            return credential;
        }

        return null;
    }

    /// 
    public async Task> GetAllSigningCredentialsAsync()
    {
        var credentials = new List();

        foreach (var store in _signingCredentialStores)
        {
            credentials.Add(await store.GetSigningCredentialsAsync());
        }

        return credentials;
    }

    /// 
    public async Task> GetValidationKeysAsync()
    {
        var keys = new List();

        foreach (var store in _validationKeysStores)
        {
            keys.AddRange(await store.GetValidationKeysAsync());
        }

        return keys;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultPersistedGrantService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default persisted grant service
/// 
public class DefaultPersistedGrantService : IPersistedGrantService
{
    private readonly ILogger _logger;
    private readonly IPersistedGrantStore _store;
    private readonly IPersistentGrantSerializer _serializer;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The serializer.
    /// The logger.
    public DefaultPersistedGrantService(IPersistedGrantStore store, 
        IPersistentGrantSerializer serializer,
        ILogger logger)
    {
        _store = store;
        _serializer = serializer;
        _logger = logger;
    }

    /// 
    public async Task> GetAllGrantsAsync(string subjectId)
    {
        if (String.IsNullOrWhiteSpace(subjectId)) throw new ArgumentNullException(nameof(subjectId));
        
        var grants = (await _store.GetAllAsync(new PersistedGrantFilter { SubjectId = subjectId })).ToArray();

        try
        {
            var consents = grants.Where(x => x.Type == IdentityServerConstants.PersistedGrantTypes.UserConsent)
                .Select(x => _serializer.Deserialize(x.Data))
                .Select(x => new Grant 
                {
                    ClientId = x.ClientId,
                    SubjectId = subjectId,
                    Scopes = x.Scopes,
                    CreationTime = x.CreationTime,
                    Expiration = x.Expiration
                });

            var codes = grants.Where(x => x.Type == IdentityServerConstants.PersistedGrantTypes.AuthorizationCode)
                .Select(x => _serializer.Deserialize(x.Data))
                .Select(x => new Grant
                {
                    ClientId = x.ClientId,
                    SubjectId = subjectId,
                    Description = x.Description,
                    Scopes = x.RequestedScopes,
                    CreationTime = x.CreationTime,
                    Expiration = x.CreationTime.AddSeconds(x.Lifetime)
                });

            var refresh = grants.Where(x => x.Type == IdentityServerConstants.PersistedGrantTypes.RefreshToken)
                .Select(x => _serializer.Deserialize(x.Data))
                .Select(x => new Grant
                {
                    ClientId = x.ClientId,
                    SubjectId = subjectId,
                    Description = x.Description,
                    Scopes = x.Scopes,
                    CreationTime = x.CreationTime,
                    Expiration = x.CreationTime.AddSeconds(x.Lifetime)
                });

            var access = grants.Where(x => x.Type == IdentityServerConstants.PersistedGrantTypes.ReferenceToken)
                .Select(x => _serializer.Deserialize(x.Data))
                .Select(x => new Grant
                {
                    ClientId = x.ClientId,
                    SubjectId = subjectId,
                    Description = x.Description,
                    Scopes = x.Scopes,
                    CreationTime = x.CreationTime,
                    Expiration = x.CreationTime.AddSeconds(x.Lifetime)
                });

            consents = Join(consents, codes);
            consents = Join(consents, refresh);
            consents = Join(consents, access);

            return consents.ToArray();
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed processing results from grant store.");
        }

        return Enumerable.Empty();
    }

    private IEnumerable Join(IEnumerable first, IEnumerable second)
    {
        var list = first.ToList();

        foreach(var other in second)
        {
            var match = list.FirstOrDefault(x => x.ClientId == other.ClientId);
            if (match != null)
            {
                match.Scopes = match.Scopes.Union(other.Scopes).Distinct();

                if (match.CreationTime > other.CreationTime)
                {
                    // show the earlier creation time
                    match.CreationTime = other.CreationTime;
                }

                if (match.Expiration == null || other.Expiration == null)
                {
                    // show that there is no expiration to one of the grants
                    match.Expiration = null;
                }
                else if (match.Expiration < other.Expiration)
                {
                    // show the latest expiration
                    match.Expiration = other.Expiration;
                }

                match.Description = match.Description ?? other.Description;
            }
            else
            {
                list.Add(other);
            }
        }

        return list;
    }

    /// 
    public Task RemoveAllGrantsAsync(string subjectId, string clientId = null, string sessionId = null)
    {
        if (String.IsNullOrWhiteSpace(subjectId)) throw new ArgumentNullException(nameof(subjectId));

        return _store.RemoveAllAsync(new PersistedGrantFilter {
            SubjectId = subjectId,
            ClientId = clientId,
            SessionId = sessionId
        });
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default profile service implementation.
/// This implementation sources all claims from the current subject (e.g. the cookie).
/// 
/// 
public class DefaultProfileService : IProfileService
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public DefaultProfileService(ILogger logger)
    {
        Logger = logger;
    }

    /// 
    /// This method is called whenever claims about the user are requested (e.g. during token creation or via the userinfo endpoint)
    /// 
    /// The context.
    /// 
    public virtual Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        context.LogProfileRequest(Logger);
        context.AddRequestedClaims(context.Subject.Claims);
        context.LogIssuedClaims(Logger);

        return Task.CompletedTask;
    }

    /// 
    /// This method gets called whenever identity server needs to determine if the user is valid or active (e.g. if the user's account has been deactivated since they logged in).
    /// (e.g. during token issuance or validation).
    /// 
    /// The context.
    /// 
    public virtual Task IsActiveAsync(IsActiveContext context)
    {
        Logger.LogDebug("IsActive called from: {caller}", context.Caller);

        context.IsActive = true;
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultRefreshTokenService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default refresh token service
/// 
public class DefaultRefreshTokenService : IRefreshTokenService
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The refresh token store
    /// 
    protected IRefreshTokenStore RefreshTokenStore { get; }

    /// 
    /// The profile service
    /// 
    protected IProfileService Profile { get; }

    /// 
    /// The clock
    /// 
    protected ISystemClock Clock { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The refresh token store
    /// 
    /// The clock
    /// The logger
    public DefaultRefreshTokenService(IRefreshTokenStore refreshTokenStore, IProfileService profile,
        ISystemClock clock,
        ILogger logger)
    {
        RefreshTokenStore = refreshTokenStore;
        Profile = profile;
        Clock = clock;

        Logger = logger;
    }

    /// 
    /// Validates a refresh token
    /// 
    /// The token handle.
    /// The client.
    /// 
    public virtual async Task ValidateRefreshTokenAsync(string tokenHandle, Client client)
    {
        var invalidGrant = new TokenValidationResult
        {
            IsError = true, Error = OidcConstants.TokenErrors.InvalidGrant
        };

        Logger.LogTrace("Start refresh token validation");

        /////////////////////////////////////////////
        // check if refresh token is valid
        /////////////////////////////////////////////
        var refreshToken = await RefreshTokenStore.GetRefreshTokenAsync(tokenHandle);
        if (refreshToken == null)
        {
            Logger.LogWarning("Invalid refresh token");
            return invalidGrant;
        }

        /////////////////////////////////////////////
        // check if refresh token has expired
        /////////////////////////////////////////////
        if (refreshToken.CreationTime.HasExceeded(refreshToken.Lifetime, Clock.UtcNow.DateTime))
        {
            Logger.LogWarning("Refresh token has expired.");
            return invalidGrant;
        }
        
        /////////////////////////////////////////////
        // check if client belongs to requested refresh token
        /////////////////////////////////////////////
        if (client.ClientId != refreshToken.ClientId)
        {
            Logger.LogError("{0} tries to refresh token belonging to {1}", client.ClientId, refreshToken.ClientId);
            return invalidGrant;
        }

        /////////////////////////////////////////////
        // check if client still has offline_access scope
        /////////////////////////////////////////////
        if (!client.AllowOfflineAccess)
        {
            Logger.LogError("{clientId} does not have access to offline_access scope anymore", client.ClientId);
            return invalidGrant;
        }
        
        /////////////////////////////////////////////
        // check if refresh token has been consumed
        /////////////////////////////////////////////
        if (refreshToken.ConsumedTime.HasValue)
        {
            if ((await AcceptConsumedTokenAsync(refreshToken)) == false)
            {
                Logger.LogWarning("Rejecting refresh token because it has been consumed already.");
                return invalidGrant;
            }
        }
        
        /////////////////////////////////////////////
        // make sure user is enabled
        /////////////////////////////////////////////
        var isActiveCtx = new IsActiveContext(
            refreshToken.Subject,
            client,
            IdentityServerConstants.ProfileIsActiveCallers.RefreshTokenValidation);

        await Profile.IsActiveAsync(isActiveCtx);

        if (isActiveCtx.IsActive == false)
        {
            Logger.LogError("{subjectId} has been disabled", refreshToken.Subject.GetSubjectId());
            return invalidGrant;
        }
        
        return new TokenValidationResult
        {
            IsError = false, 
            RefreshToken = refreshToken, 
            Client = client
        };
    }

    /// 
    /// Callback to decide if an already consumed token should be accepted.
    /// 
    /// 
    /// 
    protected virtual Task AcceptConsumedTokenAsync(RefreshToken refreshToken)
    {
        // by default we will not accept consumed tokens
        // change the behavior here to implement a time window
        // you can also implement additional revocation logic here
        return Task.FromResult(false);
    }

    /// 
    /// Creates the refresh token.
    /// 
    /// The subject.
    /// The access token.
    /// The client.
    /// 
    /// The refresh token handle
    /// 
    public virtual async Task CreateRefreshTokenAsync(ClaimsPrincipal subject, Token accessToken,
        Client client)
    {
        Logger.LogDebug("Creating refresh token");

        int lifetime;
        if (client.RefreshTokenExpiration == TokenExpiration.Absolute)
        {
            Logger.LogDebug("Setting an absolute lifetime: {absoluteLifetime}",
                client.AbsoluteRefreshTokenLifetime);
            lifetime = client.AbsoluteRefreshTokenLifetime;
        }
        else
        {
            lifetime = client.SlidingRefreshTokenLifetime;
            if (client.AbsoluteRefreshTokenLifetime > 0 && lifetime > client.AbsoluteRefreshTokenLifetime)
            {
                Logger.LogWarning(
                    "Client {clientId}'s configured " + nameof(client.SlidingRefreshTokenLifetime) +
                    " of {slidingLifetime} exceeds its " + nameof(client.AbsoluteRefreshTokenLifetime) +
                    " of {absoluteLifetime}. The refresh_token's sliding lifetime will be capped to the absolute lifetime",
                    client.ClientId, lifetime, client.AbsoluteRefreshTokenLifetime);
                lifetime = client.AbsoluteRefreshTokenLifetime;
            }

            Logger.LogDebug("Setting a sliding lifetime: {slidingLifetime}", lifetime);
        }

        var refreshToken = new RefreshToken
        {
            CreationTime = Clock.UtcNow.UtcDateTime, Lifetime = lifetime, AccessToken = accessToken
        };

        var handle = await RefreshTokenStore.StoreRefreshTokenAsync(refreshToken);
        return handle;
    }

    /// 
    /// Updates the refresh token.
    /// 
    /// The handle.
    /// The refresh token.
    /// The client.
    /// 
    /// The refresh token handle
    /// 
    public virtual async Task UpdateRefreshTokenAsync(string handle, RefreshToken refreshToken,
        Client client)
    {
        Logger.LogDebug("Updating refresh token");

        bool needsCreate = false;
        bool needsUpdate = false;

        if (client.RefreshTokenUsage == TokenUsage.OneTimeOnly)
        {
            Logger.LogDebug("Token usage is one-time only. Setting current handle as consumed, and generating new handle");

            // flag as consumed
            if (refreshToken.ConsumedTime == null)
            {
                refreshToken.ConsumedTime = Clock.UtcNow.UtcDateTime;
                await RefreshTokenStore.UpdateRefreshTokenAsync(handle, refreshToken);
            }

            // create new one
            needsCreate = true;
        }

        if (client.RefreshTokenExpiration == TokenExpiration.Sliding)
        {
            Logger.LogDebug("Refresh token expiration is sliding - extending lifetime");

            // if absolute exp > 0, make sure we don't exceed absolute exp
            // if absolute exp = 0, allow indefinite slide
            var currentLifetime = refreshToken.CreationTime.GetLifetimeInSeconds(Clock.UtcNow.UtcDateTime);
            Logger.LogDebug("Current lifetime: {currentLifetime}", currentLifetime.ToString());

            var newLifetime = currentLifetime + client.SlidingRefreshTokenLifetime;
            Logger.LogDebug("New lifetime: {slidingLifetime}", newLifetime.ToString());

            // zero absolute refresh token lifetime represents unbounded absolute lifetime
            // if absolute lifetime > 0, cap at absolute lifetime
            if (client.AbsoluteRefreshTokenLifetime > 0 && newLifetime > client.AbsoluteRefreshTokenLifetime)
            {
                newLifetime = client.AbsoluteRefreshTokenLifetime;
                Logger.LogDebug("New lifetime exceeds absolute lifetime, capping it to {newLifetime}",
                    newLifetime.ToString());
            }

            refreshToken.Lifetime = newLifetime;
            needsUpdate = true;
        }

        if (needsCreate)
        {
            // set it to null so that we save non-consumed token
            refreshToken.ConsumedTime = null;
            handle = await RefreshTokenStore.StoreRefreshTokenAsync(refreshToken);
            Logger.LogDebug("Created refresh token in store");
        }
        else if (needsUpdate)
        {
            await RefreshTokenStore.UpdateRefreshTokenAsync(handle, refreshToken);
            Logger.LogDebug("Updated refresh token in store");
        }
        else
        {
            Logger.LogDebug("No updates to refresh token done");
        }

        return handle;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultReplayCache.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default implementation of the replay cache using IDistributedCache
/// 
public class DefaultReplayCache : IReplayCache
{
    private const string Prefix = nameof(DefaultReplayCache) + ":";
    
    private readonly IDistributedCache _cache;
    
    /// 
    /// ctor
    /// 
    /// 
    public DefaultReplayCache(IDistributedCache cache)
    {
        _cache = cache;
    }
    
    /// 
    public async Task AddAsync(string purpose, string handle, DateTimeOffset expiration)
    {
        var options = new DistributedCacheEntryOptions
        {
            AbsoluteExpiration = expiration
        };
        
        await _cache.SetAsync(Prefix + purpose + handle, new byte[] { }, options);
    }

    /// 
    public async Task ExistsAsync(string purpose, string handle)
    {
        return (await _cache.GetAsync(Prefix + purpose + handle, default)) != null;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultTokenCreationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Services;

/// 
/// Default token creation service
/// 
public class DefaultTokenCreationService : ITokenCreationService
{
    /// 
    /// The key service
    /// 
    protected readonly IKeyMaterialService Keys;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    ///  The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The keys.
    /// The options.
    /// The logger.
    public DefaultTokenCreationService(
        ISystemClock clock,
        IKeyMaterialService keys,
        IdentityServerOptions options,
        ILogger logger)
    {
        Clock = clock;
        Keys = keys;
        Options = options;
        Logger = logger;
    }

    /// 
    /// Creates the token.
    /// 
    /// The token.
    /// 
    /// A protected and serialized security token
    /// 
    public virtual async Task CreateTokenAsync(Token token)
    {
        var header = await CreateHeaderAsync(token);
        var payload = await CreatePayloadAsync(token);

        return await CreateJwtAsync(new JwtSecurityToken(header, payload));
    }

    /// 
    /// Creates the JWT header
    /// 
    /// The token.
    /// The JWT header
    protected virtual async Task CreateHeaderAsync(Token token)
    {
        var credential = await Keys.GetSigningCredentialsAsync(token.AllowedSigningAlgorithms);

        if (credential == null)
        {
            throw new InvalidOperationException("No signing credential is configured. Can't create JWT token");
        }

        var header = new JwtHeader(credential);

        // emit x5t claim for backwards compatibility with v4 of MS JWT library
        if (credential.Key is X509SecurityKey x509Key)
        {
            var cert = x509Key.Certificate;
            if (Clock.UtcNow.UtcDateTime > cert.NotAfter)
            {
                Logger.LogWarning("Certificate {subjectName} has expired on {expiration}", cert.Subject, cert.NotAfter.ToString(CultureInfo.InvariantCulture));
            }

            header["x5t"] = Base64Url.Encode(cert.GetCertHash());
        }

        if (token.Type == TokenTypes.AccessToken)
        {
            if (Options.AccessTokenJwtType.IsPresent())
            {
                header["typ"] = Options.AccessTokenJwtType;
            }
        }

        return header;
    }

    /// 
    /// Creates the JWT payload
    /// 
    /// The token.
    /// The JWT payload
    protected virtual Task CreatePayloadAsync(Token token)
    {
        var payload = token.CreateJwtPayload(Clock, Options, Logger);
        return Task.FromResult(payload);
    }

    /// 
    /// Applies the signature to the JWT
    /// 
    /// The JWT object.
    /// The signed JWT
    protected virtual Task CreateJwtAsync(JwtSecurityToken jwt)
    {
        var handler = new JwtSecurityTokenHandler();
        return Task.FromResult(handler.WriteToken(jwt));
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultTokenService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default token service
/// 
public class DefaultTokenService : ITokenService
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The HTTP context accessor
    /// 
    protected readonly IHttpContextAccessor ContextAccessor;

    /// 
    /// The claims provider
    /// 
    protected readonly IClaimsService ClaimsProvider;

    /// 
    /// The reference token store
    /// 
    protected readonly IReferenceTokenStore ReferenceTokenStore;

    /// 
    /// The signing service
    /// 
    protected readonly ITokenCreationService CreationService;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The key material service
    /// 
    protected readonly IKeyMaterialService KeyMaterialService;

    /// 
    /// The IdentityServer options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The claims provider.
    /// The reference token store.
    /// The signing service.
    /// The HTTP context accessor.
    /// The clock.
    /// 
    /// The IdentityServer options
    /// The logger.
    public DefaultTokenService(
        IClaimsService claimsProvider,
        IReferenceTokenStore referenceTokenStore,
        ITokenCreationService creationService,
        IHttpContextAccessor contextAccessor,
        ISystemClock clock,
        IKeyMaterialService keyMaterialService,
        IdentityServerOptions options,
        ILogger logger)
    {
        ContextAccessor = contextAccessor;
        ClaimsProvider = claimsProvider;
        ReferenceTokenStore = referenceTokenStore;
        CreationService = creationService;
        Clock = clock;
        KeyMaterialService = keyMaterialService;
        Options = options;
        Logger = logger;
    }

    /// 
    /// Creates an identity token.
    /// 
    /// The token creation request.
    /// 
    /// An identity token
    /// 
    public virtual async Task CreateIdentityTokenAsync(TokenCreationRequest request)
    {
        Logger.LogTrace("Creating identity token");
        request.Validate();

        // todo: Dom, add a test for this. validate the at and c hashes are correct for the id_token when the client's alg doesn't match the server default.
        var credential = await KeyMaterialService.GetSigningCredentialsAsync(request.ValidatedRequest.Client.AllowedIdentityTokenSigningAlgorithms);
        if (credential == null)
        {
            throw new InvalidOperationException("No signing credential is configured.");
        }

        var signingAlgorithm = credential.Algorithm;

        // host provided claims
        var claims = new List();

        // if nonce was sent, must be mirrored in id token
        if (request.Nonce.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.Nonce, request.Nonce));
        }

        // add iat claim
        claims.Add(new Claim(JwtClaimTypes.IssuedAt, Clock.UtcNow.ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64));

        // add at_hash claim
        if (request.AccessTokenToHash.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.AccessTokenHash, CryptoHelper.CreateHashClaimValue(request.AccessTokenToHash, signingAlgorithm)));
        }

        // add c_hash claim
        if (request.AuthorizationCodeToHash.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.AuthorizationCodeHash, CryptoHelper.CreateHashClaimValue(request.AuthorizationCodeToHash, signingAlgorithm)));
        }

        // add s_hash claim
        if (request.StateHash.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.StateHash, request.StateHash));
        }

        // add sid if present
        if (request.ValidatedRequest.SessionId.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.SessionId, request.ValidatedRequest.SessionId));
        }

        claims.AddRange(await ClaimsProvider.GetIdentityTokenClaimsAsync(
            request.Subject,
            request.ValidatedResources,
            request.IncludeAllIdentityClaims,
            request.ValidatedRequest));

        var issuer = ContextAccessor.HttpContext.GetIdentityServerIssuerUri();

        var token = new Token(OidcConstants.TokenTypes.IdentityToken)
        {
            CreationTime = Clock.UtcNow.UtcDateTime,
            Audiences = { request.ValidatedRequest.Client.ClientId },
            Issuer = issuer,
            Lifetime = request.ValidatedRequest.Client.IdentityTokenLifetime,
            Claims = claims.Distinct(new ClaimComparer()).ToList(),
            ClientId = request.ValidatedRequest.Client.ClientId,
            AccessTokenType = request.ValidatedRequest.AccessTokenType,
            AllowedSigningAlgorithms = request.ValidatedRequest.Client.AllowedIdentityTokenSigningAlgorithms
        };

        return token;
    }

    /// 
    /// Creates an access token.
    /// 
    /// The token creation request.
    /// 
    /// An access token
    /// 
    public virtual async Task CreateAccessTokenAsync(TokenCreationRequest request)
    {
        Logger.LogTrace("Creating access token");
        request.Validate();

        var claims = new List();
        claims.AddRange(await ClaimsProvider.GetAccessTokenClaimsAsync(
            request.Subject,
            request.ValidatedResources,
            request.ValidatedRequest));

        if (request.ValidatedRequest.Client.IncludeJwtId)
        {
            claims.Add(new Claim(JwtClaimTypes.JwtId, CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex)));
        }

        if (request.ValidatedRequest.SessionId.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.SessionId, request.ValidatedRequest.SessionId));
        }
        
        // iat claim as required by JWT profile
        claims.Add(new Claim(JwtClaimTypes.IssuedAt, Clock.UtcNow.ToUnixTimeSeconds().ToString(),
            ClaimValueTypes.Integer64));

        var issuer = ContextAccessor.HttpContext.GetIdentityServerIssuerUri();
        var token = new Token(OidcConstants.TokenTypes.AccessToken)
        {
            CreationTime = Clock.UtcNow.UtcDateTime,
            Issuer = issuer,
            Lifetime = request.ValidatedRequest.AccessTokenLifetime,
            Claims = claims.Distinct(new ClaimComparer()).ToList(),
            ClientId = request.ValidatedRequest.Client.ClientId,
            Description = request.Description,
            AccessTokenType = request.ValidatedRequest.AccessTokenType,
            AllowedSigningAlgorithms = request.ValidatedResources.Resources.ApiResources.FindMatchingSigningAlgorithms()
        };

        // add aud based on ApiResources in the validated request
        foreach (var aud in request.ValidatedResources.Resources.ApiResources.Select(x => x.Name).Distinct())
        {
            token.Audiences.Add(aud);
        }

        if (Options.EmitStaticAudienceClaim)
        {
            token.Audiences.Add(string.Format(IdentityServerConstants.AccessTokenAudience, issuer.EnsureTrailingSlash()));
        }

        // add cnf if present
        if (request.ValidatedRequest.Confirmation.IsPresent())
        {
            token.Confirmation = request.ValidatedRequest.Confirmation;
        }
        else
        {
            if (Options.MutualTls.AlwaysEmitConfirmationClaim)
            {
                var clientCertificate = await ContextAccessor.HttpContext.Connection.GetClientCertificateAsync();
                if (clientCertificate != null)
                {
                    token.Confirmation = clientCertificate.CreateThumbprintCnf();
                }
            }
        }
        
        return token;
    }

    /// 
    /// Creates a serialized and protected security token.
    /// 
    /// The token.
    /// 
    /// A security token in serialized form
    /// 
    /// Invalid token type.
    public virtual async Task CreateSecurityTokenAsync(Token token)
    {
        string tokenResult;

        if (token.Type == OidcConstants.TokenTypes.AccessToken)
        {
            if (token.AccessTokenType == AccessTokenType.Jwt)
            {
                Logger.LogTrace("Creating JWT access token");

                tokenResult = await CreationService.CreateTokenAsync(token);
            }
            else
            {
                Logger.LogTrace("Creating reference access token");

                var handle = await ReferenceTokenStore.StoreReferenceTokenAsync(token);

                tokenResult = handle;
            }
        }
        else if (token.Type == OidcConstants.TokenTypes.IdentityToken)
        {
            Logger.LogTrace("Creating JWT identity token");

            tokenResult = await CreationService.CreateTokenAsync(token);
        }
        else
        {
            throw new InvalidOperationException("Invalid token type.");
        }

        return tokenResult;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultUserCodeService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default user code service implementation.
/// 
/// 
public class DefaultUserCodeService : IUserCodeService
{
    private readonly IEnumerable _generators;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The generators.
    /// generators
    public DefaultUserCodeService(IEnumerable generators)
    {
        _generators = generators ?? throw new ArgumentNullException(nameof(generators));
    }

    /// 
    /// Gets the user code generator.
    /// 
    /// Type of user code.
    /// 
    public Task GetGenerator(string userCodeType) =>
        Task.FromResult(_generators.FirstOrDefault(x => x.UserCodeType == userCodeType));
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DefaultUserSession.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Cookie-based session implementation
/// 
/// 
public class DefaultUserSession : IUserSession
{
    /// 
    /// The HTTP context accessor
    /// 
    protected readonly IHttpContextAccessor HttpContextAccessor;

    /// 
    /// The handlers
    /// 
    protected readonly IAuthenticationHandlerProvider Handlers;

    /// 
    /// The options
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// The clock
    /// 
    protected readonly ISystemClock Clock;

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Gets the HTTP context.
    /// 
    /// 
    /// The HTTP context.
    /// 
    protected HttpContext HttpContext => HttpContextAccessor.HttpContext;

    /// 
    /// Gets the name of the check session cookie.
    /// 
    /// 
    /// The name of the check session cookie.
    /// 
    protected string CheckSessionCookieName => Options.Authentication.CheckSessionCookieName;
    
    /// 
    /// Gets the domain of the check session cookie.
    /// 
    /// 
    /// The domain of the check session cookie.
    /// 
    protected string CheckSessionCookieDomain => Options.Authentication.CheckSessionCookieDomain;

    /// 
    /// Gets the SameSite mode of the check session cookie.
    /// 
    /// 
    /// The SameSite mode of the check session cookie.
    /// 
    protected SameSiteMode CheckSessionCookieSameSiteMode => Options.Authentication.CheckSessionCookieSameSiteMode;

    /// 
    /// The principal
    /// 
    protected ClaimsPrincipal Principal;

    /// 
    /// The properties
    /// 
    protected AuthenticationProperties Properties;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The HTTP context accessor.
    /// The handlers.
    /// The options.
    /// The clock.
    /// The logger.
    public DefaultUserSession(
        IHttpContextAccessor httpContextAccessor,
        IAuthenticationHandlerProvider handlers,
        IdentityServerOptions options,
        ISystemClock clock,
        ILogger logger)
    {
        HttpContextAccessor = httpContextAccessor;
        Handlers = handlers;
        Options = options;
        Clock = clock;
        Logger = logger;
    }

    // we need this helper (and can't call HttpContext.AuthenticateAsync) so we don't run
    // claims transformation when we get the principal. this also ensures that we don't
    // re-issue a cookie that includes the claims from claims transformation.
    //
    // also, by caching the _principal/_properties it allows someone to issue a new
    // cookie (via HttpContext.SignInAsync) and we'll use those new values, rather than
    // just reading the incoming cookie
    //
    // this design requires this to be in DI as scoped

    /// 
    /// Authenticates the authentication cookie for the current HTTP request and caches the user and properties results.
    /// 
    protected virtual async Task AuthenticateAsync()
    {
        if (Principal == null || Properties == null)
        {
            var scheme = await HttpContext.GetCookieAuthenticationSchemeAsync();

            var handler = await Handlers.GetHandlerAsync(HttpContext, scheme);
            if (handler == null)
            {
                throw new InvalidOperationException($"No authentication handler is configured to authenticate for the scheme: {scheme}");
            }

            var result = await handler.AuthenticateAsync();
            if (result != null && result.Succeeded)
            {
                Principal = result.Principal;
                Properties = result.Properties;
            }
        }
    }

    /// 
    /// Creates a session identifier for the signin context and issues the session id cookie.
    /// 
    /// 
    /// 
    /// 
    /// 
    /// principal
    /// or
    /// properties
    /// 
    public virtual async Task CreateSessionIdAsync(ClaimsPrincipal principal, AuthenticationProperties properties)
    {
        if (principal == null) throw new ArgumentNullException(nameof(principal));
        if (properties == null) throw new ArgumentNullException(nameof(properties));

        var currentSubjectId = (await GetUserAsync())?.GetSubjectId();
        var newSubjectId = principal.GetSubjectId();

        if (properties.GetSessionId() == null || currentSubjectId != newSubjectId)
        {
            properties.SetSessionId(CryptoRandom.CreateUniqueId(16, CryptoRandom.OutputFormat.Hex));
        }

        var sid = properties.GetSessionId();
        IssueSessionIdCookie(sid);

        Principal = principal;
        Properties = properties;

        return sid;
    }

    /// 
    /// Gets the current authenticated user.
    /// 
    /// 
    public virtual async Task GetUserAsync()
    {
        await AuthenticateAsync();

        return Principal;
    }

    /// 
    /// Gets the current session identifier.
    /// 
    /// 
    public virtual async Task GetSessionIdAsync()
    {
        await AuthenticateAsync();

        return Properties?.GetSessionId();
    }

    /// 
    /// Ensures the session identifier cookie asynchronous.
    /// 
    /// 
    public virtual async Task EnsureSessionIdCookieAsync()
    {
        var sid = await GetSessionIdAsync();
        if (sid != null)
        {
            IssueSessionIdCookie(sid);
        }
        else
        {
            await RemoveSessionIdCookieAsync();
        }
    }

    /// 
    /// Removes the session identifier cookie.
    /// 
    /// 
    public virtual Task RemoveSessionIdCookieAsync()
    {
        if (HttpContext.Request.Cookies.ContainsKey(CheckSessionCookieName))
        {
            // only remove it if we have it in the request
            var options = CreateSessionIdCookieOptions();
            options.Expires = Clock.UtcNow.UtcDateTime.AddYears(-1);

            HttpContext.Response.Cookies.Append(CheckSessionCookieName, ".", options);
        }

        return Task.CompletedTask;
    }

    /// 
    /// Creates the options for the session cookie.
    /// 
    public virtual CookieOptions CreateSessionIdCookieOptions()
    {
        var secure = HttpContext.Request.IsHttps;
        var path = HttpContext.GetIdentityServerBasePath().CleanUrlPath();

        var options = new CookieOptions
        {
            HttpOnly = false,
            Secure = secure,
            Path = path,
            IsEssential = true,
            Domain = CheckSessionCookieDomain,
            SameSite = CheckSessionCookieSameSiteMode
        };

        return options;
    }

    /// 
    /// Issues the cookie that contains the session id.
    /// 
    /// 
    public virtual void IssueSessionIdCookie(string sid)
    {
        if (Options.Endpoints.EnableCheckSessionEndpoint)
        {
            if (HttpContext.Request.Cookies[CheckSessionCookieName] != sid)
            {
                HttpContext.Response.Cookies.Append(
                    Options.Authentication.CheckSessionCookieName,
                    sid,
                    CreateSessionIdCookieOptions());
            }
        }
    }

    /// 
    /// Adds a client to the list of clients the user has signed into during their session.
    /// 
    /// The client identifier.
    /// 
    /// clientId
    public virtual async Task AddClientIdAsync(string clientId)
    {
        if (clientId == null) throw new ArgumentNullException(nameof(clientId));

        await AuthenticateAsync();
        if (Properties != null)
        {
            var clientIds = Properties.GetClientList();
            if (!clientIds.Contains(clientId))
            {
                Properties.AddClientId(clientId);
                await UpdateSessionCookie();
            }
        }
    }

    /// 
    /// Gets the list of clients the user has signed into during their session.
    /// 
    /// 
    public virtual async Task> GetClientListAsync()
    {
        await AuthenticateAsync();

        if (Properties != null)
        {
            try
            {
                return Properties.GetClientList();
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, "Error decoding client list");
                // clear so we don't keep failing
                Properties.RemoveClientList();
                await UpdateSessionCookie();
            }
        }

        return Enumerable.Empty();
    }

    // client list helpers
    private async Task UpdateSessionCookie()
    {
        await AuthenticateAsync();

        if (Principal == null || Properties == null) throw new InvalidOperationException("User is not currently authenticated");

        var scheme = await HttpContext.GetCookieAuthenticationSchemeAsync();
        await HttpContext.SignInAsync(scheme, Principal, Properties);
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/DistributedDeviceFlowThrottlingService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// The default device flow throttling service using IDistributedCache.
/// 
/// 
public class DistributedDeviceFlowThrottlingService : IDeviceFlowThrottlingService
{
    private readonly IDistributedCache _cache;
    private readonly ISystemClock _clock;
    private readonly IdentityServerOptions _options;

    private const string KeyPrefix = "devicecode_";

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The cache.
    /// The clock.
    /// The options.
    public DistributedDeviceFlowThrottlingService(
        IDistributedCache cache,
        ISystemClock clock,
        IdentityServerOptions options)
    {
        _cache = cache;
        _clock = clock;
        _options = options;
    }

    /// 
    /// Decides if the requesting client and device code needs to slow down.
    /// 
    /// The device code.
    /// The device code details.
    /// 
    /// deviceCode
    public async Task ShouldSlowDown(string deviceCode, DeviceCode details)
    {
        if (deviceCode == null) throw new ArgumentNullException(nameof(deviceCode));
        
        var key = KeyPrefix + deviceCode;
        var options = new DistributedCacheEntryOptions {AbsoluteExpiration = _clock.UtcNow.AddSeconds(details.Lifetime)};

        var lastSeenAsString = await _cache.GetStringAsync(key);

        // record new
        if (lastSeenAsString == null)
        {
            await _cache.SetStringAsync(key, _clock.UtcNow.ToString("O"), options);
            return false;
        }

        // check interval
        if (DateTime.TryParse(lastSeenAsString, out var lastSeen))
        {
            if (_clock.UtcNow < lastSeen.AddSeconds(_options.DeviceFlow.Interval))
            {
                await _cache.SetStringAsync(key, _clock.UtcNow.ToString("O"), options);
                return true;
            }
        }

        // store current and continue
        await _cache.SetStringAsync(key, _clock.UtcNow.ToString("O"), options);
        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/LogoutNotificationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Default implementation of logout notification service.
/// 
public class LogoutNotificationService : ILogoutNotificationService
{
    private readonly IClientStore _clientStore;
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly ILogger _logger;


    /// 
    /// Ctor.
    /// 
    public LogoutNotificationService(
        IClientStore clientStore,
        IHttpContextAccessor httpContextAccessor, 
        ILogger logger)
    {
        _clientStore = clientStore;
        _httpContextAccessor = httpContextAccessor;
        _logger = logger;
    }

    /// 
    public async Task> GetFrontChannelLogoutNotificationsUrlsAsync(LogoutNotificationContext context)
    {
        var frontChannelUrls = new List();
        foreach (var clientId in context.ClientIds)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(clientId);
            if (client != null)
            {
                if (client.FrontChannelLogoutUri.IsPresent())
                {
                    var url = client.FrontChannelLogoutUri;

                    // add session id if required
                    if (client.ProtocolType == IdentityServerConstants.ProtocolTypes.OpenIdConnect)
                    {
                        if (client.FrontChannelLogoutSessionRequired)
                        {
                            url = url.AddQueryString(OidcConstants.EndSessionRequest.Sid, context.SessionId);
                            url = url.AddQueryString(OidcConstants.EndSessionRequest.Issuer, _httpContextAccessor.HttpContext.GetIdentityServerIssuerUri());
                        }
                    }
                    else if (client.ProtocolType == IdentityServerConstants.ProtocolTypes.WsFederation)
                    {
                        url = url.AddQueryString(Constants.WsFedSignOut.LogoutUriParameterName, Constants.WsFedSignOut.LogoutUriParameterValue);
                    }

                    frontChannelUrls.Add(url);
                }
            }
        }

        if (frontChannelUrls.Any())
        {
            var msg = frontChannelUrls.Aggregate((x, y) => x + ", " + y);
            _logger.LogDebug("Client front-channel logout URLs: {0}", Ioc.Sanitizer.Log.Sanitize(msg));
        }
        else
        {
            _logger.LogDebug("No client front-channel logout URLs");
        }

        return frontChannelUrls;
    }

    /// 
    public async Task> GetBackChannelLogoutNotificationsAsync(LogoutNotificationContext context)
    {
        var backChannelLogouts = new List();
        foreach (var clientId in context.ClientIds)
        {
            var client = await _clientStore.FindEnabledClientByIdAsync(clientId);
            if (client != null)
            {
                if (client.BackChannelLogoutUri.IsPresent())
                {
                    var back = new BackChannelLogoutRequest
                    {
                        ClientId = clientId,
                        LogoutUri = client.BackChannelLogoutUri,
                        SubjectId = context.SubjectId,
                        SessionId = context.SessionId,
                        SessionIdRequired = client.BackChannelLogoutSessionRequired
                    };

                    backChannelLogouts.Add(back);
                }
            }
        }

        if (backChannelLogouts.Any())
        {
            var msg = backChannelLogouts.Select(x => x.LogoutUri).Aggregate((x, y) => x + ", " + y);
            _logger.LogDebug("Client back-channel logout URLs: {0}", msg);
        }
        else
        {
            _logger.LogDebug("No client back-channel logout URLs");
        }

        return backChannelLogouts;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/NumericUserCodeGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// User code generator using 9 digit number
/// 
/// 
public class NumericUserCodeGenerator : IUserCodeGenerator
{
    /// 
    /// Gets the type of the user code.
    /// 
    /// 
    /// The type of the user code.
    /// 
    public string UserCodeType => IdentityServerConstants.UserCodeTypes.Numeric;

    /// 
    /// Gets the retry limit.
    /// 
    /// 
    /// The retry limit for getting a unique value.
    /// 
    public int RetryLimit => 5;

    /// 
    /// Generates the user code.
    /// 
    /// 
    public Task GenerateAsync()
    {
        var next = Next(100000000, 999999999);
        return Task.FromResult(next.ToString());
    }

    private int Next(int minValue, int maxValue)
    {
        if (minValue > maxValue) throw new ArgumentOutOfRangeException(nameof(minValue));
        if (minValue == maxValue) return minValue;
        long diff = maxValue - minValue;

        var uint32Buffer = new byte[8];

        using (var rng = new RNGCryptoServiceProvider())
        {
            while (true)
            {
                rng.GetBytes(uint32Buffer);
                var rand = BitConverter.ToUInt32(uint32Buffer, 0);

                const long max = 1 + (long)uint.MaxValue;
                var remainder = max % diff;
                if (rand < max - remainder)
                {
                    return (int)(minValue + rand % diff);
                }
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/OidcReturnUrlParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

internal class OidcReturnUrlParser : IReturnUrlParser
{
    private readonly IAuthorizeRequestValidator _validator;
    private readonly IUserSession _userSession;
    private readonly ILogger _logger;
    private readonly IAuthorizationParametersMessageStore _authorizationParametersMessageStore;

    public OidcReturnUrlParser(
        IAuthorizeRequestValidator validator,
        IUserSession userSession,
        ILogger logger,
        IAuthorizationParametersMessageStore authorizationParametersMessageStore = null)
    {
        _validator = validator;
        _userSession = userSession;
        _logger = logger;
        _authorizationParametersMessageStore = authorizationParametersMessageStore;
    }

    public async Task ParseAsync(string returnUrl)
    {
        if (IsValidReturnUrl(returnUrl))
        {
            var parameters = returnUrl.ReadQueryStringAsNameValueCollection();
            if (_authorizationParametersMessageStore != null)
            {
                var messageStoreId = parameters[Constants.AuthorizationParamsStore.MessageStoreIdParameterName];
                var entry = await _authorizationParametersMessageStore.ReadAsync(messageStoreId);
                parameters = entry?.Data.FromFullDictionary() ?? new NameValueCollection();
            }

            var user = await _userSession.GetUserAsync();
            var result = await _validator.ValidateAsync(parameters, user);
            if (!result.IsError)
            {
                _logger.LogTrace("AuthorizationRequest being returned");
                return new AuthorizationRequest(result.ValidatedRequest);
            }
        }

        _logger.LogTrace("No AuthorizationRequest being returned");
        return null;
    }

    public bool IsValidReturnUrl(string returnUrl)
    {
        if (returnUrl.IsLocalUrl())
        {
            var index = returnUrl.IndexOf('?');
            if (index >= 0)
            {
                returnUrl = returnUrl.Substring(0, index);
            }

            if (returnUrl.EndsWith(Constants.ProtocolRoutePaths.Authorize, StringComparison.Ordinal) ||
                returnUrl.EndsWith(Constants.ProtocolRoutePaths.AuthorizeCallback, StringComparison.Ordinal))
            {
                _logger.LogTrace("returnUrl is valid");
                return true;
            }
        }

        _logger.LogTrace("returnUrl is not valid");
        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/Default/ReturnUrlParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Parses a return URL using all registered URL parsers
/// 
public class ReturnUrlParser
{
    private readonly IEnumerable _parsers;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The parsers.
    public ReturnUrlParser(IEnumerable parsers)
    {
        _parsers = parsers;
    }

    /// 
    /// Parses the return URL.
    /// 
    /// The return URL.
    /// 
    public virtual async Task ParseAsync(string returnUrl)
    {
        foreach (var parser in _parsers)
        {
            var result = await parser.ParseAsync(returnUrl);
            if (result != null)
            {
                return result;
            }
        }

        return null;            
    }

    /// 
    /// Determines whether a return URL is valid.
    /// 
    /// The return URL.
    /// 
    ///   true if the return URL is valid; otherwise, false.
    /// 
    public virtual bool IsValidReturnUrl(string returnUrl)
    {
        foreach (var parser in _parsers)
        {
            if (parser.IsValidReturnUrl(returnUrl))
            {
                return true;
            }
        }

        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Services/IBackChannelLogoutHttpClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Models making HTTP requests for back-channel logout notification.
/// 
public interface IBackChannelLogoutHttpClient
{
    /// 
    /// Performs HTTP POST.
    /// 
    /// 
    /// 
    /// 
    Task PostAsync(string url, Dictionary payload);
}


================================================
FILE: src/IdentityServer8/src/Services/IBackChannelLogoutService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// The service responsible for performing back-channel logout notification.
/// 
public interface IBackChannelLogoutService
{
    /// 
    /// Performs http back-channel logout notification.
    /// 
    /// The context of the back channel logout notification.
    Task SendLogoutNotificationsAsync(LogoutNotificationContext context);
}




================================================
FILE: src/IdentityServer8/src/Services/ICache.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Abstract interface to model data caching
/// 
/// The data type to be cached
public interface ICache
    where T : class
{
    /// 
    /// Gets the cached data based upon a key index.
    /// 
    /// The key.
    /// The cached item, or null if no item matches the key.
    Task GetAsync(string key);

    /// 
    /// Caches the data based upon a key
    /// 
    /// The key.
    /// The item.
    /// The expiration.
    /// 
    Task SetAsync(string key, T item, TimeSpan expiration);
}


================================================
FILE: src/IdentityServer8/src/Services/IClaimsService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// The claims service is responsible for determining which claims to include in tokens
/// 
public interface IClaimsService
{
    /// 
    /// Returns claims for an identity token
    /// 
    /// The subject
    /// The resources.
    /// Specifies if all claims should be included in the token, or if the userinfo endpoint can be used to retrieve them
    /// The raw request
    /// 
    /// Claims for the identity token
    /// 
    Task> GetIdentityTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resources, bool includeAllIdentityClaims, ValidatedRequest request);

    /// 
    /// Returns claims for an access token.
    /// 
    /// The subject.
    /// The resources.
    /// The raw request.
    /// 
    /// Claims for the access token
    /// 
    Task> GetAccessTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resources, ValidatedRequest request);
}


================================================
FILE: src/IdentityServer8/src/Services/IConsentService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Service to retrieve and update consent.
/// 
public interface IConsentService
{
    /// 
    /// Checks if consent is required.
    /// 
    /// The user.
    /// The client.
    /// The parsed scopes.
    /// 
    /// Boolean if consent is required.
    /// 
    Task RequiresConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes);

    /// 
    /// Updates the consent.
    /// 
    /// The subject.
    /// The client.
    /// The parsed scopes.
    /// 
    Task UpdateConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes);
}


================================================
FILE: src/IdentityServer8/src/Services/IDeviceFlowCodeService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Wrapper service for IDeviceFlowStore.
/// 
public interface IDeviceFlowCodeService
{
    /// 
    /// Stores the device authorization request.
    /// 
    /// The user code.
    /// The data.
    Task StoreDeviceAuthorizationAsync(string userCode, DeviceCode data);

    /// 
    /// Finds device authorization by user code.
    /// 
    /// The user code.
    /// 
    Task FindByUserCodeAsync(string userCode);

    /// 
    /// Finds device authorization by device code.
    /// 
    /// The device code.
    Task FindByDeviceCodeAsync(string deviceCode);

    /// 
    /// Updates device authorization, searching by user code.
    /// 
    /// The user code.
    /// The data.
    Task UpdateByUserCodeAsync(string userCode, DeviceCode data);

    /// 
    /// Removes the device authorization, searching by device code.
    /// 
    /// The device code.
    Task RemoveByDeviceCodeAsync(string deviceCode);
}


================================================
FILE: src/IdentityServer8/src/Services/IDeviceFlowInteractionService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
///  Provide services be used by the user interface to communicate with IdentityServer.
/// 
public interface IDeviceFlowInteractionService
{
    /// 
    /// Gets the authorization context asynchronous.
    /// 
    /// The user code.
    /// 
    Task GetAuthorizationContextAsync(string userCode);

    /// 
    /// Handles the request asynchronous.
    /// 
    /// The user code.
    /// The consent.
    /// 
    Task HandleRequestAsync(string userCode, ConsentResponse consent);
}


================================================
FILE: src/IdentityServer8/src/Services/IDeviceFlowThrottlingService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// The device flow throttling service.
/// 
public interface IDeviceFlowThrottlingService
{
    /// 
    /// Decides if the requesting client and device code needs to slow down.
    /// 
    /// The device code.
    /// The device code details.
    /// 
    Task ShouldSlowDown(string deviceCode, DeviceCode details);
}


================================================
FILE: src/IdentityServer8/src/Services/IEventService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Interface for the event service
/// 
public interface IEventService
{
    /// 
    /// Raises the specified event.
    /// 
    /// The event.
    Task RaiseAsync(Event evt);

    /// 
    /// Indicates if the type of event will be persisted.
    /// 
    bool CanRaiseEventType(EventTypes evtType);
}


================================================
FILE: src/IdentityServer8/src/Services/IEventSink.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Models persistence of events
/// 
public interface IEventSink
{
    /// 
    /// Raises the specified event.
    /// 
    /// The event.
    Task PersistAsync(Event evt);
}


================================================
FILE: src/IdentityServer8/src/Services/IHandleGenerationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Interface for the handle generation service
/// 
public interface IHandleGenerationService
{
    /// 
    /// Generates a handle.
    /// 
    /// The length.
    /// 
    Task GenerateAsync(int length = 32);
}


================================================
FILE: src/IdentityServer8/src/Services/IIdentityServerInteractionService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
///  Provide services be used by the user interface to communicate with IdentityServer.
/// 
public interface IIdentityServerInteractionService
{
    /// 
    /// Gets the authorization context.
    /// 
    /// The return URL.
    Task GetAuthorizationContextAsync(string returnUrl);

    /// 
    /// Indicates if the returnUrl is a valid URL for redirect after login or consent.
    /// 
    /// The return URL.
    bool IsValidReturnUrl(string returnUrl);

    /// 
    /// Gets the error context.
    /// 
    /// The error identifier.
    Task GetErrorContextAsync(string errorId);

    /// 
    /// Gets the logout context.
    /// 
    /// The logout identifier.
    Task GetLogoutContextAsync(string logoutId);

    /// 
    /// Used to create a logoutId if there is not one presently.
    /// 
    /// 
    Task CreateLogoutContextAsync();

    /// 
    /// Informs IdentityServer of the user's consent.
    /// 
    /// The request.
    /// The consent.
    /// The subject.
    Task GrantConsentAsync(AuthorizationRequest request, ConsentResponse consent, string subject = null);

    /// 
    /// Triggers error back to the client for the authorization request.
    /// This API is a simpler helper on top of GrantConsentAsync.
    /// 
    /// The request.
    /// 
    /// 
    Task DenyAuthorizationAsync(AuthorizationRequest request, AuthorizationError error, string errorDescription = null);

    /// 
    /// Returns a collection representing all of the user's consents and grants.
    /// 
    Task> GetAllUserGrantsAsync();

    /// 
    /// Revokes all a user's consents and grants for a client.
    /// 
    /// The client identifier.
    Task RevokeUserConsentAsync(string clientId);

    /// 
    /// Revokes all of a user's consents and grants for clients the user has signed into during their current session.
    /// 
    Task RevokeTokensForCurrentSessionAsync();
}


================================================
FILE: src/IdentityServer8/src/Services/IJwtRequestUriHttpClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Models making HTTP requests for JWTs from the authorize endpoint.
/// 
public interface IJwtRequestUriHttpClient
{
    /// 
    /// Gets a JWT from the url.
    /// 
    /// 
    /// 
    /// 
    Task GetJwtAsync(string url, Client client);
}


================================================
FILE: src/IdentityServer8/src/Services/IKeyMaterialService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Services;

/// 
/// Interface for the key material service
/// 
public interface IKeyMaterialService
{
    /// 
    /// Gets all validation keys.
    /// 
    /// 
    Task> GetValidationKeysAsync();

    /// 
    /// Gets the signing credentials.
    /// 
    /// Collection of algorithms used to filter the server supported algorithms. 
    /// A value of null or empty indicates that the server default should be returned.
    /// 
    Task GetSigningCredentialsAsync(IEnumerable allowedAlgorithms = null);

    /// 
    /// Gets all signing credentials.
    /// 
    /// 
    Task> GetAllSigningCredentialsAsync();
}


================================================
FILE: src/IdentityServer8/src/Services/ILogoutNotificationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Provides features for OIDC signout notifications.
/// 
public interface ILogoutNotificationService
{
    /// 
    /// Builds the URLs needed for front-channel logout notification.
    /// 
    /// The context for the logout notification.
    Task> GetFrontChannelLogoutNotificationsUrlsAsync(LogoutNotificationContext context);

    /// 
    /// Builds the http back-channel logout request data for the collection of clients.
    /// 
    /// The context for the logout notification.
    Task> GetBackChannelLogoutNotificationsAsync(LogoutNotificationContext context);
}

/// 
/// Information necessary to make a back-channel logout request to a client.
/// 
public class BackChannelLogoutRequest
{
    /// 
    /// Gets or sets the client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets the subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the session identifier.
    /// 
    public string SessionId { get; set; }

    /// 
    /// Gets or sets the back channel logout URI.
    /// 
    public string LogoutUri { get; set; }

    /// 
    /// Gets a value indicating whether the session identifier is required.
    /// 
    public bool SessionIdRequired { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Services/IPersistedGrantService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Implements persisted grant logic
/// 
public interface IPersistedGrantService
{
    /// 
    /// Gets all grants for a given subject ID.
    /// 
    /// The subject identifier.
    /// 
    Task> GetAllGrantsAsync(string subjectId);

    /// 
    /// Removes all grants for a given subject id, and optionally client id and session id combination.
    /// 
    /// The subject identifier.
    /// The client identifier (optional).
    /// The sesion id (optional).
    /// 
    Task RemoveAllGrantsAsync(string subjectId, string clientId = null, string sessionId = null);
}


================================================
FILE: src/IdentityServer8/src/Services/IProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// This interface allows IdentityServer to connect to your user and profile store.
/// 
public interface IProfileService
{
    /// 
    /// This method is called whenever claims about the user are requested (e.g. during token creation or via the userinfo endpoint)
    /// 
    /// The context.
    /// 
    Task GetProfileDataAsync(ProfileDataRequestContext context);

    /// 
    /// This method gets called whenever identity server needs to determine if the user is valid or active (e.g. if the user's account has been deactivated since they logged in).
    /// (e.g. during token issuance or validation).
    /// 
    /// The context.
    /// 
    Task IsActiveAsync(IsActiveContext context);
}


================================================
FILE: src/IdentityServer8/src/Services/IRefreshTokenService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Implements refresh token creation and validation
/// 
public interface IRefreshTokenService
{
    /// 
    /// Validates a refresh token.
    /// 
    /// The refresh token.
    /// The client.
    /// 
    Task ValidateRefreshTokenAsync(string token, Client client);
    
    /// 
    /// Creates the refresh token.
    /// 
    /// The subject.
    /// The access token.
    /// The client.
    /// 
    /// The refresh token handle
    /// 
    Task CreateRefreshTokenAsync(ClaimsPrincipal subject, Token accessToken, Client client);

    /// 
    /// Updates the refresh token.
    /// 
    /// The handle.
    /// The refresh token.
    /// The client.
    /// 
    /// The refresh token handle
    /// 
    Task UpdateRefreshTokenAsync(string handle, RefreshToken refreshToken, Client client);
}


================================================
FILE: src/IdentityServer8/src/Services/IReplayCache.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Interface for replay cache implementations
/// 
public interface IReplayCache
{
    /// 
    /// Adds a handle to the cache 
    /// 
    /// 
    /// 
    /// 
    /// 
    Task AddAsync(string purpose, string handle, DateTimeOffset expiration);


    /// 
    /// Checks if a cached handle exists 
    /// 
    /// 
    /// 
    /// 
    Task ExistsAsync(string purpose, string handle);
}


================================================
FILE: src/IdentityServer8/src/Services/IReturnUrlParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Interface for the return URL parser
/// 
public interface IReturnUrlParser
{
    /// 
    /// Parses a return URL.
    /// 
    /// The return URL.
    /// 
    Task ParseAsync(string returnUrl);

    /// 
    /// Determines whether the return URL is valid.
    /// 
    /// The return URL.
    /// 
    ///   true if the return URL is valid; otherwise, false.
    /// 
    bool IsValidReturnUrl(string returnUrl);
}


================================================
FILE: src/IdentityServer8/src/Services/ITokenCreationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Logic for creating security tokens
/// 
public interface ITokenCreationService
{
    /// 
    /// Creates a token.
    /// 
    /// The token description.
    /// A protected and serialized security token
    Task CreateTokenAsync(Token token);
}


================================================
FILE: src/IdentityServer8/src/Services/ITokenService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Logic for creating security tokens
/// 
public interface ITokenService
{
    /// 
    /// Creates an identity token.
    /// 
    /// The token creation request.
    /// An identity token
    Task CreateIdentityTokenAsync(TokenCreationRequest request);

    /// 
    /// Creates an access token.
    /// 
    /// The token creation request.
    /// An access token
    Task CreateAccessTokenAsync(TokenCreationRequest request);

    /// 
    /// Creates a serialized and protected security token.
    /// 
    /// The token.
    /// A security token in serialized form
    Task CreateSecurityTokenAsync(Token token);
}


================================================
FILE: src/IdentityServer8/src/Services/IUserCodeGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Implements device flow user code generation
/// 
public interface IUserCodeGenerator
{
    /// 
    /// Gets the type of the user code.
    /// 
    /// 
    /// The type of the user code.
    /// 
    string UserCodeType { get; }

    /// 
    /// Gets the retry limit.
    /// 
    /// 
    /// The retry limit for getting a unique value.
    /// 
    int RetryLimit { get; }

    /// 
    /// Generates the user code.
    /// 
    /// 
    Task GenerateAsync();
}


================================================
FILE: src/IdentityServer8/src/Services/IUserCodeService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Implements user code generation
/// 
public interface IUserCodeService
{
    /// 
    /// Gets the user code generator.
    /// 
    /// Type of user code.
    /// 
    Task GetGenerator(string userCodeType);
}


================================================
FILE: src/IdentityServer8/src/Services/IUserSession.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Models a user's authentication session
/// 
public interface IUserSession
{
    /// 
    /// Creates a session identifier for the signin context and issues the session id cookie.
    /// 
    Task CreateSessionIdAsync(ClaimsPrincipal principal, AuthenticationProperties properties);

    /// 
    /// Gets the current authenticated user.
    /// 
    Task GetUserAsync();

    /// 
    /// Gets the current session identifier.
    /// 
    /// 
    Task GetSessionIdAsync();

    /// 
    /// Ensures the session identifier cookie asynchronous.
    /// 
    /// 
    Task EnsureSessionIdCookieAsync();

    /// 
    /// Removes the session identifier cookie.
    /// 
    Task RemoveSessionIdCookieAsync();

    /// 
    /// Adds a client to the list of clients the user has signed into during their session.
    /// 
    /// The client identifier.
    /// 
    Task AddClientIdAsync(string clientId);

    /// 
    /// Gets the list of clients the user has signed into during their session.
    /// 
    /// 
    Task> GetClientListAsync();
}


================================================
FILE: src/IdentityServer8/src/Services/InMemory/InMemoryCorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// CORS policy service that configures the allowed origins from a list of clients' redirect URLs.
/// 
public class InMemoryCorsPolicyService : ICorsPolicyService
{
    /// 
    /// Logger
    /// 
    protected readonly ILogger Logger;
    /// 
    /// Clients applications list
    /// 
    protected readonly IEnumerable Clients;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger
    /// The clients.
    public InMemoryCorsPolicyService(ILogger logger, IEnumerable clients)
    {
        Logger = logger;
        Clients = clients ?? Enumerable.Empty();
    }

    /// 
    /// Determines whether origin is allowed.
    /// 
    /// The origin.
    /// 
    public virtual Task IsOriginAllowedAsync(string origin)
    {
        var query =
            from client in Clients
            from url in client.AllowedCorsOrigins
            select url.GetOrigin();

        var result = query.Contains(origin, StringComparer.OrdinalIgnoreCase);

        if (result)
        {
            Logger.LogDebug("Client list checked and origin: {0} is allowed", Ioc.Sanitizer.Log.Sanitize(origin));
        }
        else
        {
            Logger.LogDebug("Client list checked and origin: {0} is not allowed", Ioc.Sanitizer.Log.Sanitize(origin));
        }

        return Task.FromResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Caching/CachingClientStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Cache decorator for IClientStore
/// 
/// 
/// 
public class CachingClientStore : IClientStore
    where T : IClientStore
{
    private readonly IdentityServerOptions _options;
    private readonly ICache _cache;
    private readonly IClientStore _inner;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The inner.
    /// The cache.
    /// The logger.
    public CachingClientStore(IdentityServerOptions options, T inner, ICache cache, ILogger> logger)
    {
        _options = options;
        _inner = inner;
        _cache = cache;
        _logger = logger;
    }

    /// 
    /// Finds a client by id
    /// 
    /// The client id
    /// 
    /// The client
    /// 
    public async Task FindClientByIdAsync(string clientId)
    {
        var client = await _cache.GetAsync(clientId,
            _options.Caching.ClientStoreExpiration,
            async () => await _inner.FindClientByIdAsync(clientId),
            _logger);

        return client;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Caching/CachingCorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Caching decorator for ICorsPolicyService
/// 
/// 
public class CachingCorsPolicyService : ICorsPolicyService
    where T : ICorsPolicyService
{
    /// 
    /// Class to model entries in CORS origin cache.
    /// 
    public class CorsCacheEntry
    {
        /// 
        /// Ctor.
        /// 
        public CorsCacheEntry(bool allowed)
        {
            Allowed = allowed;
        }

        /// 
        /// Is origin allowed.
        /// 
        public bool Allowed { get; }
    }

    private readonly IdentityServerOptions Options;
    private readonly ICache CorsCache;
    private readonly ICorsPolicyService Inner;
    private readonly ILogger Logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The inner.
    /// The CORS origin cache.
    /// The logger.
    public CachingCorsPolicyService(IdentityServerOptions options,
        T inner,
        ICache corsCache,
        ILogger> logger)
    {
        Options = options;
        Inner = inner;
        CorsCache = corsCache;
        Logger = logger;
    }

    /// 
    /// Determines whether origin is allowed.
    /// 
    /// The origin.
    /// 
    public virtual async Task IsOriginAllowedAsync(string origin)
    {
        var entry = await CorsCache.GetAsync(origin,
                      Options.Caching.CorsExpiration,
                      async () => new CorsCacheEntry(await Inner.IsOriginAllowedAsync(origin)),
                      Logger);

        return entry.Allowed;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Caching/CachingResourceStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Caching decorator for IResourceStore
/// 
/// 
/// 
public class CachingResourceStore : IResourceStore
    where T : IResourceStore
{
    private const string AllKey = "__all__";

    private readonly IdentityServerOptions _options;
    
    private readonly ICache> _identityCache;
    private readonly ICache> _apiByScopeCache;
    private readonly ICache> _apiScopeCache;
    private readonly ICache> _apiResourceCache;
    private readonly ICache _allCache;
    
    private readonly IResourceStore _inner;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The inner.
    /// The identity cache.
    /// The API by scope cache.
    /// The API cache.
    /// 
    /// All cache.
    /// The logger.
    public CachingResourceStore(IdentityServerOptions options, T inner, 
        ICache> identityCache, 
        ICache> apiByScopeCache,
        ICache> apisCache,
        ICache> scopeCache,
        ICache allCache,
        ILogger> logger)
    {
        _options = options;
        _inner = inner;
        _identityCache = identityCache;
        _apiByScopeCache = apiByScopeCache;
        _apiResourceCache = apisCache;
        _apiScopeCache = scopeCache;
        _allCache = allCache;
        _logger = logger;
    }

    private string GetKey(IEnumerable names)
    {
        if (names == null || !names.Any()) return string.Empty;
        return names.OrderBy(x => x).Aggregate((x, y) => x + "," + y);
    }

    /// 
    public async Task GetAllResourcesAsync()
    {
        var key = AllKey;

        var all = await _allCache.GetAsync(key,
            _options.Caching.ResourceStoreExpiration,
            async () => await _inner.GetAllResourcesAsync(),
            _logger);

        return all;
    }

    /// 
    public async Task> FindApiResourcesByNameAsync(IEnumerable apiResourceNames)
    {
        var key = GetKey(apiResourceNames);

        var apis = await _apiResourceCache.GetAsync(key,
            _options.Caching.ResourceStoreExpiration,
            async () => await _inner.FindApiResourcesByNameAsync(apiResourceNames),
            _logger);

        return apis;
    }

    /// 
    public async Task> FindIdentityResourcesByScopeNameAsync(IEnumerable names)
    {
        var key = GetKey(names);

        var identities = await _identityCache.GetAsync(key,
            _options.Caching.ResourceStoreExpiration,
            async () => await _inner.FindIdentityResourcesByScopeNameAsync(names),
            _logger);

        return identities;
    }

    /// 
    public async Task> FindApiResourcesByScopeNameAsync(IEnumerable names)
    {
        var key = GetKey(names);

        var apis = await _apiByScopeCache.GetAsync(key,
            _options.Caching.ResourceStoreExpiration,
            async () => await _inner.FindApiResourcesByScopeNameAsync(names),
            _logger);

        return apis;
    }

    /// 
    public async Task> FindApiScopesByNameAsync(IEnumerable scopeNames)
    {
        var key = GetKey(scopeNames);

        var apis = await _apiScopeCache.GetAsync(key,
            _options.Caching.ResourceStoreExpiration,
            async () => await _inner.FindApiScopesByNameAsync(scopeNames),
            _logger);

        return apis;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/ConsentMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

internal class ConsentMessageStore : IConsentMessageStore
{
    protected readonly MessageCookie Cookie;

    public ConsentMessageStore(MessageCookie cookie)
    {
        Cookie = cookie;
    }

    public virtual Task DeleteAsync(string id)
    {
        Cookie.Clear(id);
        return Task.CompletedTask;
    }

    public virtual Task> ReadAsync(string id)
    {
        return Task.FromResult(Cookie.Read(id));
    }

    public virtual Task WriteAsync(string id, Message message)
    {
        Cookie.Write(id, message);
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DefaultAuthorizationCodeStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Default authorization code store.
/// 
public class DefaultAuthorizationCodeStore : DefaultGrantStore, IAuthorizationCodeStore
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The serializer.
    /// The handle generation service.
    /// The logger.
    public DefaultAuthorizationCodeStore(
        IPersistedGrantStore store,
        IPersistentGrantSerializer serializer,
        IHandleGenerationService handleGenerationService,
        ILogger logger)
        : base(IdentityServerConstants.PersistedGrantTypes.AuthorizationCode, store, serializer, handleGenerationService, logger)
    {
    }

    /// 
    /// Stores the authorization code asynchronous.
    /// 
    /// The code.
    /// 
    public Task StoreAuthorizationCodeAsync(AuthorizationCode code)
    {
        return CreateItemAsync(code, code.ClientId, code.Subject.GetSubjectId(), code.SessionId, code.Description, code.CreationTime, code.Lifetime);
    }

    /// 
    /// Gets the authorization code asynchronous.
    /// 
    /// The code.
    /// 
    public Task GetAuthorizationCodeAsync(string code)
    {
        return GetItemAsync(code);
    }

    /// 
    /// Removes the authorization code asynchronous.
    /// 
    /// The code.
    /// 
    public Task RemoveAuthorizationCodeAsync(string code)
    {
        return RemoveItemAsync(code);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DefaultGrantStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Base class for persisting grants using the IPersistedGrantStore.
/// 
/// 
public class DefaultGrantStore
{
    /// 
    /// The grant type being stored.
    /// 
    protected string GrantType { get; }

    /// 
    /// The logger.
    /// 
    protected ILogger Logger { get; }

    /// 
    /// The PersistedGrantStore.
    /// 
    protected IPersistedGrantStore Store { get; }

    /// 
    /// The PersistentGrantSerializer;
    /// 
    protected IPersistentGrantSerializer Serializer { get; }

    /// 
    /// The HandleGenerationService.
    /// 
    protected IHandleGenerationService HandleGenerationService { get; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// Type of the grant.
    /// The store.
    /// The serializer.
    /// The handle generation service.
    /// The logger.
    /// grantType
    protected DefaultGrantStore(string grantType,
        IPersistedGrantStore store,
        IPersistentGrantSerializer serializer,
        IHandleGenerationService handleGenerationService,
        ILogger logger)
    {
        if (grantType.IsMissing()) throw new ArgumentNullException(nameof(grantType));

        GrantType = grantType;
        Store = store;
        Serializer = serializer;
        HandleGenerationService = handleGenerationService;
        Logger = logger;
    }

    private const string KeySeparator = ":";

    /// 
    /// Gets the hashed key.
    /// 
    /// The value.
    /// 
    protected virtual string GetHashedKey(string value)
    {
        return (value + KeySeparator + GrantType).Sha256();
    }

    /// 
    /// Gets the item.
    /// 
    /// The key.
    /// 
    protected virtual async Task GetItemAsync(string key)
    {
        var hashedKey = GetHashedKey(key);

        var grant = await Store.GetAsync(hashedKey);
        if (grant != null && grant.Type == GrantType)
        {
            try
            {
                return Serializer.Deserialize(grant.Data);
            }
            catch (Exception ex)
            {
                Logger.LogError(ex, "Failed to deserialize JSON from grant store.");
            }
        }
        else
        {
            Logger.LogDebug("{grantType} grant with value: {key} not found in store.", GrantType, Ioc.Sanitizer.Log.Sanitize(key));
        }

        return default;
    }

    /// 
    /// Creates the item.
    /// 
    /// The item.
    /// The client identifier.
    /// The subject identifier.
    /// The session identifier.
    /// The description.
    /// The created.
    /// The lifetime.
    /// 
    protected virtual async Task CreateItemAsync(T item, string clientId, string subjectId, string sessionId, string description, DateTime created, int lifetime)
    {
        var handle = await HandleGenerationService.GenerateAsync();
        await StoreItemAsync(handle, item, clientId, subjectId, sessionId, description, created, created.AddSeconds(lifetime));
        return handle;
    }

    /// 
    /// Stores the item.
    /// 
    /// The key.
    /// The item.
    /// The client identifier.
    /// The subject identifier.
    /// The session identifier.
    /// The description.
    /// The created time.
    /// The expiration.
    /// The consumed time.
    /// 
    protected virtual async Task StoreItemAsync(string key, T item, string clientId, string subjectId, string sessionId, string description, DateTime created, DateTime? expiration, DateTime? consumedTime = null)
    {
        key = GetHashedKey(key);

        var json = Serializer.Serialize(item);

        var grant = new PersistedGrant
        {
            Key = key,
            Type = GrantType,
            ClientId = clientId,
            SubjectId = subjectId,
            SessionId = sessionId,
            Description = description,
            CreationTime = created,
            Expiration = expiration,
            ConsumedTime = consumedTime,
            Data = json
        };

        await Store.StoreAsync(grant);
    }

    /// 
    /// Removes the item.
    /// 
    /// The key.
    /// 
    protected virtual async Task RemoveItemAsync(string key)
    {
        key = GetHashedKey(key);
        await Store.RemoveAsync(key);
    }

    /// 
    /// Removes all items for a subject id / cliend id combination.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    protected virtual async Task RemoveAllAsync(string subjectId, string clientId)
    {
        await Store.RemoveAllAsync(new PersistedGrantFilter
        {
            SubjectId = subjectId,
            ClientId = clientId,
            Type = GrantType
        });
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DefaultReferenceTokenStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Default reference token store.
/// 
public class DefaultReferenceTokenStore : DefaultGrantStore, IReferenceTokenStore
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The serializer.
    /// The handle generation service.
    /// The logger.
    public DefaultReferenceTokenStore(
        IPersistedGrantStore store, 
        IPersistentGrantSerializer serializer,
        IHandleGenerationService handleGenerationService,
        ILogger logger) 
        : base(IdentityServerConstants.PersistedGrantTypes.ReferenceToken, store, serializer, handleGenerationService, logger)
    {
    }

    /// 
    /// Stores the reference token asynchronous.
    /// 
    /// The token.
    /// 
    public Task StoreReferenceTokenAsync(Token token)
    {
        return CreateItemAsync(token, token.ClientId, token.SubjectId, token.SessionId, token.Description, token.CreationTime, token.Lifetime);
    }

    /// 
    /// Gets the reference token asynchronous.
    /// 
    /// The handle.
    /// 
    public Task GetReferenceTokenAsync(string handle)
    {
        return GetItemAsync(handle);
    }

    /// 
    /// Removes the reference token asynchronous.
    /// 
    /// The handle.
    /// 
    public Task RemoveReferenceTokenAsync(string handle)
    {
        return RemoveItemAsync(handle);
    }

    /// 
    /// Removes the reference tokens asynchronous.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    public Task RemoveReferenceTokensAsync(string subjectId, string clientId)
    {
        return RemoveAllAsync(subjectId, clientId);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DefaultRefreshTokenStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Default refresh token store.
/// 
public class DefaultRefreshTokenStore : DefaultGrantStore, IRefreshTokenStore
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The serializer.
    /// The handle generation service.
    /// The logger.
    public DefaultRefreshTokenStore(
        IPersistedGrantStore store, 
        IPersistentGrantSerializer serializer, 
        IHandleGenerationService handleGenerationService,
        ILogger logger) 
        : base(IdentityServerConstants.PersistedGrantTypes.RefreshToken, store, serializer, handleGenerationService, logger)
    {
    }

    /// 
    /// Stores the refresh token.
    /// 
    /// The refresh token.
    /// 
    public async Task StoreRefreshTokenAsync(RefreshToken refreshToken)
    {
        return await CreateItemAsync(refreshToken, refreshToken.ClientId, refreshToken.SubjectId, refreshToken.SessionId, refreshToken.Description, refreshToken.CreationTime, refreshToken.Lifetime);
    }

    /// 
    /// Updates the refresh token.
    /// 
    /// The handle.
    /// The refresh token.
    /// 
    public Task UpdateRefreshTokenAsync(string handle, RefreshToken refreshToken)
    {
        return StoreItemAsync(handle, refreshToken, refreshToken.ClientId, refreshToken.SubjectId, refreshToken.SessionId, refreshToken.Description, refreshToken.CreationTime, refreshToken.CreationTime.AddSeconds(refreshToken.Lifetime), refreshToken.ConsumedTime);
    }

    /// 
    /// Gets the refresh token.
    /// 
    /// The refresh token handle.
    /// 
    public Task GetRefreshTokenAsync(string refreshTokenHandle)
    {
        return GetItemAsync(refreshTokenHandle);
    }

    /// 
    /// Removes the refresh token.
    /// 
    /// The refresh token handle.
    /// 
    public Task RemoveRefreshTokenAsync(string refreshTokenHandle)
    {
        return RemoveItemAsync(refreshTokenHandle);
    }

    /// 
    /// Removes the refresh tokens.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    public Task RemoveRefreshTokensAsync(string subjectId, string clientId)
    {
        return RemoveAllAsync(subjectId, clientId);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DefaultUserConsentStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Default user consent store.
/// 
public class DefaultUserConsentStore : DefaultGrantStore, IUserConsentStore
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// The serializer.
    /// The handle generation service.
    /// The logger.
    public DefaultUserConsentStore(
        IPersistedGrantStore store, 
        IPersistentGrantSerializer serializer,
        IHandleGenerationService handleGenerationService,
        ILogger logger) 
        : base(IdentityServerConstants.PersistedGrantTypes.UserConsent, store, serializer, handleGenerationService, logger)
    {
    }

    private string GetConsentKey(string subjectId, string clientId)
    {
        return clientId + "|" + subjectId;
    }

    /// 
    /// Stores the user consent asynchronous.
    /// 
    /// The consent.
    /// 
    public Task StoreUserConsentAsync(Consent consent)
    {
        var key = GetConsentKey(consent.SubjectId, consent.ClientId);
        return StoreItemAsync(key, consent, consent.ClientId, consent.SubjectId, null, null, consent.CreationTime, consent.Expiration);
    }

    /// 
    /// Gets the user consent asynchronous.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    public Task GetUserConsentAsync(string subjectId, string clientId)
    {
        var key = GetConsentKey(subjectId, clientId);
        return GetItemAsync(key);
    }

    /// 
    /// Removes the user consent asynchronous.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    public Task RemoveUserConsentAsync(string subjectId, string clientId)
    {
        var key = GetConsentKey(subjectId, clientId);
        return RemoveItemAsync(key);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/DistributedCacheAuthorizationParametersMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores.Default;

/// 
/// Implementation of IAuthorizationParametersMessageStore that uses the IDistributedCache.
/// 
public class DistributedCacheAuthorizationParametersMessageStore : IAuthorizationParametersMessageStore
{
    private readonly IDistributedCache _distributedCache;
    private readonly IHandleGenerationService _handleGenerationService;

    /// 
    /// Ctor.
    /// 
    /// 
    /// 
    public DistributedCacheAuthorizationParametersMessageStore(IDistributedCache distributedCache, IHandleGenerationService handleGenerationService)
    {
        _distributedCache = distributedCache;
        _handleGenerationService = handleGenerationService;
    }

    private string CacheKeyPrefix => "DistributedCacheAuthorizationParametersMessageStore";
    
    /// 
    public async Task WriteAsync(Message> message)
    {
        // since this store is trusted and the JWT request processing has provided redundant entries
        // in the NameValueCollection, we are removing the JWT "request_uri" param so that when they
        // are reloaded/revalidated we don't re-trigger outbound requests. we could possibly do the
        // same for the "request" param, but it's less of a concern (as it's just a signature check).
        message.Data.Remove(OidcConstants.AuthorizeRequest.RequestUri);

        var key = await _handleGenerationService.GenerateAsync();
        var cacheKey = $"{CacheKeyPrefix}-{key}";
        
        var json = ObjectSerializer.ToString(message);

        var options = new DistributedCacheEntryOptions();
        options.SetSlidingExpiration(Constants.DefaultCacheDuration);

        await _distributedCache.SetStringAsync(cacheKey, json, options);

        return key;
    }

    /// 
    public async Task>> ReadAsync(string id)
    {
        var cacheKey = $"{CacheKeyPrefix}-{id}";
        var json = await _distributedCache.GetStringAsync(cacheKey);

        if (json == null)
        {
            return new Message>(new Dictionary());
        }

        return ObjectSerializer.FromString>>(json);
    }

    /// 
    public Task DeleteAsync(string id)
    {
        return _distributedCache.RemoveAsync(id);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/ProtectedDataMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.DataProtection;

namespace IdentityServer8.Stores;

/// 
/// IMessageStore implementation that uses data protection to protect message.
/// 
/// 
public class ProtectedDataMessageStore : IMessageStore
{
    private const string Purpose = "IdentityServer8.Stores.ProtectedDataMessageStore";

    /// 
    /// The data protector.
    /// 
    protected readonly IDataProtector Protector;

    /// 
    /// The logger.
    /// 
    protected readonly ILogger Logger;

    /// 
    /// Ctor
    /// 
    /// 
    /// 
    public ProtectedDataMessageStore(IDataProtectionProvider provider, ILogger> logger)
    {
        Protector = provider.CreateProtector(Purpose);
        Logger = logger;
    }

    /// 
    public virtual Task> ReadAsync(string value)
    {
        Message result = null;

        if (!String.IsNullOrWhiteSpace(value))
        {
            try
            {
                var bytes = Base64Url.Decode(value);
                bytes = Protector.Unprotect(bytes);
                var json = Encoding.UTF8.GetString(bytes);
                result = ObjectSerializer.FromString>(json);
            }
            catch(Exception ex)
            {
                Logger.LogError(ex, "Exception reading protected message");
            }
        }

        return Task.FromResult(result);
    }

    /// 
    public virtual Task WriteAsync(Message message)
    {
        string value = null;

        try
        {
            var json = ObjectSerializer.ToString(message);
            var bytes = Encoding.UTF8.GetBytes(json);
            bytes = Protector.Protect(bytes);
            value = Base64Url.Encode(bytes);
        }
        catch(Exception ex)
        {
            Logger.LogError(ex, "Exception writing protected message");
        }

        return Task.FromResult(value);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/Default/QueryStringAuthorizationParametersMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

// internal just for testing
internal class QueryStringAuthorizationParametersMessageStore : IAuthorizationParametersMessageStore
{
    public Task WriteAsync(Message> message)
    {
        var queryString = message.Data.FromFullDictionary().ToQueryString();
        return Task.FromResult(queryString);
    }

    public Task>> ReadAsync(string id)
    {
        var values = id.ReadQueryStringAsNameValueCollection();
        var msg = new Message>(values.ToFullDictionary());
        return Task.FromResult(msg);
    }

    public Task DeleteAsync(string id)
    {
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/IAuthorizationParametersMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for authorization request messages that are sent from the authorization endpoint to the login and consent UI.
/// 
public interface IAuthorizationParametersMessageStore
{
    /// 
    /// Writes the authorization parameters.
    /// 
    /// The message.
    /// The identifier for the stored message.
    Task WriteAsync(Message> message);

    /// 
    /// Reads the authorization parameters.
    /// 
    /// The identifier.
    /// 
    Task>> ReadAsync(string id);

    /// 
    /// Deletes the authorization parameters.
    /// 
    /// The identifier.
    /// 
    Task DeleteAsync(string id);
}


================================================
FILE: src/IdentityServer8/src/Stores/IConsentMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for consent messages that are sent from the consent UI to the authorization endpoint.
/// 
public interface IConsentMessageStore
{
    /// 
    /// Writes the consent response message.
    /// 
    /// The id for the message.
    /// The message.
    Task WriteAsync(string id, Message message);

    /// 
    /// Reads the consent response message.
    /// 
    /// The identifier.
    /// 
    Task> ReadAsync(string id);

    /// 
    /// Deletes the consent response message.
    /// 
    /// The identifier.
    /// 
    Task DeleteAsync(string id);
}


================================================
FILE: src/IdentityServer8/src/Stores/IMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for a message store
/// 
/// The type of the model.
public interface IMessageStore
{
    /// 
    /// Writes the message.
    /// 
    /// The message.
    /// An identifier for the message
    Task WriteAsync(Message message);

    /// 
    /// Reads the message.
    /// 
    /// The identifier.
    /// 
    Task> ReadAsync(string id);
}


================================================
FILE: src/IdentityServer8/src/Stores/ISigningCredentialStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Stores;

/// 
/// Interface for a signing credential store
/// 
public interface ISigningCredentialStore
{
    /// 
    /// Gets the signing credentials.
    /// 
    /// 
    Task GetSigningCredentialsAsync();
}


================================================
FILE: src/IdentityServer8/src/Stores/IValidationKeysStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for the validation key store
/// 
public interface IValidationKeysStore
{
    /// 
    /// Gets all validation keys.
    /// 
    /// 
    Task> GetValidationKeysAsync();
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemoryClientStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// In-memory client store
/// 
public class InMemoryClientStore : IClientStore
{
    private readonly IEnumerable _clients;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clients.
    public InMemoryClientStore(IEnumerable clients)
    {
        if (clients.HasDuplicates(m => m.ClientId))
        {
            throw new ArgumentException("Clients must not contain duplicate ids");
        }
        _clients = clients;
    }

    /// 
    /// Finds a client by id
    /// 
    /// The client id
    /// 
    /// The client
    /// 
    public Task FindClientByIdAsync(string clientId)
    {
        var query =
            from client in _clients
            where client.ClientId == clientId
            select client;
        
        return Task.FromResult(query.SingleOrDefault());
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemoryDeviceFlowStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// In-memory device flow store
/// 
/// 
public class InMemoryDeviceFlowStore : IDeviceFlowStore
{
    private readonly List _repository = new List();

    /// 
    /// Stores the device authorization request.
    /// 
    /// The device code.
    /// The user code.
    /// The data.
    /// 
    public Task StoreDeviceAuthorizationAsync(string deviceCode, string userCode, DeviceCode data)
    {
        lock (_repository)
        {
            _repository.Add(new InMemoryDeviceAuthorization(deviceCode, userCode, data));
        }
        
        return Task.CompletedTask;
    }

    /// 
    /// Finds device authorization by user code.
    /// 
    /// The user code.
    public Task FindByUserCodeAsync(string userCode)
    {
        DeviceCode foundDeviceCode;

        lock (_repository)
        {
            foundDeviceCode = _repository.FirstOrDefault(x => x.UserCode == userCode)?.Data;
        }

        return Task.FromResult(foundDeviceCode);
    }

    /// 
    /// Finds device authorization by device code.
    /// 
    /// The device code.
    public Task FindByDeviceCodeAsync(string deviceCode)
    {
        DeviceCode foundDeviceCode;

        lock (_repository)
        {
            foundDeviceCode = _repository.FirstOrDefault(x => x.DeviceCode == deviceCode)?.Data;
        }

        return Task.FromResult(foundDeviceCode);
    }

    /// 
    /// Updates device authorization, searching by user code.
    /// 
    /// The user code.
    /// The data.
    public Task UpdateByUserCodeAsync(string userCode, DeviceCode data)
    {
        lock (_repository)
        {
            var foundData = _repository.FirstOrDefault(x => x.UserCode == userCode);

            if (foundData != null)
            {
                foundData.Data = data;
            }
        }

        return Task.CompletedTask;
    }

    /// 
    /// Removes the device authorization, searching by device code.
    /// 
    /// The device code.
    /// 
    public Task RemoveByDeviceCodeAsync(string deviceCode)
    {
        lock (_repository)
        {
            var foundData = _repository.FirstOrDefault(x => x.DeviceCode == deviceCode);

            if (foundData != null)
            {
                _repository.Remove(foundData);
            }
        }


        return Task.CompletedTask;
    }

    private class InMemoryDeviceAuthorization
    {
        public InMemoryDeviceAuthorization(string deviceCode, string userCode, DeviceCode data)
        {
            DeviceCode = deviceCode;
            UserCode = userCode;
            Data = data;
        }

        public string DeviceCode { get; }
        public string UserCode { get; }
        public DeviceCode Data { get; set; }
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemoryPersistedGrantStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// In-memory persisted grant store
/// 
public class InMemoryPersistedGrantStore : IPersistedGrantStore
{
    private readonly ConcurrentDictionary _repository = new ConcurrentDictionary();

    /// 
    public Task StoreAsync(PersistedGrant grant)
    {
        _repository[grant.Key] = grant;

        return Task.CompletedTask;
    }

    /// 
    public Task GetAsync(string key)
    {
        if (_repository.TryGetValue(key, out PersistedGrant token))
        {
            return Task.FromResult(token);
        }

        return Task.FromResult(null);
    }

    /// 
    public Task> GetAllAsync(PersistedGrantFilter filter)
    {
        filter.Validate();
        
        var items = Filter(filter);
        
        return Task.FromResult(items);
    }

    /// 
    public Task RemoveAsync(string key)
    {
        _repository.TryRemove(key, out _);

        return Task.CompletedTask;
    }

    /// 
    public Task RemoveAllAsync(PersistedGrantFilter filter)
    {
        filter.Validate();

        var items = Filter(filter);
        
        foreach (var item in items)
        {
            _repository.TryRemove(item.Key, out _);
        }

        return Task.CompletedTask;
    }

    private IEnumerable Filter(PersistedGrantFilter filter)
    {
        var query =
            from item in _repository
            select item.Value;

        if (!String.IsNullOrWhiteSpace(filter.ClientId))
        {
            query = query.Where(x => x.ClientId == filter.ClientId);
        }
        if (!String.IsNullOrWhiteSpace(filter.SessionId))
        {
            query = query.Where(x => x.SessionId == filter.SessionId);
        }
        if (!String.IsNullOrWhiteSpace(filter.SubjectId))
        {
            query = query.Where(x => x.SubjectId == filter.SubjectId);
        }
        if (!String.IsNullOrWhiteSpace(filter.Type))
        {
            query = query.Where(x => x.Type == filter.Type);
        }

        var items = query.ToArray().AsEnumerable();
        return items;
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemoryResourcesStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// In-memory resource store
/// 
public class InMemoryResourcesStore : IResourceStore
{
    private readonly IEnumerable _identityResources;
    private readonly IEnumerable _apiResources;
    private readonly IEnumerable _apiScopes;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public InMemoryResourcesStore(
        IEnumerable identityResources = null, 
        IEnumerable apiResources = null, 
        IEnumerable apiScopes = null)
    {
        if (identityResources?.HasDuplicates(m => m.Name) == true)
        {
            throw new ArgumentException("Identity resources must not contain duplicate names");
        }

        if (apiResources?.HasDuplicates(m => m.Name) == true)
        {
            throw new ArgumentException("Api resources must not contain duplicate names");
        }
        
        if (apiScopes?.HasDuplicates(m => m.Name) == true)
        {
            throw new ArgumentException("Scopes must not contain duplicate names");
        }

        _identityResources = identityResources ?? Enumerable.Empty();
        _apiResources = apiResources ?? Enumerable.Empty();
        _apiScopes = apiScopes ?? Enumerable.Empty();
    }

    /// 
    public Task GetAllResourcesAsync()
    {
        var result = new Resources(_identityResources, _apiResources, _apiScopes);
        return Task.FromResult(result);
    }

    /// 
    public Task> FindApiResourcesByNameAsync(IEnumerable apiResourceNames)
    {
        if (apiResourceNames == null) throw new ArgumentNullException(nameof(apiResourceNames));

        var query = from a in _apiResources
                    where apiResourceNames.Contains(a.Name)
                    select a;
        return Task.FromResult(query);
    }

    /// 
    public Task> FindIdentityResourcesByScopeNameAsync(IEnumerable scopeNames)
    {
        if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

        var identity = from i in _identityResources
                       where scopeNames.Contains(i.Name)
                       select i;

        return Task.FromResult(identity);
    }

    /// 
    public Task> FindApiResourcesByScopeNameAsync(IEnumerable scopeNames)
    {
        if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

        var query = from a in _apiResources
                    where a.Scopes.Any(x => scopeNames.Contains(x))
                    select a;

        return Task.FromResult(query);
    }

    /// 
    public Task> FindApiScopesByNameAsync(IEnumerable scopeNames)
    {
        if (scopeNames == null) throw new ArgumentNullException(nameof(scopeNames));

        var query =
            from x in _apiScopes
            where scopeNames.Contains(x.Name)
            select x;
        
        return Task.FromResult(query);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemorySigningCredentialsStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Stores;

/// 
/// Default signing credentials store
/// 
/// 
public class InMemorySigningCredentialsStore : ISigningCredentialStore
{
    private readonly SigningCredentials _credential;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The credential.
    public InMemorySigningCredentialsStore(SigningCredentials credential)
    {
        _credential = credential;
    }

    /// 
    /// Gets the signing credentials.
    /// 
    /// 
    public Task GetSigningCredentialsAsync()
    {
        return Task.FromResult(_credential);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/InMemory/InMemoryValidationKeysStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// The default validation key store
/// 
/// 
public class InMemoryValidationKeysStore : IValidationKeysStore
{
    private readonly IEnumerable _keys;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The keys.
    /// keys
    public InMemoryValidationKeysStore(IEnumerable keys)
    {
        _keys = keys ?? throw new ArgumentNullException(nameof(keys));
    }

    /// 
    /// Gets all validation keys.
    /// 
    /// 
    public Task> GetValidationKeysAsync()
    {
        return Task.FromResult(_keys);
    }
}


================================================
FILE: src/IdentityServer8/src/Stores/ValidatingClientStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Client store decorator for running runtime configuration validation checks
/// 
public class ValidatingClientStore : IClientStore
    where T : IClientStore
{
    private readonly IClientStore _inner;
    private readonly IClientConfigurationValidator _validator;
    private readonly IEventService _events;
    private readonly ILogger> _logger;
    private readonly string _validatorType;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The inner.
    /// The validator.
    /// The events.
    /// The logger.
    public ValidatingClientStore(T inner, IClientConfigurationValidator validator, IEventService events, ILogger> logger)
    {
        _inner = inner;
        _validator = validator;
        _events = events;
        _logger = logger;

        _validatorType = validator.GetType().FullName;
    }

    /// 
    /// Finds a client by id (and runs the validation logic)
    /// 
    /// The client id
    /// 
    /// The client or an InvalidOperationException
    /// 
    public async Task FindClientByIdAsync(string clientId)
    {
        var client = await _inner.FindClientByIdAsync(clientId);

        if (client != null)
        {
            _logger.LogTrace("Calling into client configuration validator: {validatorType}", _validatorType);

            var context = new ClientConfigurationValidationContext(client);
            await _validator.ValidateAsync(context);

            if (context.IsValid)
            {
                _logger.LogDebug("client configuration validation for client {clientId} succeeded.", client.ClientId);
                return client;
            }

            _logger.LogError("Invalid client configuration for client {clientId}: {errorMessage}", client.ClientId, context.ErrorMessage);
            await _events.RaiseAsync(new InvalidClientConfigurationEvent(client, context.ErrorMessage));
                
            return null;
        }

        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Test/IdentityServerBuilderExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

/// 
/// Extension methods for the IdentityServer builder
/// 
public static class IdentityServerBuilderExtensions
{
    /// 
    /// Adds test users.
    /// 
    /// The builder.
    /// The users.
    /// 
    public static IIdentityServerBuilder AddTestUsers(this IIdentityServerBuilder builder, List users)
    {
        builder.Services.AddSingleton(new TestUserStore(users));
        builder.AddProfileService();
        builder.AddResourceOwnerValidator();

        return builder;
    }
}


================================================
FILE: src/IdentityServer8/src/Test/TestUser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Test;

/// 
/// In-memory user object for testing. Not intended for modeling users in production.
/// 
public class TestUser
{
    /// 
    /// Gets or sets the subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets or sets the username.
    /// 
    public string Username { get; set; }

    /// 
    /// Gets or sets the password.
    /// 
    public string Password { get; set; }

    /// 
    /// Gets or sets the provider name.
    /// 
    public string ProviderName { get; set; }

    /// 
    /// Gets or sets the provider subject identifier.
    /// 
    public string ProviderSubjectId { get; set; }

    /// 
    /// Gets or sets if the user is active.
    /// 
    public bool IsActive { get; set; } = true;

    /// 
    /// Gets or sets the claims.
    /// 
    public ICollection Claims { get; set; } = new HashSet(new ClaimComparer());
}


================================================
FILE: src/IdentityServer8/src/Test/TestUserProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Test;

/// 
/// Profile service for test users
/// 
/// 
public class TestUserProfileService : IProfileService
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;
    
    /// 
    /// The users
    /// 
    protected readonly TestUserStore Users;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The users.
    /// The logger.
    public TestUserProfileService(TestUserStore users, ILogger logger)
    {
        Users = users;
        Logger = logger;
    }

    /// 
    /// This method is called whenever claims about the user are requested (e.g. during token creation or via the userinfo endpoint)
    /// 
    /// The context.
    /// 
    public virtual Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        context.LogProfileRequest(Logger);

        if (context.RequestedClaimTypes.Any())
        {
            var user = Users.FindBySubjectId(context.Subject.GetSubjectId());
            if (user != null)
            {
                context.AddRequestedClaims(user.Claims);
            }
        }

        context.LogIssuedClaims(Logger);

        return Task.CompletedTask;
    }

    /// 
    /// This method gets called whenever identity server needs to determine if the user is valid or active (e.g. if the user's account has been deactivated since they logged in).
    /// (e.g. during token issuance or validation).
    /// 
    /// The context.
    /// 
    public virtual Task IsActiveAsync(IsActiveContext context)
    {
        Logger.LogDebug("IsActive called from: {caller}", context.Caller);

        var user = Users.FindBySubjectId(context.Subject.GetSubjectId());
        context.IsActive = user?.IsActive == true;

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Test/TestUserResourceOwnerPasswordValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Test;

/// 
/// Resource owner password validator for test users
/// 
/// 
public class TestUserResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
{
    private readonly TestUserStore _users;
    private readonly ISystemClock _clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The users.
    /// The clock.
    public TestUserResourceOwnerPasswordValidator(TestUserStore users, ISystemClock clock)
    {
        _users = users;
        _clock = clock;
    }

    /// 
    /// Validates the resource owner password credential
    /// 
    /// The context.
    /// 
    public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {
        if (_users.ValidateCredentials(context.UserName, context.Password))
        {
            var user = _users.FindByUsername(context.UserName);
            context.Result = new GrantValidationResult(
                user.SubjectId ?? throw new ArgumentException("Subject ID not set", nameof(user.SubjectId)), 
                OidcConstants.AuthenticationMethods.Password, _clock.UtcNow.UtcDateTime, 
                user.Claims);
        }

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Test/TestUserStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Test;

/// 
/// Store for test users
/// 
public class TestUserStore
{
    private readonly List _users;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The users.
    public TestUserStore(List users)
    {
        _users = users;
    }

    /// 
    /// Validates the credentials.
    /// 
    /// The username.
    /// The password.
    /// 
    public bool ValidateCredentials(string username, string password)
    {
        var user = FindByUsername(username);
        
        if (user != null)
        {
            if (string.IsNullOrWhiteSpace(user.Password) && string.IsNullOrWhiteSpace(password))
            {
                return true;
            }
            
            return user.Password.Equals(password);
        }
        
        return false;
    }

    /// 
    /// Finds the user by subject identifier.
    /// 
    /// The subject identifier.
    /// 
    public TestUser FindBySubjectId(string subjectId)
    {
        return _users.FirstOrDefault(x => x.SubjectId == subjectId);
    }

    /// 
    /// Finds the user by username.
    /// 
    /// The username.
    /// 
    public TestUser FindByUsername(string username)
    {
        return _users.FirstOrDefault(x => x.Username.Equals(username, StringComparison.OrdinalIgnoreCase));
    }

    /// 
    /// Finds the user by external provider.
    /// 
    /// The provider.
    /// The user identifier.
    /// 
    public TestUser FindByExternalProvider(string provider, string userId)
    {
        return _users.FirstOrDefault(x =>
            x.ProviderName == provider &&
            x.ProviderSubjectId == userId);
    }

    /// 
    /// Automatically provisions a user.
    /// 
    /// The provider.
    /// The user identifier.
    /// The claims.
    /// 
    public TestUser AutoProvisionUser(string provider, string userId, List claims)
    {
        // create a list of claims that we want to transfer into our store
        var filtered = new List();

        foreach (var claim in claims)
        {
            // if the external system sends a display name - translate that to the standard OIDC name claim
            if (claim.Type == ClaimTypes.Name)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, claim.Value));
            }
            // if the JWT handler has an outbound mapping to an OIDC claim use that
            else if (JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap.ContainsKey(claim.Type))
            {
                filtered.Add(new Claim(JwtSecurityTokenHandler.DefaultOutboundClaimTypeMap[claim.Type], claim.Value));
            }
            // copy the claim as-is
            else
            {
                filtered.Add(claim);
            }
        }

        // if no display name was provided, try to construct by first and/or last name
        if (!filtered.Any(x => x.Type == JwtClaimTypes.Name))
        {
            var first = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.GivenName)?.Value;
            var last = filtered.FirstOrDefault(x => x.Type == JwtClaimTypes.FamilyName)?.Value;
            if (first != null && last != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, first + " " + last));
            }
            else if (first != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, first));
            }
            else if (last != null)
            {
                filtered.Add(new Claim(JwtClaimTypes.Name, last));
            }
        }

        // create a new unique subject id
        var sub = CryptoRandom.CreateUniqueId(format: CryptoRandom.OutputFormat.Hex);

        // check if a display name is available, otherwise fallback to subject id
        var name = filtered.FirstOrDefault(c => c.Type == JwtClaimTypes.Name)?.Value ?? sub;

        // create new user
        var user = new TestUser
        {
            SubjectId = sub,
            Username = name,
            ProviderName = provider,
            ProviderSubjectId = userId,
            Claims = filtered
        };

        // add user to in-memory store
        _users.Add(user);

        return user;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/ClientConfigurationValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Context for client configuration validation.
/// 
public class ClientConfigurationValidationContext
{
    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; }

    /// 
    /// Returns true if client configuration is valid.
    /// 
    /// 
    ///   true if this instance is valid; otherwise, false.
    /// 
    public bool IsValid { get; set; } = true;

    /// 
    /// Gets or sets the error message.
    /// 
    /// 
    /// The error message.
    /// 
    public string ErrorMessage { get; set; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The client.
    public ClientConfigurationValidationContext(Client client)
    {
        Client = client;
    }

    /// 
    /// Sets a validation error.
    /// 
    /// The message.
    public void SetError(string message)
    {
        IsValid = false;
        ErrorMessage = message;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/CustomAuthorizeRequestValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Context for custom authorize request validation.
/// 
public class CustomAuthorizeRequestValidationContext
{
    /// 
    /// The result of custom validation. 
    /// 
    public AuthorizeRequestValidationResult Result { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/CustomTokenRequestValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Context class for custom token request validation
/// 
public class CustomTokenRequestValidationContext
{
    /// 
    /// Gets or sets the result.
    /// 
    /// 
    /// The result.
    /// 
    public TokenRequestValidationResult Result { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/ExtensionGrantValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Class describing the extension grant validation context
/// 
public class ExtensionGrantValidationContext
{
    /// 
    /// Gets or sets the request.
    /// 
    /// 
    /// The request.
    /// 
    public ValidatedTokenRequest Request { get; set; }

    /// 
    /// Gets or sets the result.
    /// 
    /// 
    /// The result.
    /// 
    public GrantValidationResult Result { get; set; } = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/ResourceOwnerPasswordValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Class describing the resource owner password validation context
/// 
public class ResourceOwnerPasswordValidationContext
{
    /// 
    /// Gets or sets the name of the user.
    /// 
    /// 
    /// The name of the user.
    /// 
    public string UserName { get; set; }

    /// 
    /// Gets or sets the password.
    /// 
    /// 
    /// The password.
    /// 
    public string Password { get; set; }

    /// 
    /// Gets or sets the request.
    /// 
    /// 
    /// The request.
    /// 
    public ValidatedTokenRequest Request { get; set; }

    /// 
    /// Gets or sets the result.
    /// 
    /// 
    /// The result.
    /// 
    public GrantValidationResult Result { get; set; } = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
}


================================================
FILE: src/IdentityServer8/src/Validation/Contexts/ResourceValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Class describing the resource validation context
/// 
public class ResourceValidationContext
{
    /// 
    /// Gets or sets the result.
    /// 
    /// 
    /// The result.
    /// 
    public GrantValidationResult Result { get; set; } = new GrantValidationResult(TokenRequestErrors.InvalidGrant);
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/ApiSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates API secrets using the registered secret validators and parsers
/// 
public class ApiSecretValidator : IApiSecretValidator
{
    private readonly ILogger _logger;
    private readonly IResourceStore _resources;
    private readonly IEventService _events;
    private readonly ISecretsListParser _parser;
    private readonly ISecretsListValidator _validator;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The resources.
    /// The parsers.
    /// The validator.
    /// The events.
    /// The logger.
    public ApiSecretValidator(IResourceStore resources, ISecretsListParser parsers, ISecretsListValidator validator, IEventService events, ILogger logger)
    {
        _resources = resources;
        _parser = parsers;
        _validator = validator;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Validates the secret on the current request.
    /// 
    /// The context.
    /// 
    public async Task ValidateAsync(HttpContext context)
    {
        _logger.LogTrace("Start API validation");

        var fail = new ApiSecretValidationResult
        {
            IsError = true
        };

        var parsedSecret = await _parser.ParseAsync(context);
        if (parsedSecret == null)
        {
            await RaiseFailureEventAsync("unknown", "No API id or secret found");

            _logger.LogError("No API secret found");
            return fail;
        }

        // load API resource
        var apis = await _resources.FindApiResourcesByNameAsync(new[] { parsedSecret.Id });
        if (apis == null || !apis.Any())
        {
            await RaiseFailureEventAsync(parsedSecret.Id, "Unknown API resource");

            _logger.LogError("No API resource with that name found. aborting");
            return fail;
        }

        if (apis.Count() > 1)
        {
            await RaiseFailureEventAsync(parsedSecret.Id, "Invalid API resource");

            _logger.LogError("More than one API resource with that name found. aborting");
            return fail;
        }

        var api = apis.Single();

        if (api.Enabled == false)
        {
            await RaiseFailureEventAsync(parsedSecret.Id, "API resource not enabled");

            _logger.LogError("API resource not enabled. aborting.");
            return fail;
        }

        var result = await _validator.ValidateAsync(api.ApiSecrets, parsedSecret);
        if (result.Success)
        {
            _logger.LogDebug("API resource validation success");

            var success = new ApiSecretValidationResult
            {
                IsError = false,
                Resource = api
            };

            await RaiseSuccessEventAsync(api.Name, parsedSecret.Type);
            return success;
        }

        await RaiseFailureEventAsync(api.Name, "Invalid API secret");
        _logger.LogError("API validation failed.");

        return fail;
    }

    private Task RaiseSuccessEventAsync(string clientId, string authMethod)
    {
        return _events.RaiseAsync(new ApiAuthenticationSuccessEvent(clientId, authMethod));
    }

    private Task RaiseFailureEventAsync(string clientId, string message)
    {
        return _events.RaiseAsync(new ApiAuthenticationFailureEvent(clientId, message));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/AuthorizeRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

internal class AuthorizeRequestValidator : IAuthorizeRequestValidator
{
    private readonly IdentityServerOptions _options;
    private readonly IClientStore _clients;
    private readonly ICustomAuthorizeRequestValidator _customValidator;
    private readonly IRedirectUriValidator _uriValidator;
    private readonly IResourceValidator _resourceValidator;
    private readonly IUserSession _userSession;
    private readonly JwtRequestValidator _jwtRequestValidator;
    private readonly IJwtRequestUriHttpClient _jwtRequestUriHttpClient;
    private readonly ILogger _logger;

    private readonly ResponseTypeEqualityComparer
        _responseTypeEqualityComparer = new ResponseTypeEqualityComparer();

    public AuthorizeRequestValidator(
        IdentityServerOptions options,
        IClientStore clients,
        ICustomAuthorizeRequestValidator customValidator,
        IRedirectUriValidator uriValidator,
        IResourceValidator resourceValidator,
        IUserSession userSession,
        JwtRequestValidator jwtRequestValidator,
        IJwtRequestUriHttpClient jwtRequestUriHttpClient,
        ILogger logger)
    {
        _options = options;
        _clients = clients;
        _customValidator = customValidator;
        _uriValidator = uriValidator;
        _resourceValidator = resourceValidator;
        _jwtRequestValidator = jwtRequestValidator;
        _userSession = userSession;
        _jwtRequestUriHttpClient = jwtRequestUriHttpClient;
        _logger = logger;
    }

    public async Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject = null)
    {
        _logger.LogDebug("Start authorize request protocol validation");

        var request = new ValidatedAuthorizeRequest
        {
            Options = _options,
            Subject = subject ?? Principal.Anonymous,
            Raw = parameters ?? throw new ArgumentNullException(nameof(parameters))
        };
        
        // load client_id
        // client_id must always be present on the request
        var loadClientResult = await LoadClientAsync(request);
        if (loadClientResult.IsError)
        {
            return loadClientResult;
        }

        // load request object
        var roLoadResult = await LoadRequestObjectAsync(request);
        if (roLoadResult.IsError)
        {
            return roLoadResult;
        }

        // validate request object
        var roValidationResult = await ValidateRequestObjectAsync(request);
        if (roValidationResult.IsError)
        {
            return roValidationResult;
        }

        // validate client_id and redirect_uri
        var clientResult = await ValidateClientAsync(request);
        if (clientResult.IsError)
        {
            return clientResult;
        }

        // state, response_type, response_mode
        var mandatoryResult = ValidateCoreParameters(request);
        if (mandatoryResult.IsError)
        {
            return mandatoryResult;
        }

        // scope, scope restrictions and plausability
        var scopeResult = await ValidateScopeAsync(request);
        if (scopeResult.IsError)
        {
            return scopeResult;
        }

        // nonce, prompt, acr_values, login_hint etc.
        var optionalResult = await ValidateOptionalParametersAsync(request);
        if (optionalResult.IsError)
        {
            return optionalResult;
        }

        // custom validator
        _logger.LogDebug("Calling into custom validator: {type}", _customValidator.GetType().FullName);
        var context = new CustomAuthorizeRequestValidationContext
        {
            Result = new AuthorizeRequestValidationResult(request)
        };
        await _customValidator.ValidateAsync(context);

        var customResult = context.Result;
        if (customResult.IsError)
        {
            LogError("Error in custom validation", customResult.Error, request);
            return Invalid(request, customResult.Error, customResult.ErrorDescription);
        }

        _logger.LogTrace("Authorize request protocol validation successful");

        return Valid(request);
    }

    private async Task LoadRequestObjectAsync(ValidatedAuthorizeRequest request)
    {
        var jwtRequest = request.Raw.Get(OidcConstants.AuthorizeRequest.Request);
        var jwtRequestUri = request.Raw.Get(OidcConstants.AuthorizeRequest.RequestUri);

        if (jwtRequest.IsPresent() && jwtRequestUri.IsPresent())
        {
            LogError("Both request and request_uri are present", request);
            return Invalid(request, description: "Only one request parameter is allowed");
        }

        if (_options.Endpoints.EnableJwtRequestUri)
        {
            if (jwtRequestUri.IsPresent())
            {
                // 512 is from the spec
                if (jwtRequestUri.Length > 512)
                {
                    LogError("request_uri is too long", request);
                    return Invalid(request, error: OidcConstants.AuthorizeErrors.InvalidRequestUri, description: "request_uri is too long");
                }

                var jwt = await _jwtRequestUriHttpClient.GetJwtAsync(jwtRequestUri, request.Client);
                if (jwt.IsMissing())
                {
                    LogError("no value returned from request_uri", request);
                    return Invalid(request, error: OidcConstants.AuthorizeErrors.InvalidRequestUri, description: "no value returned from request_uri");
                }

                jwtRequest = jwt;
            }
        }
        else if (jwtRequestUri.IsPresent())
        {
            LogError("request_uri present but config prohibits", request);
            return Invalid(request, error: OidcConstants.AuthorizeErrors.RequestUriNotSupported);
        }

        // check length restrictions
        if (jwtRequest.IsPresent())
        {
            if (jwtRequest.Length >= _options.InputLengthRestrictions.Jwt)
            {
                LogError("request value is too long", request);
                return Invalid(request, error: OidcConstants.AuthorizeErrors.InvalidRequestObject, description: "Invalid request value");
            }
        }

        request.RequestObject = jwtRequest;
        return Valid(request);
    }

    private async Task LoadClientAsync(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // client_id must be present
        /////////////////////////////////////////////////////////
        var clientId = request.Raw.Get(OidcConstants.AuthorizeRequest.ClientId);

        if (clientId.IsMissingOrTooLong(_options.InputLengthRestrictions.ClientId))
        {
            LogError("client_id is missing or too long", request);
            return Invalid(request, description: "Invalid client_id");
        }

        request.ClientId = clientId;

        //////////////////////////////////////////////////////////
        // check for valid client
        //////////////////////////////////////////////////////////
        var client = await _clients.FindEnabledClientByIdAsync(request.ClientId);
        if (client == null)
        {
            LogError("Unknown client or not enabled", request.ClientId, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient, "Unknown client or client not enabled");
        }

        request.SetClient(client);

        return Valid(request);
    }

    private async Task ValidateRequestObjectAsync(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // validate request object
        /////////////////////////////////////////////////////////
        if (request.RequestObject.IsPresent())
        {
            // validate the request JWT for this client
            var jwtRequestValidationResult = await _jwtRequestValidator.ValidateAsync(request.Client, request.RequestObject);
            if (jwtRequestValidationResult.IsError)
            {
                LogError("request JWT validation failure", request);
                return Invalid(request, error: OidcConstants.AuthorizeErrors.InvalidRequestObject, description: "Invalid JWT request");
            }

            // validate response_type match
            var responseType = request.Raw.Get(OidcConstants.AuthorizeRequest.ResponseType);
            if (responseType != null)
            {
                if (jwtRequestValidationResult.Payload.TryGetValue(OidcConstants.AuthorizeRequest.ResponseType, out var payloadResponseType))
                {
                    if (payloadResponseType != responseType)
                    {
                        LogError("response_type in JWT payload does not match response_type in request", request);
                        return Invalid(request, description: "Invalid JWT request");
                    }
                }
            }

            // validate client_id mismatch
            if (jwtRequestValidationResult.Payload.TryGetValue(OidcConstants.AuthorizeRequest.ClientId, out var payloadClientId))
            {
                if (!string.Equals(request.Client.ClientId, payloadClientId, StringComparison.Ordinal))
                {
                    LogError("client_id in JWT payload does not match client_id in request", request);
                    return Invalid(request, description: "Invalid JWT request");
                }
            }
            else
            {
                LogError("client_id is missing in JWT payload", request);
                return Invalid(request, error: OidcConstants.AuthorizeErrors.InvalidRequestObject, description: "Invalid JWT request");
            }

            var ignoreKeys = new[]
            {
                JwtClaimTypes.Issuer,
                JwtClaimTypes.Audience
            };

            // merge jwt payload values into original request parameters
            foreach (var key in jwtRequestValidationResult.Payload.Keys)
            {
                if (ignoreKeys.Contains(key)) continue;
                
                var value = jwtRequestValidationResult.Payload[key];
                
                var qsValue = request.Raw.Get(key);
                if (qsValue != null)
                {
                    if (!string.Equals(value, qsValue, StringComparison.Ordinal))
                    {
                        LogError("parameter mismatch between request object and query string parameter.", request);
                        return Invalid(request, description: "Parameter mismatch in JWT request");
                    }
                }

                request.Raw.Set(key, value);
            }

            request.RequestObjectValues = jwtRequestValidationResult.Payload;
        }

        return Valid(request);
    }

    private async Task ValidateClientAsync(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // check request object requirement
        //////////////////////////////////////////////////////////
        if (request.Client.RequireRequestObject)
        {
            if (!request.RequestObjectValues.Any())
            {
                return Invalid(request, description: "Client must use request object, but no request or request_uri parameter present");
            }
        }

        //////////////////////////////////////////////////////////
        // redirect_uri must be present, and a valid uri
        //////////////////////////////////////////////////////////
        var redirectUri = request.Raw.Get(OidcConstants.AuthorizeRequest.RedirectUri);

        if (redirectUri.IsMissingOrTooLong(_options.InputLengthRestrictions.RedirectUri))
        {
            LogError("redirect_uri is missing or too long", request);
            return Invalid(request, description: "Invalid redirect_uri");
        }

        if (!Uri.TryCreate(redirectUri, UriKind.Absolute, out _))
        {
            LogError("malformed redirect_uri", redirectUri, request);
            return Invalid(request, description: "Invalid redirect_uri");
        }

        //////////////////////////////////////////////////////////
        // check if client protocol type is oidc
        //////////////////////////////////////////////////////////
        if (request.Client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
        {
            LogError("Invalid protocol type for OIDC authorize endpoint", request.Client.ProtocolType, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient, description: "Invalid protocol");
        }

        //////////////////////////////////////////////////////////
        // check if redirect_uri is valid
        //////////////////////////////////////////////////////////
        if (await _uriValidator.IsRedirectUriValidAsync(redirectUri, request.Client) == false)
        {
            LogError("Invalid redirect_uri", redirectUri, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.InvalidRequest, "Invalid redirect_uri");
        }

        request.RedirectUri = redirectUri;

        return Valid(request);
    }

    private AuthorizeRequestValidationResult ValidateCoreParameters(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // check state
        //////////////////////////////////////////////////////////
        var state = request.Raw.Get(OidcConstants.AuthorizeRequest.State);
        if (state.IsPresent())
        {
            request.State = state;
        }

        //////////////////////////////////////////////////////////
        // response_type must be present and supported
        //////////////////////////////////////////////////////////
        var responseType = request.Raw.Get(OidcConstants.AuthorizeRequest.ResponseType);
        if (responseType.IsMissing())
        {
            LogError("Missing response_type", request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnsupportedResponseType, "Missing response_type");
        }

        // The responseType may come in in an unconventional order.
        // Use an IEqualityComparer that doesn't care about the order of multiple values.
        // Per https://tools.ietf.org/html/rfc6749#section-3.1.1 -
        // 'Extension response types MAY contain a space-delimited (%x20) list of
        // values, where the order of values does not matter (e.g., response
        // type "a b" is the same as "b a").'
        // http://openid.net/specs/oauth-v2-multiple-response-types-1_0-03.html#terminology -
        // 'If a response type contains one of more space characters (%20), it is compared
        // as a space-delimited list of values in which the order of values does not matter.'
        if (!Constants.SupportedResponseTypes.Contains(responseType, _responseTypeEqualityComparer))
        {
            LogError("Response type not supported", responseType, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnsupportedResponseType, "Response type not supported");
        }

        // Even though the responseType may have come in in an unconventional order,
        // we still need the request's ResponseType property to be set to the
        // conventional, supported response type.
        request.ResponseType = Constants.SupportedResponseTypes.First(
            supportedResponseType => _responseTypeEqualityComparer.Equals(supportedResponseType, responseType));

        //////////////////////////////////////////////////////////
        // match response_type to grant type
        //////////////////////////////////////////////////////////
        request.GrantType = Constants.ResponseTypeToGrantTypeMapping[request.ResponseType];

        // set default response mode for flow; this is needed for any client error processing below
        request.ResponseMode = Constants.AllowedResponseModesForGrantType[request.GrantType].First();

        //////////////////////////////////////////////////////////
        // check if flow is allowed at authorize endpoint
        //////////////////////////////////////////////////////////
        if (!Constants.AllowedGrantTypesForAuthorizeEndpoint.Contains(request.GrantType))
        {
            LogError("Invalid grant type", request.GrantType, request);
            return Invalid(request, description: "Invalid response_type");
        }

        //////////////////////////////////////////////////////////
        // check if PKCE is required and validate parameters
        //////////////////////////////////////////////////////////
        if (request.GrantType == GrantType.AuthorizationCode || request.GrantType == GrantType.Hybrid)
        {
            _logger.LogDebug("Checking for PKCE parameters");

            /////////////////////////////////////////////////////////////////////////////
            // validate code_challenge and code_challenge_method
            /////////////////////////////////////////////////////////////////////////////
            var proofKeyResult = ValidatePkceParameters(request);

            if (proofKeyResult.IsError)
            {
                return proofKeyResult;
            }
        }

        //////////////////////////////////////////////////////////
        // check response_mode parameter and set response_mode
        //////////////////////////////////////////////////////////

        // check if response_mode parameter is present and valid
        var responseMode = request.Raw.Get(OidcConstants.AuthorizeRequest.ResponseMode);
        if (responseMode.IsPresent())
        {
            if (Constants.SupportedResponseModes.Contains(responseMode))
            {
                if (Constants.AllowedResponseModesForGrantType[request.GrantType].Contains(responseMode))
                {
                    request.ResponseMode = responseMode;
                }
                else
                {
                    LogError("Invalid response_mode for response_type", responseMode, request);
                    return Invalid(request, OidcConstants.AuthorizeErrors.InvalidRequest, description: "Invalid response_mode for response_type");
                }
            }
            else
            {
                LogError("Unsupported response_mode", responseMode, request);
                return Invalid(request, OidcConstants.AuthorizeErrors.UnsupportedResponseType, description: "Invalid response_mode");
            }
        }


        //////////////////////////////////////////////////////////
        // check if grant type is allowed for client
        //////////////////////////////////////////////////////////
        if (!request.Client.AllowedGrantTypes.Contains(request.GrantType))
        {
            LogError("Invalid grant type for client", request.GrantType, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient, "Invalid grant type for client");
        }

        //////////////////////////////////////////////////////////
        // check if response type contains an access token,
        // and if client is allowed to request access token via browser
        //////////////////////////////////////////////////////////
        var responseTypes = responseType.FromSpaceSeparatedString();
        if (responseTypes.Contains(OidcConstants.ResponseTypes.Token))
        {
            if (!request.Client.AllowAccessTokensViaBrowser)
            {
                LogError("Client requested access token - but client is not configured to receive access tokens via browser", request);
                return Invalid(request, description: "Client not configured to receive access tokens via browser");
            }
        }

        return Valid(request);
    }

    private AuthorizeRequestValidationResult ValidatePkceParameters(ValidatedAuthorizeRequest request)
    {
        var fail = Invalid(request);

        var codeChallenge = request.Raw.Get(OidcConstants.AuthorizeRequest.CodeChallenge);
        if (codeChallenge.IsMissing())
        {
            if (request.Client.RequirePkce)
            {
                LogError("code_challenge is missing", request);
                fail.ErrorDescription = "code challenge required";
            }
            else
            {
                _logger.LogDebug("No PKCE used.");
                return Valid(request);
            }

            return fail;
        }

        if (codeChallenge.Length < _options.InputLengthRestrictions.CodeChallengeMinLength ||
            codeChallenge.Length > _options.InputLengthRestrictions.CodeChallengeMaxLength)
        {
            LogError("code_challenge is either too short or too long", request);
            fail.ErrorDescription = "Invalid code_challenge";
            return fail;
        }

        request.CodeChallenge = codeChallenge;

        var codeChallengeMethod = request.Raw.Get(OidcConstants.AuthorizeRequest.CodeChallengeMethod);
        if (codeChallengeMethod.IsMissing())
        {
            _logger.LogDebug("Missing code_challenge_method, defaulting to plain");
            codeChallengeMethod = OidcConstants.CodeChallengeMethods.Plain;
        }

        if (!Constants.SupportedCodeChallengeMethods.Contains(codeChallengeMethod))
        {
            LogError("Unsupported code_challenge_method", codeChallengeMethod, request);
            fail.ErrorDescription = "Transform algorithm not supported";
            return fail;
        }

        // check if plain method is allowed
        if (codeChallengeMethod == OidcConstants.CodeChallengeMethods.Plain)
        {
            if (!request.Client.AllowPlainTextPkce)
            {
                LogError("code_challenge_method of plain is not allowed", request);
                fail.ErrorDescription = "Transform algorithm not supported";
                return fail;
            }
        }

        request.CodeChallengeMethod = codeChallengeMethod;

        return Valid(request);
    }

    private async Task ValidateScopeAsync(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // scope must be present
        //////////////////////////////////////////////////////////
        var scope = request.Raw.Get(OidcConstants.AuthorizeRequest.Scope);
        if (scope.IsMissing())
        {
            LogError("scope is missing", request);
            return Invalid(request, description: "Invalid scope");
        }

        if (scope.Length > _options.InputLengthRestrictions.Scope)
        {
            LogError("scopes too long.", request);
            return Invalid(request, description: "Invalid scope");
        }

        request.RequestedScopes = scope.FromSpaceSeparatedString().Distinct().ToList();

        if (request.RequestedScopes.Contains(IdentityServerConstants.StandardScopes.OpenId))
        {
            request.IsOpenIdRequest = true;
        }

        //////////////////////////////////////////////////////////
        // check scope vs response_type plausability
        //////////////////////////////////////////////////////////
        var requirement = Constants.ResponseTypeToScopeRequirement[request.ResponseType];
        if (requirement == Constants.ScopeRequirement.Identity ||
            requirement == Constants.ScopeRequirement.IdentityOnly)
        {
            if (request.IsOpenIdRequest == false)
            {
                LogError("response_type requires the openid scope", request);
                return Invalid(request, description: "Missing openid scope");
            }
        }

        //////////////////////////////////////////////////////////
        // check if scopes are valid/supported and check for resource scopes
        //////////////////////////////////////////////////////////
        var validatedResources = await _resourceValidator.ValidateRequestedResourcesAsync(new ResourceValidationRequest
        {
            Client = request.Client,
            Scopes = request.RequestedScopes
        });

        if (!validatedResources.Succeeded)
        {
            return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope, "Invalid scope");
        }

        if (validatedResources.Resources.IdentityResources.Any() && !request.IsOpenIdRequest)
        {
            LogError("Identity related scope requests, but no openid scope", request);
            return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope, "Identity scopes requested, but openid scope is missing");
        }

        if (validatedResources.Resources.ApiScopes.Any())
        {
            request.IsApiResourceRequest = true;
        }

        //////////////////////////////////////////////////////////
        // check id vs resource scopes and response types plausability
        //////////////////////////////////////////////////////////
        var responseTypeValidationCheck = true;
        switch (requirement)
        {
            case Constants.ScopeRequirement.Identity:
                if (!validatedResources.Resources.IdentityResources.Any())
                {
                    _logger.LogError("Requests for id_token response type must include identity scopes");
                    responseTypeValidationCheck = false;
                }
                break;
            case Constants.ScopeRequirement.IdentityOnly:
                if (!validatedResources.Resources.IdentityResources.Any() || validatedResources.Resources.ApiScopes.Any())
                {
                    _logger.LogError("Requests for id_token response type only must not include resource scopes");
                    responseTypeValidationCheck = false;
                }
                break;
            case Constants.ScopeRequirement.ResourceOnly:
                if (validatedResources.Resources.IdentityResources.Any() || !validatedResources.Resources.ApiScopes.Any())
                {
                    _logger.LogError("Requests for token response type only must include resource scopes, but no identity scopes.");
                    responseTypeValidationCheck = false;
                }
                break;
        }

        if (!responseTypeValidationCheck)
        {
            return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope, "Invalid scope for response type");
        }

        request.ValidatedResources = validatedResources;

        return Valid(request);
    }

    private async Task ValidateOptionalParametersAsync(ValidatedAuthorizeRequest request)
    {
        //////////////////////////////////////////////////////////
        // check nonce
        //////////////////////////////////////////////////////////
        var nonce = request.Raw.Get(OidcConstants.AuthorizeRequest.Nonce);
        if (nonce.IsPresent())
        {
            if (nonce.Length > _options.InputLengthRestrictions.Nonce)
            {
                LogError("Nonce too long", request);
                return Invalid(request, description: "Invalid nonce");
            }

            request.Nonce = nonce;
        }
        else
        {
            if (request.GrantType == GrantType.Implicit ||
                request.GrantType == GrantType.Hybrid)
            {
                // only openid requests require nonce
                if (request.IsOpenIdRequest)
                {
                    LogError("Nonce required for implicit and hybrid flow with openid scope", request);
                    return Invalid(request, description: "Invalid nonce");
                }
            }
        }


        //////////////////////////////////////////////////////////
        // check prompt
        //////////////////////////////////////////////////////////
        var prompt = request.Raw.Get(OidcConstants.AuthorizeRequest.Prompt);
        if (prompt.IsPresent())
        {
            var prompts = prompt.Split(' ', StringSplitOptions.RemoveEmptyEntries);
            if (prompts.All(p => Constants.SupportedPromptModes.Contains(p)))
            {
                if (prompts.Contains(OidcConstants.PromptModes.None) && prompts.Length > 1)
                {
                    LogError("prompt contains 'none' and other values. 'none' should be used by itself.", request);
                    return Invalid(request, description: "Invalid prompt");
                }

                request.PromptModes = prompts;
            }
            else
            {
                _logger.LogDebug("Unsupported prompt mode - ignored: " + prompt);
            }
        }

        //////////////////////////////////////////////////////////
        // check ui locales
        //////////////////////////////////////////////////////////
        var uilocales = request.Raw.Get(OidcConstants.AuthorizeRequest.UiLocales);
        if (uilocales.IsPresent())
        {
            if (uilocales.Length > _options.InputLengthRestrictions.UiLocale)
            {
                LogError("UI locale too long", request);
                return Invalid(request, description: "Invalid ui_locales");
            }

            request.UiLocales = uilocales;
        }

        //////////////////////////////////////////////////////////
        // check display
        //////////////////////////////////////////////////////////
        var display = request.Raw.Get(OidcConstants.AuthorizeRequest.Display);
        if (display.IsPresent())
        {
            if (Constants.SupportedDisplayModes.Contains(display))
            {
                request.DisplayMode = display;
            }

            _logger.LogDebug("Unsupported display mode - ignored: " + display);
        }

        //////////////////////////////////////////////////////////
        // check max_age
        //////////////////////////////////////////////////////////
        var maxAge = request.Raw.Get(OidcConstants.AuthorizeRequest.MaxAge);
        if (maxAge.IsPresent())
        {
            if (int.TryParse(maxAge, out var seconds))
            {
                if (seconds >= 0)
                {
                    request.MaxAge = seconds;
                }
                else
                {
                    LogError("Invalid max_age.", request);
                    return Invalid(request, description: "Invalid max_age");
                }
            }
            else
            {
                LogError("Invalid max_age.", request);
                return Invalid(request, description: "Invalid max_age");
            }
        }

        //////////////////////////////////////////////////////////
        // check login_hint
        //////////////////////////////////////////////////////////
        var loginHint = request.Raw.Get(OidcConstants.AuthorizeRequest.LoginHint);
        if (loginHint.IsPresent())
        {
            if (loginHint.Length > _options.InputLengthRestrictions.LoginHint)
            {
                LogError("Login hint too long", request);
                return Invalid(request, description: "Invalid login_hint");
            }

            request.LoginHint = loginHint;
        }

        //////////////////////////////////////////////////////////
        // check acr_values
        //////////////////////////////////////////////////////////
        var acrValues = request.Raw.Get(OidcConstants.AuthorizeRequest.AcrValues);
        if (acrValues.IsPresent())
        {
            if (acrValues.Length > _options.InputLengthRestrictions.AcrValues)
            {
                LogError("Acr values too long", request);
                return Invalid(request, description: "Invalid acr_values");
            }

            request.AuthenticationContextReferenceClasses = acrValues.FromSpaceSeparatedString().Distinct().ToList();
        }

        //////////////////////////////////////////////////////////
        // check custom acr_values: idp
        //////////////////////////////////////////////////////////
        var idp = request.GetIdP();
        if (idp.IsPresent())
        {
            // if idp is present but client does not allow it, strip it from the request message
            if (request.Client.IdentityProviderRestrictions != null && request.Client.IdentityProviderRestrictions.Any())
            {
                if (!request.Client.IdentityProviderRestrictions.Contains(idp))
                {
                    _logger.LogWarning("idp requested ({idp}) is not in client restriction list.", idp);
                    request.RemoveIdP();
                }
            }
        }

        //////////////////////////////////////////////////////////
        // check session cookie
        //////////////////////////////////////////////////////////
        if (_options.Endpoints.EnableCheckSessionEndpoint)
        {
            if (request.Subject.IsAuthenticated())
            {
                var sessionId = await _userSession.GetSessionIdAsync();
                if (sessionId.IsPresent())
                {
                    request.SessionId = sessionId;
                }
                else
                {
                    LogError("Check session endpoint enabled, but SessionId is missing", request);
                }
            }
            else
            {
                request.SessionId = ""; // empty string for anonymous users
            }
        }

        return Valid(request);
    }

    private AuthorizeRequestValidationResult Invalid(ValidatedAuthorizeRequest request, string error = OidcConstants.AuthorizeErrors.InvalidRequest, string description = null)
    {
        return new AuthorizeRequestValidationResult(request, error, description);
    }

    private AuthorizeRequestValidationResult Valid(ValidatedAuthorizeRequest request)
    {
        return new AuthorizeRequestValidationResult(request);
    }

    private void LogError(string message, ValidatedAuthorizeRequest request)
    {
        var requestDetails = new AuthorizeRequestValidationLog(request, _options.Logging.AuthorizeRequestSensitiveValuesFilter);
        _logger.LogError(message + "\n{@requestDetails}", requestDetails);
    }

    private void LogError(string message, string detail, ValidatedAuthorizeRequest request)
    {
        var requestDetails = new AuthorizeRequestValidationLog(request, _options.Logging.AuthorizeRequestSensitiveValuesFilter);
        _logger.LogError(message + ": {detail}\n{@requestDetails}", detail, requestDetails);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/BasicAuthenticationSecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Parses a Basic Authentication header
/// 
public class BasicAuthenticationSecretParser : ISecretParser
{
    private readonly ILogger _logger;
    private readonly IdentityServerOptions _options;

    /// 
    /// Creates the parser with a reference to identity server options
    /// 
    /// IdentityServer options
    /// The logger
    public BasicAuthenticationSecretParser(IdentityServerOptions options, ILogger logger)
    {
        _options = options;
        _logger = logger;
    }

    /// 
    /// Returns the authentication method name that this parser implements
    /// 
    /// 
    /// The authentication method.
    /// 
    public string AuthenticationMethod => OidcConstants.EndpointAuthenticationMethods.BasicAuthentication;

    /// 
    /// Tries to find a secret that can be used for authentication
    /// 
    /// 
    /// A parsed secret
    /// 
    public Task ParseAsync(HttpContext context)
    {
        _logger.LogDebug("Start parsing Basic Authentication secret");

        var notfound = Task.FromResult(null);
        var authorizationHeader = context.Request.Headers["Authorization"].FirstOrDefault();

        if (authorizationHeader.IsMissing())
        {
            return notfound;
        }

        if (!authorizationHeader.StartsWith("Basic ", StringComparison.OrdinalIgnoreCase))
        {
            return notfound;
        }

        var parameter = authorizationHeader.Substring("Basic ".Length);

        string pair;
        try
        {
            pair = Encoding.UTF8.GetString(
                Convert.FromBase64String(parameter));
        }
        catch (FormatException)
        {
            _logger.LogWarning("Malformed Basic Authentication credential.");
            return notfound;
        }
        catch (ArgumentException)
        {
            _logger.LogWarning("Malformed Basic Authentication credential.");
            return notfound;
        }

        var ix = pair.IndexOf(':');
        if (ix == -1)
        {
            _logger.LogWarning("Malformed Basic Authentication credential.");
            return notfound;
        }

        var clientId = pair.Substring(0, ix);
        var secret = pair.Substring(ix + 1);

        if (clientId.IsPresent())
        {
            if (clientId.Length > _options.InputLengthRestrictions.ClientId)
            {
                _logger.LogError("Client ID exceeds maximum length.");
                return notfound;
            }

            if (secret.IsPresent())
            {
                if (secret.Length > _options.InputLengthRestrictions.ClientSecret)
                {
                    _logger.LogError("Client secret exceeds maximum length.");
                    return notfound;
                }

                var parsedSecret = new ParsedSecret
                {
                    Id = Decode(clientId),
                    Credential = Decode(secret),
                    Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
                };

                return Task.FromResult(parsedSecret);
            }
            else
            {
                // client secret is optional
                _logger.LogDebug("client id without secret found");

                var parsedSecret = new ParsedSecret
                {
                    Id = Decode(clientId),
                    Type = IdentityServerConstants.ParsedSecretTypes.NoSecret
                };

                return Task.FromResult(parsedSecret);
            }
        }

        _logger.LogDebug("No Basic Authentication secret found");
        return notfound;
    }

    // RFC6749 says individual values must be application/x-www-form-urlencoded
    // 2.3.1
    private string Decode(string value)
    {
        if (value.IsMissing()) return string.Empty;

        return Uri.UnescapeDataString(value.Replace("+", "%20"));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/BearerTokenUsageValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates a request that uses a bearer token for authentication
/// 
internal class BearerTokenUsageValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public BearerTokenUsageValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Validates the request.
    /// 
    /// The context.
    /// 
    public async Task ValidateAsync(HttpContext context)
    {
        var result = ValidateAuthorizationHeader(context);
        if (result.TokenFound)
        {
            _logger.LogDebug("Bearer token found in header");
            return result;
        }

        if (context.Request.HasApplicationFormContentType())
        {
            result = await ValidatePostBodyAsync(context);
            if (result.TokenFound)
            {
                _logger.LogDebug("Bearer token found in body");
                return result;
            }
        }

        _logger.LogDebug("Bearer token not found");
        return new BearerTokenUsageValidationResult();
    }

    /// 
    /// Validates the authorization header.
    /// 
    /// The context.
    /// 
    public BearerTokenUsageValidationResult ValidateAuthorizationHeader(HttpContext context)
    {
        var authorizationHeader = context.Request.Headers["Authorization"].FirstOrDefault();
        if (authorizationHeader.IsPresent())
        {
            var header = authorizationHeader.Trim();
            if (header.StartsWith(OidcConstants.AuthenticationSchemes.AuthorizationHeaderBearer))
            {
                var value = header.Substring(OidcConstants.AuthenticationSchemes.AuthorizationHeaderBearer.Length).Trim();
                if (value.IsPresent())
                {
                    return new BearerTokenUsageValidationResult
                    {
                        TokenFound = true,
                        Token = value,
                        UsageType = BearerTokenUsageType.AuthorizationHeader
                    };
                }
            }
            else
            {
                _logger.LogTrace("Unexpected header format: {header}", Ioc.Sanitizer.Log.Sanitize(header));
            }
        }

        return new BearerTokenUsageValidationResult();
    }

    /// 
    /// Validates the post body.
    /// 
    /// The context.
    /// 
    public async Task ValidatePostBodyAsync(HttpContext context)
    {
        var token = (await context.Request.ReadFormAsync())["access_token"].FirstOrDefault();
        if (token.IsPresent())
        {
            return new BearerTokenUsageValidationResult
            {
                TokenFound = true,
                Token = token,
                UsageType = BearerTokenUsageType.PostBody
            };
        }

        return new BearerTokenUsageValidationResult();
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/ClientSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates a client secret using the registered secret validators and parsers
/// 
public class ClientSecretValidator : IClientSecretValidator
{
    private readonly ILogger _logger;
    private readonly IClientStore _clients;
    private readonly IEventService _events;
    private readonly ISecretsListValidator _validator;
    private readonly ISecretsListParser _parser;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clients.
    /// The parser.
    /// The validator.
    /// The events.
    /// The logger.
    public ClientSecretValidator(IClientStore clients, ISecretsListParser parser, ISecretsListValidator validator, IEventService events, ILogger logger)
    {
        _clients = clients;
        _parser = parser;
        _validator = validator;
        _events = events;
        _logger = logger;
    }

    /// 
    /// Validates the current request.
    /// 
    /// The context.
    /// 
    public async Task ValidateAsync(HttpContext context)
    {
        _logger.LogDebug("Start client validation");

        var fail = new ClientSecretValidationResult
        {
            IsError = true
        };

        var parsedSecret = await _parser.ParseAsync(context);
        if (parsedSecret == null)
        {
            await RaiseFailureEventAsync("unknown", "No client id found");

            _logger.LogError("No client identifier found");
            return fail;
        }

        // load client
        var client = await _clients.FindEnabledClientByIdAsync(parsedSecret.Id);
        if (client == null)
        {
            await RaiseFailureEventAsync(parsedSecret.Id, "Unknown client");

            _logger.LogError("No client with id '{clientId}' found. aborting", Ioc.Sanitizer.Log.Sanitize(parsedSecret.Id));
            return fail;
        }

        SecretValidationResult secretValidationResult = null;
        if (!client.RequireClientSecret || client.IsImplicitOnly())
        {
            _logger.LogDebug("Public Client - skipping secret validation success");
        }
        else
        {
            secretValidationResult = await _validator.ValidateAsync(client.ClientSecrets, parsedSecret);
            if (secretValidationResult.Success == false)
            {
                await RaiseFailureEventAsync(client.ClientId, "Invalid client secret");
                _logger.LogError("Client secret validation failed for client: {clientId}.", client.ClientId);

                return fail;
            }
        }

        _logger.LogDebug("Client validation success");

        var success = new ClientSecretValidationResult
        {
            IsError = false,
            Client = client,
            Secret = parsedSecret,
            Confirmation = secretValidationResult?.Confirmation
        };

        await RaiseSuccessEventAsync(client.ClientId, parsedSecret.Type);
        return success;
    }

    private Task RaiseSuccessEventAsync(string clientId, string authMethod)
    {
        return _events.RaiseAsync(new ClientAuthenticationSuccessEvent(clientId, authMethod));
    }

    private Task RaiseFailureEventAsync(string clientId, string message)
    {
        return _events.RaiseAsync(new ClientAuthenticationFailureEvent(clientId, message));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultClientConfigurationValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default client configuration validator
/// 
/// 
public class DefaultClientConfigurationValidator : IClientConfigurationValidator
{
    private readonly IdentityServerOptions _options;

    /// 
    /// Constructor for DefaultClientConfigurationValidator
    /// 
    public DefaultClientConfigurationValidator(IdentityServerOptions options)
    {
        _options = options;
    }

    /// 
    /// Determines whether the configuration of a client is valid.
    /// 
    /// The context.
    /// 
    public async Task ValidateAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.ProtocolType == IdentityServerConstants.ProtocolTypes.OpenIdConnect)
        {
            await ValidateGrantTypesAsync(context);
            if (context.IsValid == false) return;

            await ValidateLifetimesAsync(context);
            if (context.IsValid == false) return;

            await ValidateRedirectUriAsync(context);
            if (context.IsValid == false) return;

            await ValidateAllowedCorsOriginsAsync(context);
            if (context.IsValid == false) return;

            await ValidateUriSchemesAsync(context);
            if (context.IsValid == false) return;

            await ValidateSecretsAsync(context);
            if (context.IsValid == false) return;

            await ValidatePropertiesAsync(context);
            if (context.IsValid == false) return;
        }
    }

    /// 
    /// Validates grant type related configuration settings.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidateGrantTypesAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.AllowedGrantTypes?.Any() != true)
        {
            context.SetError("no allowed grant type specified");
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates lifetime related configuration settings.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidateLifetimesAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.AccessTokenLifetime <= 0)
        {
            context.SetError("access token lifetime is 0 or negative");
            return Task.CompletedTask;
        }

        if (context.Client.IdentityTokenLifetime <= 0)
        {
            context.SetError("identity token lifetime is 0 or negative");
            return Task.CompletedTask;
        }

        if (context.Client.AllowedGrantTypes?.Contains(GrantType.DeviceFlow) == true
            && context.Client.DeviceCodeLifetime <= 0)
        {
            context.SetError("device code lifetime is 0 or negative");
        }

        // 0 means unlimited lifetime
        if (context.Client.AbsoluteRefreshTokenLifetime < 0)
        {
            context.SetError("absolute refresh token lifetime is negative");
            return Task.CompletedTask;
        }

        // 0 might mean that sliding is disabled
        if (context.Client.SlidingRefreshTokenLifetime < 0)
        {
            context.SetError("sliding refresh token lifetime is negative");
            return Task.CompletedTask;
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates redirect URI related configuration.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidateRedirectUriAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.AllowedGrantTypes?.Any() == true)
        {
            if (context.Client.AllowedGrantTypes.Contains(GrantType.AuthorizationCode) ||
                context.Client.AllowedGrantTypes.Contains(GrantType.Hybrid) ||
                context.Client.AllowedGrantTypes.Contains(GrantType.Implicit))
            {
                if (context.Client.RedirectUris?.Any() == false)
                {
                    context.SetError("No redirect URI configured.");
                }
            }
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates allowed CORS origins for valid format.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidateAllowedCorsOriginsAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.AllowedCorsOrigins?.Any() == true)
        {
            foreach (var origin in context.Client.AllowedCorsOrigins)
            {
                var fail = true;

                if (!string.IsNullOrWhiteSpace(origin) && Uri.TryCreate(origin, UriKind.Absolute, out var uri))
                {
                    if (uri.AbsolutePath == "/" && !origin.EndsWith("/"))
                    {
                        fail = false;
                    }
                }

                if (fail)
                {
                    if (!string.IsNullOrWhiteSpace(origin))
                    {
                        context.SetError($"AllowedCorsOrigins contains invalid origin: {origin}");
                    }
                    else
                    {
                        context.SetError($"AllowedCorsOrigins contains invalid origin. There is an empty value.");
                    }
                    return Task.CompletedTask;
                }
            }
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates that URI schemes is not in the list of invalid URI scheme prefixes, as controlled by the ValidationOptions.
    /// 
    /// 
    /// 
    protected virtual Task ValidateUriSchemesAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.RedirectUris?.Any() == true)
        {
            foreach (var uri in context.Client.RedirectUris)
            {
                if (_options.Validation.InvalidRedirectUriPrefixes
                        .Any(scheme => uri?.StartsWith(scheme, StringComparison.OrdinalIgnoreCase) == true))
                {
                    context.SetError($"RedirectUri '{uri}' uses invalid scheme. If this scheme should be allowed, then configure it via ValidationOptions.");
                }
            }
        }

        if (context.Client.PostLogoutRedirectUris?.Any() == true)
        {
            foreach (var uri in context.Client.PostLogoutRedirectUris)
            {
                if (_options.Validation.InvalidRedirectUriPrefixes
                        .Any(scheme => uri?.StartsWith(scheme, StringComparison.OrdinalIgnoreCase) == true))
                {
                    context.SetError($"PostLogoutRedirectUri '{uri}' uses invalid scheme. If this scheme should be allowed, then configure it via ValidationOptions.");
                }
            }
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates secret related configuration.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidateSecretsAsync(ClientConfigurationValidationContext context)
    {
        if (context.Client.AllowedGrantTypes?.Any() == true)
        {
            foreach (var grantType in context.Client.AllowedGrantTypes)
            {
                if (!string.Equals(grantType, GrantType.Implicit))
                {
                    if (context.Client.RequireClientSecret && context.Client.ClientSecrets.Count == 0)
                    {
                        context.SetError($"Client secret is required for {grantType}, but no client secret is configured.");
                        return Task.CompletedTask;
                    }
                }
            }
        }

        return Task.CompletedTask;
    }

    /// 
    /// Validates properties related configuration settings.
    /// 
    /// The context.
    /// 
    protected virtual Task ValidatePropertiesAsync(ClientConfigurationValidationContext context)
    {
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultCustomAuthorizeRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default custom request validator
/// 
internal class DefaultCustomAuthorizeRequestValidator : ICustomAuthorizeRequestValidator
{
    /// 
    /// Custom validation logic for the authorize request.
    /// 
    /// The context.
    public Task ValidateAsync(CustomAuthorizeRequestValidationContext context)
    {
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultCustomTokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default custom request validator
/// 
internal class DefaultCustomTokenRequestValidator : ICustomTokenRequestValidator
{
    /// 
    /// Custom validation logic for a token request.
    /// 
    /// The context.
    /// 
    /// The validation result
    /// 
    public Task ValidateAsync(CustomTokenRequestValidationContext context)
    {
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultCustomTokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default custom token validator
/// 
public class DefaultCustomTokenValidator : ICustomTokenValidator
{
    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;

    /// 
    /// The user service
    /// 
    protected readonly IProfileService Profile;

    /// 
    /// The client store
    /// 
    protected readonly IClientStore Clients;

    /// 
    /// Custom validation logic for access tokens.
    /// 
    /// The validation result so far.
    /// 
    /// The validation result
    /// 
    public virtual Task ValidateAccessTokenAsync(TokenValidationResult result)
    {
        return Task.FromResult(result);
    }

    /// 
    /// Custom validation logic for identity tokens.
    /// 
    /// The validation result so far.
    /// 
    /// The validation result
    /// 
    public virtual Task ValidateIdentityTokenAsync(TokenValidationResult result)
    {
        return Task.FromResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultResourceValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default implementation of IResourceValidator.
/// 
public class DefaultResourceValidator : IResourceValidator
{
    private readonly ILogger _logger;
    private readonly IScopeParser _scopeParser;
    private readonly IResourceStore _store;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The store.
    /// 
    /// The logger.
    public DefaultResourceValidator(IResourceStore store, IScopeParser scopeParser, ILogger logger)
    {
        _logger = logger;
        _scopeParser = scopeParser;
        _store = store;
    }

    /// 
    public virtual async Task ValidateRequestedResourcesAsync(ResourceValidationRequest request)
    {
        if (request == null) throw new ArgumentNullException(nameof(request));

        var parsedScopesResult = _scopeParser.ParseScopeValues(request.Scopes);

        var result = new ResourceValidationResult();
        
        if (!parsedScopesResult.Succeeded)
        {
            foreach (var invalidScope in parsedScopesResult.Errors)
            {
                _logger.LogError("Invalid parsed scope {scope}, message: {error}", Ioc.Sanitizer.Log.Sanitize(invalidScope.RawValue), Ioc.Sanitizer.Log.Sanitize(invalidScope.Error));
                result.InvalidScopes.Add(invalidScope.RawValue);
            }

            return result;
        }

        var scopeNames = parsedScopesResult.ParsedScopes.Select(x => x.ParsedName).Distinct().ToArray();
        var resourcesFromStore = await _store.FindEnabledResourcesByScopeAsync(scopeNames);

        foreach (var scope in parsedScopesResult.ParsedScopes)
        {
            await ValidateScopeAsync(request.Client, resourcesFromStore, scope, result);
        }

        if (result.InvalidScopes.Count > 0)
        {
            result.Resources.IdentityResources.Clear();
            result.Resources.ApiResources.Clear();
            result.Resources.ApiScopes.Clear();
            result.ParsedScopes.Clear();
        }

        return result;
    }

    /// 
    /// Validates that the requested scopes is contained in the store, and the client is allowed to request it.
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    protected virtual async Task ValidateScopeAsync(
        Client client, 
        Resources resourcesFromStore, 
        ParsedScopeValue requestedScope, 
        ResourceValidationResult result)
    {
        if (requestedScope.ParsedName == IdentityServerConstants.StandardScopes.OfflineAccess)
        {
            if (await IsClientAllowedOfflineAccessAsync(client))
            {
                result.Resources.OfflineAccess = true;
                result.ParsedScopes.Add(new ParsedScopeValue(IdentityServerConstants.StandardScopes.OfflineAccess));
            }
            else
            {
                result.InvalidScopes.Add(IdentityServerConstants.StandardScopes.OfflineAccess);
            }
        }
        else
        {
            var identity = resourcesFromStore.FindIdentityResourcesByScope(requestedScope.ParsedName);
            if (identity != null)
            {
                if (await IsClientAllowedIdentityResourceAsync(client, identity))
                {
                    result.ParsedScopes.Add(requestedScope);
                    result.Resources.IdentityResources.Add(identity);
                }
                else
                {
                    result.InvalidScopes.Add(requestedScope.RawValue);
                }
            }
            else
            {
                var apiScope = resourcesFromStore.FindApiScope(requestedScope.ParsedName);
                if (apiScope != null)
                {
                    if (await IsClientAllowedApiScopeAsync(client, apiScope))
                    {
                        result.ParsedScopes.Add(requestedScope);
                        result.Resources.ApiScopes.Add(apiScope);

                        var apis = resourcesFromStore.FindApiResourcesByScope(apiScope.Name);
                        foreach (var api in apis)
                        {
                            result.Resources.ApiResources.Add(api);
                        }
                    }
                    else
                    {
                        result.InvalidScopes.Add(requestedScope.RawValue);
                    }
                }
                else
                {
                    _logger.LogError("Scope {scope} not found in store.", requestedScope.ParsedName);
                    result.InvalidScopes.Add(requestedScope.RawValue);
                }
            }
        }
    }

    /// 
    /// Determines if client is allowed access to the identity scope.
    /// 
    /// 
    /// 
    /// 
    protected virtual Task IsClientAllowedIdentityResourceAsync(Client client, IdentityResource identity)
    {
        var allowed = client.AllowedScopes.Contains(identity.Name);
        if (!allowed)
        {
            _logger.LogError("Client {client} is not allowed access to scope {scope}.", client.ClientId, identity.Name);
        }
        return Task.FromResult(allowed);
    }

    /// 
    /// Determines if client is allowed access to the API scope.
    /// 
    /// 
    /// 
    /// 
    protected virtual Task IsClientAllowedApiScopeAsync(Client client, ApiScope apiScope)
    {
        var allowed = client.AllowedScopes.Contains(apiScope.Name);
        if (!allowed)
        {
            _logger.LogError("Client {client} is not allowed access to scope {scope}.", client.ClientId, apiScope.Name);
        }
        return Task.FromResult(allowed);
    }

    /// 
    /// Validates if the client is allowed offline_access.
    /// 
    /// 
    /// 
    protected virtual Task IsClientAllowedOfflineAccessAsync(Client client)
    {
        var allowed = client.AllowOfflineAccess;
        if (!allowed)
        {
            _logger.LogError("Client {client} is not allowed access to scope offline_access (via AllowOfflineAccess setting).", client.ClientId);
        }
        return Task.FromResult(allowed);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DefaultScopeParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default implementation of IScopeParser.
/// 
public class DefaultScopeParser : IScopeParser
{
    private readonly ILogger _logger;

    /// 
    /// Ctor.
    /// 
    /// 
    public DefaultScopeParser(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    public ParsedScopesResult ParseScopeValues(IEnumerable scopeValues)
    {
        if (scopeValues == null) throw new ArgumentNullException(nameof(scopeValues));

        var result = new ParsedScopesResult();

        foreach (var scopeValue in scopeValues)
        {
            var ctx = new ParseScopeContext(scopeValue);
            ParseScopeValue(ctx);
            
            if (ctx.Succeeded)
            {
                var parsedScope = ctx.ParsedName != null ?
                    new ParsedScopeValue(ctx.RawValue, ctx.ParsedName, ctx.ParsedParameter) :
                    new ParsedScopeValue(ctx.RawValue);

                result.ParsedScopes.Add(parsedScope);
            }
            else if (!ctx.Ignore)
            {
                result.Errors.Add(new ParsedScopeValidationError(scopeValue, ctx.Error));
            }
            else
            {
                _logger.LogDebug("Scope parsing ignoring scope {scope}", Ioc.Sanitizer.Log.Sanitize(scopeValue));
            }
        }

        return result;
    }

    /// 
    /// Parses a scope value.
    /// 
    /// 
    /// 
    public virtual void ParseScopeValue(ParseScopeContext scopeContext)
    {
        // nop leaves the raw scope value as a success result.
    }

    /// 
    /// Models the context for parsing a scope.
    /// 
    public class ParseScopeContext
    {
        /// 
        /// The original (raw) value of the scope.
        /// 
        public string RawValue { get; }

        /// 
        /// The parsed name of the scope. 
        /// 
        public string ParsedName { get; private set; }

        /// 
        /// The parsed parameter value of the scope. 
        /// 
        public string ParsedParameter { get; private set; }

        /// 
        /// The error encountered parsing the scope.
        /// 
        public string Error { get; private set; }
        
        /// 
        /// Indicates if the scope should be excluded from the parsed results.
        /// 
        public bool Ignore { get; private set; }

        /// 
        /// Indicates if parsing the scope was successful.
        /// 
        public bool Succeeded => !Ignore && Error == null;


        /// 
        /// Ctor. Indicates success, but the scope should not be included in result.
        /// 
        internal ParseScopeContext(string rawScopeValue)
        {
            RawValue = rawScopeValue;
        }

        /// 
        /// Sets the parsed name and parsed parameter value for the scope.
        /// 
        /// 
        /// 
        public void SetParsedValues(string parsedName, string parsedParameter)
        {
            if (String.IsNullOrWhiteSpace(parsedName))
            {
                throw new ArgumentNullException(nameof(parsedName));
            }
            if (String.IsNullOrWhiteSpace(parsedParameter))
            {
                throw new ArgumentNullException(nameof(parsedParameter));
            }

            ParsedName = parsedName;
            ParsedParameter = parsedParameter;
            Error = null;
            Ignore = false;
        }

        /// 
        /// Set the error encountered parsing the scope.
        /// 
        /// 
        public void SetError(string error)
        {
            ParsedName = null;
            ParsedParameter = null;
            Error = error;
            Ignore = false;
        }

        /// 
        /// Sets that the scope is to be ignore/excluded from the parsed results.
        /// 
        public void SetIgnore()
        {
            ParsedName = null;
            ParsedParameter = null;
            Error = null;
            Ignore = true;
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DeviceAuthorizationRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

internal class DeviceAuthorizationRequestValidator : IDeviceAuthorizationRequestValidator
{
    private readonly IdentityServerOptions _options;
    private readonly IResourceValidator _resourceValidator;
    private readonly ILogger _logger;
    
    public DeviceAuthorizationRequestValidator(
        IdentityServerOptions options,
        IResourceValidator resourceValidator,
        ILogger logger)
    {
        _options = options;
        _resourceValidator = resourceValidator;
        _logger = logger;
    }

    public async Task ValidateAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult)
    {
        _logger.LogDebug("Start device authorization request validation");

        var request = new ValidatedDeviceAuthorizationRequest
        {
            Raw = parameters ?? throw new ArgumentNullException(nameof(parameters)),
            Options = _options
        };

        var clientResult = ValidateClient(request, clientValidationResult);
        if (clientResult.IsError)
        {
            return clientResult;
        }

        var scopeResult = await ValidateScopeAsync(request);
        if (scopeResult.IsError)
        {
            return scopeResult;
        }

        _logger.LogDebug("{clientId} device authorization request validation success", request.Client.ClientId);
        return Valid(request);
    }

    private DeviceAuthorizationRequestValidationResult Valid(ValidatedDeviceAuthorizationRequest request)
    {
        return new DeviceAuthorizationRequestValidationResult(request);
    }

    private DeviceAuthorizationRequestValidationResult Invalid(ValidatedDeviceAuthorizationRequest request, string error = OidcConstants.AuthorizeErrors.InvalidRequest, string description = null)
    {
        return new DeviceAuthorizationRequestValidationResult(request, error, description);
    }

    private void LogError(string message, ValidatedDeviceAuthorizationRequest request)
    {
        var requestDetails = new DeviceAuthorizationRequestValidationLog(request);
        _logger.LogError(message + "\n{requestDetails}", requestDetails);
    }

    private void LogError(string message, string detail, ValidatedDeviceAuthorizationRequest request)
    {
        var requestDetails = new DeviceAuthorizationRequestValidationLog(request);
        _logger.LogError(message + ": {detail}\n{requestDetails}", detail, requestDetails);
    }

    private DeviceAuthorizationRequestValidationResult ValidateClient(ValidatedDeviceAuthorizationRequest request, ClientSecretValidationResult clientValidationResult)
    {
        //////////////////////////////////////////////////////////
        // set client & secret
        //////////////////////////////////////////////////////////
        if (clientValidationResult == null) throw new ArgumentNullException(nameof(clientValidationResult));
        request.SetClient(clientValidationResult.Client, clientValidationResult.Secret);

        //////////////////////////////////////////////////////////
        // check if client protocol type is oidc
        //////////////////////////////////////////////////////////
        if (request.Client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
        {
            LogError("Invalid protocol type for OIDC authorize endpoint", request.Client.ProtocolType, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient, "Invalid protocol");
        }

        //////////////////////////////////////////////////////////
        // check if client allows device flow
        //////////////////////////////////////////////////////////
        if (!request.Client.AllowedGrantTypes.Contains(GrantType.DeviceFlow))
        {
            LogError("Client not configured for device flow", GrantType.DeviceFlow, request);
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        return Valid(request);
    }

    private async Task ValidateScopeAsync(ValidatedDeviceAuthorizationRequest request)
    {
        //////////////////////////////////////////////////////////
        // scope must be present
        //////////////////////////////////////////////////////////
        var scope = request.Raw.Get(OidcConstants.AuthorizeRequest.Scope);
        if (scope.IsMissing())
        {
            _logger.LogTrace("Client provided no scopes - checking allowed scopes list");

            if (!request.Client.AllowedScopes.EnumerableIsNullOrEmpty())
            {
                var clientAllowedScopes = new List(request.Client.AllowedScopes);
                if (request.Client.AllowOfflineAccess)
                {
                    clientAllowedScopes.Add(IdentityServerConstants.StandardScopes.OfflineAccess);
                }
                scope = clientAllowedScopes.ToSpaceSeparatedString();
                _logger.LogTrace("Defaulting to: {scopes}", scope);
            }
            else
            {
                LogError("No allowed scopes configured for client", request);
                return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope);
            }
        }

        if (scope.Length > _options.InputLengthRestrictions.Scope)
        {
            LogError("scopes too long.", request);
            return Invalid(request, description: "Invalid scope");
        }

        request.RequestedScopes = scope.FromSpaceSeparatedString().Distinct().ToList();

        if (request.RequestedScopes.Contains(IdentityServerConstants.StandardScopes.OpenId))
        {
            request.IsOpenIdRequest = true;
        }

        //////////////////////////////////////////////////////////
        // check if scopes are valid/supported
        //////////////////////////////////////////////////////////
        var validatedResources = await _resourceValidator.ValidateRequestedResourcesAsync(new ResourceValidationRequest{
            Client = request.Client, 
            Scopes = request.RequestedScopes
        });

        if (!validatedResources.Succeeded)
        {
            if (validatedResources.InvalidScopes.Count > 0)
            {
                return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope);
            }
            
            return Invalid(request, OidcConstants.AuthorizeErrors.UnauthorizedClient, "Invalid scope");
        }

        if (validatedResources.Resources.IdentityResources.Any() && !request.IsOpenIdRequest)
        {
            LogError("Identity related scope requests, but no openid scope", request);
            return Invalid(request, OidcConstants.AuthorizeErrors.InvalidScope);
        }

        request.ValidatedResources = validatedResources;
        
        return Valid(request);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/DeviceCodeValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates an incoming token request using the device flow
/// 
internal class DeviceCodeValidator : IDeviceCodeValidator
{
    private readonly IDeviceFlowCodeService _devices;
    private readonly IProfileService _profile;
    private readonly IDeviceFlowThrottlingService _throttlingService;
    private readonly ISystemClock _systemClock;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The devices.
    /// The profile.
    /// The throttling service.
    /// The system clock.
    /// The logger.
    public DeviceCodeValidator(
        IDeviceFlowCodeService devices,
        IProfileService profile,
        IDeviceFlowThrottlingService throttlingService,
        ISystemClock systemClock,
        ILogger logger)
    {
        _devices = devices;
        _profile = profile;
        _throttlingService = throttlingService;
        _systemClock = systemClock;
        _logger = logger;
    }

    /// 
    /// Validates the device code.
    /// 
    /// The context.
    /// 
    public async Task ValidateAsync(DeviceCodeValidationContext context)
    {
        var deviceCode = await _devices.FindByDeviceCodeAsync(context.DeviceCode);

        if (deviceCode == null)
        {
            _logger.LogError("Invalid device code");
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.InvalidGrant);
            return;
        }
        
        // validate client binding
        if (deviceCode.ClientId != context.Request.Client.ClientId)
        {
            _logger.LogError("Client {0} is trying to use a device code from client {1}", context.Request.Client.ClientId, deviceCode.ClientId);
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.InvalidGrant);
            return;
        }

        if (await _throttlingService.ShouldSlowDown(context.DeviceCode, deviceCode))
        {
            _logger.LogError("Client {0} is polling too fast", deviceCode.ClientId);
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.SlowDown);
            return;
        }

        // validate lifetime
        if (deviceCode.CreationTime.AddSeconds(deviceCode.Lifetime) < _systemClock.UtcNow)
        {
            _logger.LogError("Expired device code");
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.ExpiredToken);
            return;
        }

        // denied
        if (deviceCode.IsAuthorized
            && (deviceCode.AuthorizedScopes == null || deviceCode.AuthorizedScopes.Any() == false))
        {
            _logger.LogError("No scopes authorized for device authorization. Access denied");
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.AccessDenied);
            return;
        }

        // make sure code is authorized
        if (!deviceCode.IsAuthorized || deviceCode.Subject == null)
        {
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.AuthorizationPending);
            return;
        }

        // make sure user is enabled
        var isActiveCtx = new IsActiveContext(deviceCode.Subject, context.Request.Client, IdentityServerConstants.ProfileIsActiveCallers.DeviceCodeValidation);
        await _profile.IsActiveAsync(isActiveCtx);

        if (isActiveCtx.IsActive == false)
        {
            _logger.LogError("User has been disabled: {subjectId}", deviceCode.Subject.GetSubjectId());
            context.Result = new TokenRequestValidationResult(context.Request, OidcConstants.TokenErrors.InvalidGrant);
            return;
        }

        context.Request.DeviceCode = deviceCode;
        context.Request.SessionId = deviceCode.SessionId;

        context.Result = new TokenRequestValidationResult(context.Request);
        await _devices.RemoveByDeviceCodeAsync(context.DeviceCode);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/EndSessionRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates requests to the end session endpoint.
/// 
public class EndSessionRequestValidator : IEndSessionRequestValidator
{
    /// 
    /// The logger.
    /// 
    protected readonly ILogger Logger;

    /// 
    ///  The IdentityServer options.
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// The token validator.
    /// 
    protected readonly ITokenValidator TokenValidator;

    /// 
    /// The URI validator.
    /// 
    protected readonly IRedirectUriValidator UriValidator;

    /// 
    /// The user session service.
    /// 
    protected readonly IUserSession UserSession;

    /// 
    /// The logout notification service.
    /// 
    public ILogoutNotificationService LogoutNotificationService { get; }

    /// 
    /// The end session message store.
    /// 
    protected readonly IMessageStore EndSessionMessageStore;

    /// 
    /// The HTTP context accessor.
    /// 
    protected readonly IHttpContextAccessor Context;

    /// 
    /// Creates a new instance of the EndSessionRequestValidator.
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    /// 
    public EndSessionRequestValidator(
        IHttpContextAccessor context,
        IdentityServerOptions options,
        ITokenValidator tokenValidator,
        IRedirectUriValidator uriValidator,
        IUserSession userSession,
        ILogoutNotificationService logoutNotificationService,
        IMessageStore endSessionMessageStore,
        ILogger logger)
    {
        Context = context;
        Options = options;
        TokenValidator = tokenValidator;
        UriValidator = uriValidator;
        UserSession = userSession;
        LogoutNotificationService = logoutNotificationService;
        EndSessionMessageStore = endSessionMessageStore;
        Logger = logger;
    }

    /// 
    public async Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject)
    {
        Logger.LogDebug("Start end session request validation");

        var isAuthenticated = subject.IsAuthenticated();

        if (!isAuthenticated && Options.Authentication.RequireAuthenticatedUserForSignOutMessage)
        {
            return Invalid("User is anonymous. Ignoring end session parameters");
        }

        var validatedRequest = new ValidatedEndSessionRequest
        {
            Raw = parameters
        };

        var idTokenHint = parameters.Get(OidcConstants.EndSessionRequest.IdTokenHint);
        if (idTokenHint.IsPresent())
        {
            // validate id_token - no need to validate token life time
            var tokenValidationResult = await TokenValidator.ValidateIdentityTokenAsync(idTokenHint, null, false);
            if (tokenValidationResult.IsError)
            {
                return Invalid("Error validating id token hint", validatedRequest);
            }

            validatedRequest.Client = tokenValidationResult.Client;

            // validate sub claim against currently logged on user
            var subClaim = tokenValidationResult.Claims.FirstOrDefault(c => c.Type == JwtClaimTypes.Subject);
            if (subClaim != null && isAuthenticated)
            {
                if (subject.GetSubjectId() != subClaim.Value)
                {
                    return Invalid("Current user does not match identity token", validatedRequest);
                }

                validatedRequest.Subject = subject;
                validatedRequest.SessionId = await UserSession.GetSessionIdAsync();
                validatedRequest.ClientIds = await UserSession.GetClientListAsync();
            }

            var redirectUri = parameters.Get(OidcConstants.EndSessionRequest.PostLogoutRedirectUri);
            if (redirectUri.IsPresent())
            {
                if (await UriValidator.IsPostLogoutRedirectUriValidAsync(redirectUri, validatedRequest.Client))
                {
                    validatedRequest.PostLogOutUri = redirectUri;
                }
                else
                {
                    Logger.LogWarning("Invalid PostLogoutRedirectUri: {postLogoutRedirectUri}", redirectUri);
                }
            }

            if (validatedRequest.PostLogOutUri != null)
            {
                var state = parameters.Get(OidcConstants.EndSessionRequest.State);
                if (state.IsPresent())
                {
                    validatedRequest.State = state;
                }
            }
        }
        else
        {
            // no id_token to authenticate the client, but we do have a user and a user session
            validatedRequest.Subject = subject;
            validatedRequest.SessionId = await UserSession.GetSessionIdAsync();
            validatedRequest.ClientIds = await UserSession.GetClientListAsync();
        }

        LogSuccess(validatedRequest);

        return new EndSessionValidationResult
        {
            ValidatedRequest = validatedRequest,
            IsError = false
        };
    }

    /// 
    /// Creates a result that indicates an error.
    /// 
    /// 
    /// 
    /// 
    protected virtual EndSessionValidationResult Invalid(string message, ValidatedEndSessionRequest request = null)
    {
        message = "End session request validation failure: " + message;
        if (request != null)
        {
            var log = new EndSessionRequestValidationLog(request);
            Logger.LogInformation(message + Environment.NewLine + "{@details}", log);
        }
        else
        {
            Logger.LogInformation(message);
        }

        return new EndSessionValidationResult
        {
            IsError = true,
            Error = "Invalid request",
            ErrorDescription = message
        };
    }

    /// 
    /// Logs a success result.
    /// 
    /// 
    protected virtual void LogSuccess(ValidatedEndSessionRequest request)
    {
        var log = new EndSessionRequestValidationLog(request);
        Logger.LogInformation("End session request validation success" + Environment.NewLine + "{@details}", log);
    }

    /// 
    public async Task ValidateCallbackAsync(NameValueCollection parameters)
    {
        var result = new EndSessionCallbackValidationResult
        {
            IsError = true
        };

        var endSessionId = parameters[Constants.UIConstants.DefaultRoutePathParams.EndSessionCallback];
        var endSessionMessage = await EndSessionMessageStore.ReadAsync(endSessionId);
        if (endSessionMessage?.Data?.ClientIds?.Any() == true)
        {
            result.IsError = false;
            result.FrontChannelLogoutUrls = await LogoutNotificationService.GetFrontChannelLogoutNotificationsUrlsAsync(endSessionMessage.Data);
        }
        else
        {
            result.Error = "Failed to read end session callback message";
        }

        return result;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/ExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates an extension grant request using the registered validators
/// 
public class ExtensionGrantValidator
{
    private readonly ILogger _logger;
    private readonly IEnumerable _validators;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The validators.
    /// The logger.
    public ExtensionGrantValidator(IEnumerable validators, ILogger logger)
    {
        if (validators == null)
        {
            _validators = Enumerable.Empty();
        }
        else
        {
            _validators = validators;
        }

        _logger = logger;
    }

    /// 
    /// Gets the available grant types.
    /// 
    /// 
    public IEnumerable GetAvailableGrantTypes()
    {
        return _validators.Select(v => v.GrantType);
    }

    /// 
    /// Validates the request.
    /// 
    /// The request.
    /// 
    public async Task ValidateAsync(ValidatedTokenRequest request)
    {
        var validator = _validators.FirstOrDefault(v => v.GrantType.Equals(request.GrantType, StringComparison.Ordinal));

        if (validator == null)
        {
            _logger.LogError("No validator found for grant type");
            return new GrantValidationResult(TokenRequestErrors.UnsupportedGrantType);
        }

        try
        {
            _logger.LogTrace("Calling into custom grant validator: {type}", validator.GetType().FullName);

            var context = new ExtensionGrantValidationContext
            {
                Request = request
            };
        
            await validator.ValidateAsync(context);
            return context.Result;
        }
        catch (Exception e)
        {
            _logger.LogError(1, e, "Grant validation error: {message}", e.Message);
            return new GrantValidationResult(TokenRequestErrors.InvalidGrant);
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/HashedSharedSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Secret = IdentityServer8.Models.Secret;


namespace IdentityServer8.Validation;

/// 
/// Validates a shared secret stored in SHA256 or SHA512
/// 
public class HashedSharedSecretValidator : ISecretValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public HashedSharedSecretValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Validates a secret
    /// 
    /// The stored secrets.
    /// The received secret.
    /// 
    /// A validation result
    /// 
    /// Id or cedential
    public Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var fail = Task.FromResult(new SecretValidationResult { Success = false });
        var success = Task.FromResult(new SecretValidationResult { Success = true });

        if (parsedSecret.Type != IdentityServerConstants.ParsedSecretTypes.SharedSecret)
        {
            _logger.LogDebug("Hashed shared secret validator cannot process {type}", parsedSecret.Type ?? "null");
            return fail;
        }

        var sharedSecrets = secrets.Where(s => s.Type == IdentityServerConstants.SecretTypes.SharedSecret);
        if (!sharedSecrets.Any())
        {
            _logger.LogDebug("No shared secret configured for client.");
            return fail;
        }

        var sharedSecret = parsedSecret.Credential as string;

        if (parsedSecret.Id.IsMissing() || sharedSecret.IsMissing())
        {
            throw new ArgumentException("Id or Credential is missing.");
        }

        var secretSha256 = sharedSecret.Sha256();
        var secretSha512 = sharedSecret.Sha512();

        foreach (var secret in sharedSecrets)
        {
            var secretDescription = string.IsNullOrEmpty(secret.Description) ? "no description" : secret.Description;

            bool isValid = false;
            byte[] secretBytes;

            try
            {
                secretBytes = Convert.FromBase64String(secret.Value);
            }
            catch (FormatException)
            {
                _logger.LogInformation("Secret: {description} uses invalid hashing algorithm.", secretDescription);
                return fail;
            }
            catch (ArgumentNullException)
            {
                _logger.LogInformation("Secret: {description} is null.", secretDescription);
                return fail;
            }

            if (secretBytes.Length == 32)
            {
                isValid = TimeConstantComparer.IsEqual(secret.Value, secretSha256);
            }
            else if (secretBytes.Length == 64)
            {
                isValid = TimeConstantComparer.IsEqual(secret.Value, secretSha512);
            }
            else
            {
                _logger.LogInformation("Secret: {description} uses invalid hashing algorithm.", secretDescription);
                return fail;
            }

            if (isValid)
            {
                return success;
            }
        }

        _logger.LogDebug("No matching hashed secret found.");
        return fail;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/IntrospectionRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// The introspection request validator
/// 
/// 
internal class IntrospectionRequestValidator : IIntrospectionRequestValidator
{
    private readonly ILogger _logger;
    private readonly ITokenValidator _tokenValidator;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The token validator.
    /// The logger.
    public IntrospectionRequestValidator(ITokenValidator tokenValidator, ILogger logger)
    {
        _tokenValidator = tokenValidator;
        _logger = logger;
    }

    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The API.
    /// 
    public async Task ValidateAsync(NameValueCollection parameters, ApiResource api)
    {
        _logger.LogDebug("Introspection request validation started.");

        // retrieve required token
        var token = parameters.Get("token");
        if (token == null)
        {
            _logger.LogError("Token is missing");

            return new IntrospectionRequestValidationResult
            {
                IsError = true,
                Api = api,
                Error = "missing_token",
                Parameters = parameters
            };
        }

        // validate token
        var tokenValidationResult = await _tokenValidator.ValidateAccessTokenAsync(token);

        // invalid or unknown token
        if (tokenValidationResult.IsError)
        {
            _logger.LogDebug("Token is invalid.");

            return new IntrospectionRequestValidationResult
            {
                IsActive = false,
                IsError = false,
                Token = token,
                Api = api,
                Parameters = parameters
            };
        }

        _logger.LogDebug("Introspection request validation successful.");

        // valid token
        return new IntrospectionRequestValidationResult
        {
            IsActive = true,
            IsError = false,
            Token = token,
            Claims = tokenValidationResult.Claims,
            Api = api,
            Parameters = parameters
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/JwtBearerClientAssertionSecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Parses a POST body for a JWT bearer client assertion
/// 
public class JwtBearerClientAssertionSecretParser : ISecretParser
{
    private readonly IdentityServerOptions _options;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The logger.
    public JwtBearerClientAssertionSecretParser(IdentityServerOptions options, ILogger logger)
    {
        _options = options;
        _logger = logger;
    }

    /// 
    /// Returns the authentication method name that this parser implements
    /// 
    /// 
    /// The authentication method.
    /// 
    public string AuthenticationMethod => OidcConstants.EndpointAuthenticationMethods.PrivateKeyJwt;

    /// 
    /// Tries to find a JWT client assertion token in the request body that can be used for authentication
    /// Used for "private_key_jwt" client authentication method as defined in http://openid.net/specs/openid-connect-core-1_0.html#ClientAuthentication
    /// 
    /// The HTTP context
    /// 
    /// A parsed secret
    /// 
    public async Task ParseAsync(HttpContext context)
    {
        _logger.LogDebug("Start parsing for JWT client assertion in post body");

        if (!context.Request.HasApplicationFormContentType())
        {
            _logger.LogDebug("Content type is not a form");
            return null;
        }

        var body = await context.Request.ReadFormAsync();

        if (body != null)
        {
            var clientAssertionType = body[OidcConstants.TokenRequest.ClientAssertionType].FirstOrDefault();
            var clientAssertion = body[OidcConstants.TokenRequest.ClientAssertion].FirstOrDefault();

            if (clientAssertion.IsPresent()
                && clientAssertionType == OidcConstants.ClientAssertionTypes.JwtBearer)
            {
                if (clientAssertion.Length > _options.InputLengthRestrictions.Jwt)
                {
                    _logger.LogError("Client assertion token exceeds maximum length.");
                    return null;
                }

                var clientId = GetClientIdFromToken(clientAssertion);
                if (!clientId.IsPresent())
                {
                    return null;
                }

                if (clientId.Length > _options.InputLengthRestrictions.ClientId)
                {
                    _logger.LogError("Client ID exceeds maximum length.");
                    return null;
                }

                var parsedSecret = new ParsedSecret
                {
                    Id = clientId,
                    Credential = clientAssertion,
                    Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
                };

                return parsedSecret;
            }
        }

        _logger.LogDebug("No JWT client assertion found in post body");
        return null;
    }

    private string GetClientIdFromToken(string token)
    {
        try
        {
            var jwt = new JwtSecurityToken(token);
            return jwt.Subject;
        }
        catch (Exception e)
        {
            _logger.LogWarning("Could not parse client assertion: {e}", e);
            return null;
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/JwtRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Validation;

/// 
/// Validates JWT authorization request objects
/// 
public class JwtRequestValidator
{
    private readonly string _audienceUri;
    private readonly IHttpContextAccessor _httpContextAccessor;
    
    /// 
    /// JWT handler
    /// 
    protected JwtSecurityTokenHandler Handler = new JwtSecurityTokenHandler
    {
        MapInboundClaims = false
    };

    /// 
    /// The audience URI to use
    /// 
    protected string AudienceUri
    {
        get
        {
            if (_audienceUri.IsPresent())
            {
                return _audienceUri;
            }

            return _httpContextAccessor.HttpContext.GetIdentityServerIssuerUri();
        }
    }

    /// 
    /// The logger
    /// 
    protected readonly ILogger Logger;
    
    /// 
    /// The optione
    /// 
    protected readonly IdentityServerOptions Options;

    /// 
    /// Instantiates an instance of private_key_jwt secret validator
    /// 
    public JwtRequestValidator(IHttpContextAccessor contextAccessor, IdentityServerOptions options, ILogger logger)
    {
        _httpContextAccessor = contextAccessor;
        
        Options = options;
        Logger = logger;
    }

    /// 
    /// Instantiates an instance of private_key_jwt secret validator (used for testing)
    /// 
    internal JwtRequestValidator(string audience, ILogger logger)
    {
        _audienceUri = audience;
        Logger = logger;
    }

    /// 
    /// Validates a JWT request object
    /// 
    /// The client
    /// The JWT
    /// 
    public virtual async Task ValidateAsync(Client client, string jwtTokenString)
    {
        if (client == null) throw new ArgumentNullException(nameof(client));
        if (String.IsNullOrWhiteSpace(jwtTokenString)) throw new ArgumentNullException(nameof(jwtTokenString));

        var fail = new JwtRequestValidationResult { IsError = true };

        List trustedKeys;
        try
        {
            trustedKeys = await GetKeysAsync(client);
        }
        catch (Exception e)
        {
            Logger.LogError(e, "Could not parse client secrets");
            return fail;
        }

        if (!trustedKeys.Any())
        {
            Logger.LogError("There are no keys available to validate JWT.");
            return fail;
        }

        JwtSecurityToken jwtSecurityToken;
        try
        {
            jwtSecurityToken = await ValidateJwtAsync(jwtTokenString, trustedKeys, client);
        }
        catch (Exception e)
        {
            Logger.LogError(e, "JWT token validation error");
            return fail;
        }

        if (jwtSecurityToken.Payload.ContainsKey(OidcConstants.AuthorizeRequest.Request) ||
            jwtSecurityToken.Payload.ContainsKey(OidcConstants.AuthorizeRequest.RequestUri))
        {
            Logger.LogError("JWT payload must not contain request or request_uri");
            return fail;
        }

        var payload = await ProcessPayloadAsync(jwtSecurityToken);

        var result = new JwtRequestValidationResult
        {
            IsError = false,
            Payload = payload
        };

        Logger.LogDebug("JWT request object validation success.");
        return result;
    }

    /// 
    /// Retrieves keys for a given client
    /// 
    /// The client
    /// 
    protected virtual Task> GetKeysAsync(Client client)
    {
        return client.ClientSecrets.GetKeysAsync();
    }

    /// 
    /// Validates the JWT token
    /// 
    /// JWT as a string
    /// The keys
    /// The client
    /// 
    protected virtual Task ValidateJwtAsync(string jwtTokenString, IEnumerable keys, Client client)
    {
        var tokenValidationParameters = new TokenValidationParameters
        {
            IssuerSigningKeys = keys,
            ValidateIssuerSigningKey = true,

            ValidIssuer = client.ClientId,
            ValidateIssuer = true,

            ValidAudience = AudienceUri,
            ValidateAudience = true,

            RequireSignedTokens = true,
            RequireExpirationTime = true
        };

        if (Options.StrictJarValidation)
        {
            tokenValidationParameters.ValidTypes = new[] { JwtClaimTypes.JwtTypes.AuthorizationRequest };
        }

        Handler.ValidateToken(jwtTokenString, tokenValidationParameters, out var token);
        
        return Task.FromResult((JwtSecurityToken)token);
    }

    /// 
    /// Processes the JWT contents
    /// 
    /// The JWT token
    /// 
    protected virtual Task> ProcessPayloadAsync(JwtSecurityToken token)
    {
        // filter JWT validation values
        var payload = new Dictionary();
        foreach (var key in token.Payload.Keys)
        {
            if (!Constants.Filters.JwtRequestClaimTypesFilter.Contains(key))
            {
                var value = token.Payload[key];

                switch (value)
                {
                    case string s:
                        payload.Add(key, s);
                        break;
                    case JObject jobj:
                        payload.Add(key, jobj.ToString(Formatting.None));
                        break;
                    case JArray jarr:
                        payload.Add(key, jarr.ToString(Formatting.None));
                        break;
                }
            }
        }

        return Task.FromResult(payload);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/MutualTlsSecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Parses secret according to MTLS spec
/// 
public class MutualTlsSecretParser : ISecretParser
{
    private readonly IdentityServerOptions _options;
    private readonly ILogger _logger;

    /// 
    /// ctor
    /// 
    /// 
    /// 
    public MutualTlsSecretParser(IdentityServerOptions options, ILogger logger)
    {
        _options = options;
        _logger = logger;
    }

    /// 
    /// Name of authentication method (blank to suppress in discovery since we do special handling)
    /// 
    public string AuthenticationMethod => String.Empty;

    /// 
    /// Parses the HTTP context
    /// 
    /// 
    /// 
    public async Task ParseAsync(HttpContext context)
    {
        _logger.LogDebug("Start parsing for client id in post body");

        if (!context.Request.HasApplicationFormContentType())
        {
            _logger.LogDebug("Content type is not a form");
            return null;
        }

        var body = await context.Request.ReadFormAsync();

        if (body != null)
        {
            var id = body["client_id"].FirstOrDefault();

            // client id must be present
            if (!String.IsNullOrWhiteSpace(id))
            {
                if (id.Length > _options.InputLengthRestrictions.ClientId)
                {
                    _logger.LogError("Client ID exceeds maximum length.");
                    return null;
                }
                
                var clientCertificate = await context.Connection.GetClientCertificateAsync();
                
                if (clientCertificate is null)
                {
                    _logger.LogDebug("Client certificate not present");
                    return null;
                }
                
                return new ParsedSecret
                {
                    Id = id,
                    Credential = clientCertificate,
                    Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
                };
            }
        }

        _logger.LogDebug("No post body found");
        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/NopClientConfigurationValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// No-op client configuration validator (for backwards-compatibility).
/// 
/// 
public class NopClientConfigurationValidator : IClientConfigurationValidator
{
    /// 
    /// Determines whether the configuration of a client is valid.
    /// 
    /// The context.
    /// 
    public Task ValidateAsync(ClientConfigurationValidationContext context)
    {
        context.IsValid = true;
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/NotSupportedResouceOwnerCredentialValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default resource owner password validator (no implementation == not supported)
/// 
/// 
public class NotSupportedResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public NotSupportedResourceOwnerPasswordValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Validates the resource owner password credential
    /// 
    /// The context.
    /// 
    public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {
        context.Result = new GrantValidationResult(TokenRequestErrors.UnsupportedGrantType);

        _logger.LogInformation("Resource owner password credential type not supported. Configure an IResourceOwnerPasswordValidator.");
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/PlainTextSharedSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates a secret stored in plain text
/// 
public class PlainTextSharedSecretValidator : ISecretValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public PlainTextSharedSecretValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Validates a secret
    /// 
    /// The stored secrets.
    /// The received secret.
    /// 
    /// A validation result
    /// 
    /// id or credential is missing.
    public Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var fail = Task.FromResult(new SecretValidationResult { Success = false });
        var success = Task.FromResult(new SecretValidationResult { Success = true });

        if (parsedSecret.Type != IdentityServerConstants.ParsedSecretTypes.SharedSecret)
        {
            _logger.LogError("Parsed secret should not be of type: {type}", parsedSecret.Type ?? "null");
            return fail;
        }

        var sharedSecrets = secrets.Where(s => s.Type == IdentityServerConstants.SecretTypes.SharedSecret);
        if (!sharedSecrets.Any())
        {
            _logger.LogDebug("No shared secret configured for client.");
            return fail;
        }

        var sharedSecret = parsedSecret.Credential as string;

        if (parsedSecret.Id.IsMissing() || sharedSecret.IsMissing())
        {
            throw new ArgumentException("Id or Credential is missing.");
        }

        foreach (var secret in sharedSecrets)
        {
            // use time constant string comparison
            var isValid = TimeConstantComparer.IsEqual(sharedSecret, secret.Value);

            if (isValid)
            {
                return success;
            }
        }

        _logger.LogDebug("No matching plain text secret found.");
        return fail;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/PostBodySecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Parses a POST body for secrets
/// 
public class PostBodySecretParser : ISecretParser
{
    private readonly ILogger _logger;
    private readonly IdentityServerOptions _options;

    /// 
    /// Creates the parser with options
    /// 
    /// IdentityServer options
    /// Logger
    public PostBodySecretParser(IdentityServerOptions options, ILogger logger)
    {
        _logger = logger;
        _options = options;
    }

    /// 
    /// Returns the authentication method name that this parser implements
    /// 
    /// 
    /// The authentication method.
    /// 
    public string AuthenticationMethod => OidcConstants.EndpointAuthenticationMethods.PostBody;

    /// 
    /// Tries to find a secret on the context that can be used for authentication
    /// 
    /// The HTTP context.
    /// 
    /// A parsed secret
    /// 
    public async Task ParseAsync(HttpContext context)
    {
        _logger.LogDebug("Start parsing for secret in post body");

        if (!context.Request.HasApplicationFormContentType())
        {
            _logger.LogDebug("Content type is not a form");
            return null;
        }

        var body = await context.Request.ReadFormAsync();

        if (body != null)
        {
            var id = body["client_id"].FirstOrDefault();
            var secret = body["client_secret"].FirstOrDefault();

            // client id must be present
            if (id.IsPresent())
            {
                if (id.Length > _options.InputLengthRestrictions.ClientId)
                {
                    _logger.LogError("Client ID exceeds maximum length.");
                    return null;
                }

                if (secret.IsPresent())
                {
                    if (secret.Length > _options.InputLengthRestrictions.ClientSecret)
                    {
                        _logger.LogError("Client secret exceeds maximum length.");
                        return null;
                    }

                    return new ParsedSecret
                    {
                        Id = id,
                        Credential = secret,
                        Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
                    };
                }
                else
                {
                    // client secret is optional
                    _logger.LogDebug("client id without secret found");

                    return new ParsedSecret
                    {
                        Id = id,
                        Type = IdentityServerConstants.ParsedSecretTypes.NoSecret
                    };
                }
            }
        }

        _logger.LogDebug("No secret in post body found");
        return null;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/PrivateKeyJwtSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Validation;

/// 
/// Validates a secret based on RS256 signed JWT token
/// 
public class PrivateKeyJwtSecretValidator : ISecretValidator
{
    private readonly IHttpContextAccessor _contextAccessor;
    private readonly IReplayCache _replayCache;
    private readonly ILogger _logger;

    private const string Purpose = nameof(PrivateKeyJwtSecretValidator);
    
    /// 
    /// Instantiates an instance of private_key_jwt secret validator
    /// 
    public PrivateKeyJwtSecretValidator(IHttpContextAccessor contextAccessor, IReplayCache replayCache, ILogger logger)
    {
        _contextAccessor = contextAccessor;
        _replayCache = replayCache;
        _logger = logger;
    }

    /// 
    /// Validates a secret
    /// 
    /// The stored secrets.
    /// The received secret.
    /// 
    /// A validation result
    /// 
    /// ParsedSecret.Credential is not a JWT token
    public async Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var fail = new SecretValidationResult { Success = false };
        var success = new SecretValidationResult { Success = true };

        if (parsedSecret.Type != IdentityServerConstants.ParsedSecretTypes.JwtBearer)
        {
            return fail;
        }

        if (!(parsedSecret.Credential is string jwtTokenString))
        {
            _logger.LogError("ParsedSecret.Credential is not a string.");
            return fail;
        }

        List trustedKeys;
        try
        {
            trustedKeys = await secrets.GetKeysAsync();
        }
        catch (Exception e)
        {
            _logger.LogError(e, "Could not parse secrets");
            return fail;
        }

        if (!trustedKeys.Any())
        {
            _logger.LogError("There are no keys available to validate client assertion.");
            return fail;
        }

        var validAudiences = new[]
        {
            // issuer URI (tbd)
            //_contextAccessor.HttpContext.GetIdentityServerIssuerUri(),
            
            // token endpoint URL
            string.Concat(_contextAccessor.HttpContext.GetIdentityServerIssuerUri().EnsureTrailingSlash(),
                Constants.ProtocolRoutePaths.Token)
        };
        
        var tokenValidationParameters = new TokenValidationParameters
        {
            IssuerSigningKeys = trustedKeys,
            ValidateIssuerSigningKey = true,

            ValidIssuer = parsedSecret.Id,
            ValidateIssuer = true,

            ValidAudiences = validAudiences,
            ValidateAudience = true,

            RequireSignedTokens = true,
            RequireExpirationTime = true,
            
            ClockSkew = TimeSpan.FromMinutes(5)
        };
        try
        {
            var handler = new JwtSecurityTokenHandler();
            handler.ValidateToken(jwtTokenString, tokenValidationParameters, out var token);

            var jwtToken = (JwtSecurityToken)token;
            if (jwtToken.Subject != jwtToken.Issuer)
            {
                _logger.LogError("Both 'sub' and 'iss' in the client assertion token must have a value of client_id.");
                return fail;
            }
            
            var exp = jwtToken.Payload.Exp;
            if (!exp.HasValue)
            {
                _logger.LogError("exp is missing.");
                return fail;
            }
            
            var jti = jwtToken.Payload.Jti;
            if (jti.IsMissing())
            {
                _logger.LogError("jti is missing.");
                return fail;
            }

            if (await _replayCache.ExistsAsync(Purpose, jti))
            {
                _logger.LogError("jti is found in replay cache. Possible replay attack.");
                return fail;
            }
            else
            {
                await _replayCache.AddAsync(Purpose, jti, DateTimeOffset.FromUnixTimeSeconds(exp.Value).AddMinutes(5));
            }

            return success;
        }
        catch (Exception e)
        {
            _logger.LogError(e, "JWT token validation error");
            return fail;
        }
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/ResponseTypeEqualityComparer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Compares resource_type strings, where the order of space-delimited values is insignificant.
/// 
/// 
/// 
/// This is to handle the fact that the order of multi-valued response_type lists is
/// insignificant, per the OAuth2 spec
/// and the 
/// (OAuth 
/// 2.0 Multiple Response Type Encoding Practices draft ).
/// 
/// 
public class ResponseTypeEqualityComparer : IEqualityComparer
{
    /// 
    /// Determines whether the specified values are equal.
    /// 
    /// The first string to compare.
    /// The second string to compare.
    /// true if the specified values are equal; otherwise, false.
    public bool Equals(string x, string y)
    {
        if (x == y) return true;

        if (x == null || y == null) return false;

        if (x.Length != y.Length) return false;

        var xValues = x.Split(' ');
        var yValues = y.Split(' ');

        if (xValues.Length != yValues.Length)
        {
            return false;
        }

        Array.Sort(xValues);
        Array.Sort(yValues);

        for (var i = 0; i < xValues.Length; i++)
        {
            if (xValues[i] != yValues[i])
            {
                return false;
            }
        }

        return true;
    }

    /// 
    /// Returns a hash code for the value.
    /// 
    /// The value for which a hash code is to be returned.
    /// A hash code for the value, suitable for use in hashing algorithms and data structures like a hash table.
    public int GetHashCode(string value)
    {
        if (value == null) return 0;

        var values = value.Split(' ');
        if (values.Length == 1)
        {
            // Only one value, so just spit out the hash code of the whole string
            return value.GetHashCode();
        }

        Array.Sort(values);

        // Using Skeet's answer here: http://stackoverflow.com/a/7244729/208990
        // Licensed under Creative Commons CC-BY-SA from SO: https://stackoverflow.com/legal/terms-of-service#licensing
        // Creative Commons CC-BY-SA https://creativecommons.org/licenses/by-sa/4.0/
        var hash = 17;
        foreach (var element in values)
        {
            // changed to use StringComparer.Ordinal, rather than StringComparer.InvariantCulture
            hash = hash * 31 + StringComparer.Ordinal.GetHashCode(element);
        }
        return hash;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/SecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Uses the registered secret parsers to parse a secret on the current request
/// 
public class SecretParser : ISecretsListParser
{
    private readonly ILogger _logger;
    private readonly IEnumerable _parsers;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The parsers.
    /// The logger.
    public SecretParser(IEnumerable parsers, ILogger logger)
    {
        _parsers = parsers;
        _logger = logger;
    }

    /// 
    /// Checks the context to find a secret.
    /// 
    /// The HTTP context.
    /// 
    public async Task ParseAsync(HttpContext context)
    {
        // see if a registered parser finds a secret on the request
        ParsedSecret bestSecret = null;
        foreach (var parser in _parsers)
        {
            var parsedSecret = await parser.ParseAsync(context);
            if (parsedSecret != null)
            {
                _logger.LogDebug("Parser found secret: {type}", parser.GetType().Name);

                bestSecret = parsedSecret;

                if (parsedSecret.Type != IdentityServerConstants.ParsedSecretTypes.NoSecret)
                {
                    break;
                }
            }
        }

        if (bestSecret != null)
        {
            _logger.LogDebug("Secret id found: {id}", Ioc.Sanitizer.Log.Sanitize(bestSecret.Id));
            return bestSecret;
        }

        _logger.LogDebug("Parser found no secret");
        return null;
    }

    /// 
    /// Gets all available authentication methods.
    /// 
    /// 
    public IEnumerable GetAvailableAuthenticationMethods()
    {
        return _parsers.Select(p => p.AuthenticationMethod).Where(p => !String.IsNullOrWhiteSpace(p));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/SecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates secrets using the registered validators
/// 
public class SecretValidator : ISecretsListValidator
{
    private readonly ILogger _logger;
    private readonly IEnumerable _validators;
    private readonly ISystemClock _clock;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The clock.
    /// The validators.
    /// The logger.
    public SecretValidator(ISystemClock clock, IEnumerable validators, ILogger logger)
    {
        _clock = clock;
        _validators = validators;
        _logger = logger;
    }

    /// 
    /// Validates the secret.
    /// 
    /// The parsed secret.
    /// The secrets.
    /// 
    public async Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var secretsArray = secrets as Secret[] ?? secrets.ToArray();

        var expiredSecrets = secretsArray.Where(s => s.Expiration.HasExpired(_clock.UtcNow.UtcDateTime)).ToList();
        if (expiredSecrets.Any())
        {
            expiredSecrets.ForEach(
                ex => _logger.LogInformation("Secret [{description}] is expired", ex.Description ?? "no description"));
        }

        var currentSecrets = secretsArray.Where(s => !s.Expiration.HasExpired(_clock.UtcNow.UtcDateTime)).ToArray();

        // see if a registered validator can validate the secret
        foreach (var validator in _validators)
        {
            var secretValidationResult = await validator.ValidateAsync(currentSecrets, parsedSecret);

            if (secretValidationResult.Success)
            {
                _logger.LogDebug("Secret validator success: {0}", validator.GetType().Name);
                return secretValidationResult;
            }
        }

        _logger.LogDebug("Secret validators could not validate secret");
        return new SecretValidationResult { Success = false };
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/StrictRedirectUriValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default implementation of redirect URI validator. Validates the URIs against
/// the client's configured URIs.
/// 
public class StrictRedirectUriValidator : IRedirectUriValidator
{
    /// 
    /// Checks if a given URI string is in a collection of strings (using ordinal ignore case comparison)
    /// 
    /// The uris.
    /// The requested URI.
    /// 
    protected bool StringCollectionContainsString(IEnumerable uris, string requestedUri)
    {
        if (uris.EnumerableIsNullOrEmpty()) return false;

        return uris.Contains(requestedUri, StringComparer.OrdinalIgnoreCase);
    }

    /// 
    /// Determines whether a redirect URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// 
    ///   true is the URI is valid; false otherwise.
    /// 
    public virtual Task IsRedirectUriValidAsync(string requestedUri, Client client)
    {
        return Task.FromResult(StringCollectionContainsString(client.RedirectUris, requestedUri));
    }

    /// 
    /// Determines whether a post logout URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// 
    ///   true is the URI is valid; false otherwise.
    /// 
    public virtual Task IsPostLogoutRedirectUriValidAsync(string requestedUri, Client client)
    {
        return Task.FromResult(StringCollectionContainsString(client.PostLogoutRedirectUris, requestedUri));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/StrictRedirectUriValidatorAppAuth.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Implementation of strict redirect URI validator that allows a random port if 127.0.0.1 is used.
/// 
/// 
public class StrictRedirectUriValidatorAppAuth : StrictRedirectUriValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public StrictRedirectUriValidatorAppAuth(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Determines whether a redirect URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// 
    /// true is the URI is valid; false otherwise.
    /// 
    public override async Task IsRedirectUriValidAsync(string requestedUri, Client client)
    {
        var isAllowed = await base.IsRedirectUriValidAsync(requestedUri, client);
        if (isAllowed) return isAllowed;

        // since this is appauth specific, we can require pkce
        if (client.RequirePkce && client.RedirectUris.Contains("http://127.0.0.1")) return IsLoopback(requestedUri);

        return false;
    }

    /// 
    /// Determines whether a post logout URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// 
    /// true is the URI is valid; false otherwise.
    /// 
    public override async Task IsPostLogoutRedirectUriValidAsync(string requestedUri, Client client)
    {
        var isAllowed = await base.IsPostLogoutRedirectUriValidAsync(requestedUri, client);
        if (isAllowed) return isAllowed;

        // since this is appauth specific, we can require pkce
        if (client.RequirePkce && client.RedirectUris.Contains("http://127.0.0.1")) return IsLoopback(requestedUri);

        return false;
    }

    /// 
    /// Check if  is of the form http://127.0.0.1:port/path.
    /// 
    /// The requested URI.
    /// 
    /// true if  is a valid Loopback URI; false otherwise.
    /// 
    internal bool IsLoopback(string requestedUri)
    {
        _logger.LogDebug("Checking for 127.0.0.1 redirect URI");

        // Validate that the requestedUri is not null or empty.
        if (string.IsNullOrEmpty(requestedUri))
        {
            _logger.LogDebug("'requestedUri' is null or empty");
            return false;
        }

        var parts = requestedUri.Split(':');

        if (parts.Length != 3)
        {
            _logger.LogDebug("invalid format - http://127.0.0.1:port is required.");
            return false;
        }

        if (!string.Equals(parts[0], "http", StringComparison.Ordinal) ||
            !string.Equals(parts[1], "//127.0.0.1", StringComparison.Ordinal))
        {
            _logger.LogDebug("invalid format - http://127.0.0.1:port is required.");
            return false;
        }

        string portAsString;
        int indexOfPathSeparator = parts[2].IndexOfAny(new[] { '/', '?', '#' });
        if (indexOfPathSeparator > 0)
        {
            portAsString = parts[2].Substring(0, indexOfPathSeparator);
        }
        else
        {
            portAsString = parts[2];
        }

        // Valid port range is 0 through 65535.
        if (int.TryParse(portAsString, out var port))
        {
            if (port >= 0 && port < 65536)
            {
                return true;
            }
        }

        _logger.LogDebug("invalid port");
        return false;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/TokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

internal class TokenRequestValidator : ITokenRequestValidator
{
    private readonly IdentityServerOptions _options;
    private readonly IAuthorizationCodeStore _authorizationCodeStore;
    private readonly ExtensionGrantValidator _extensionGrantValidator;
    private readonly ICustomTokenRequestValidator _customRequestValidator;
    private readonly IResourceValidator _resourceValidator;
    private readonly IResourceStore _resourceStore;
    private readonly ITokenValidator _tokenValidator;
    private readonly IRefreshTokenService _refreshTokenService;
    private readonly IEventService _events;
    private readonly IResourceOwnerPasswordValidator _resourceOwnerValidator;
    private readonly IProfileService _profile;
    private readonly IDeviceCodeValidator _deviceCodeValidator;
    private readonly ISystemClock _clock;
    private readonly ILogger _logger;

    private ValidatedTokenRequest _validatedRequest;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The options.
    /// The authorization code store.
    /// The resource owner validator.
    /// The profile.
    /// The device code validator.
    /// The extension grant validator.
    /// The custom request validator.
    /// The resource validator.
    /// The resource store.
    /// The token validator.
    /// 
    /// The events.
    /// The clock.
    /// The logger.
    public TokenRequestValidator(IdentityServerOptions options, 
        IAuthorizationCodeStore authorizationCodeStore, 
        IResourceOwnerPasswordValidator resourceOwnerValidator, 
        IProfileService profile, 
        IDeviceCodeValidator deviceCodeValidator, 
        ExtensionGrantValidator extensionGrantValidator, 
        ICustomTokenRequestValidator customRequestValidator,
        IResourceValidator resourceValidator,
        IResourceStore resourceStore,
        ITokenValidator tokenValidator, 
        IRefreshTokenService refreshTokenService,
        IEventService events, 
        ISystemClock clock, 
        ILogger logger)
    {
        _logger = logger;
        _options = options;
        _clock = clock;
        _authorizationCodeStore = authorizationCodeStore;
        _resourceOwnerValidator = resourceOwnerValidator;
        _profile = profile;
        _deviceCodeValidator = deviceCodeValidator;
        _extensionGrantValidator = extensionGrantValidator;
        _customRequestValidator = customRequestValidator;
        _resourceValidator = resourceValidator;
        _resourceStore = resourceStore;
        _tokenValidator = tokenValidator;
        _refreshTokenService = refreshTokenService;
        _events = events;
    }

    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The client validation result.
    /// 
    /// 
    /// parameters
    /// or
    /// client
    /// 
    public async Task ValidateRequestAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult)
    {
        _logger.LogDebug("Start token request validation");

        _validatedRequest = new ValidatedTokenRequest
        {
            Raw = parameters ?? throw new ArgumentNullException(nameof(parameters)),
            Options = _options
        };

        if (clientValidationResult == null) throw new ArgumentNullException(nameof(clientValidationResult));

        _validatedRequest.SetClient(clientValidationResult.Client, clientValidationResult.Secret, clientValidationResult.Confirmation);

        /////////////////////////////////////////////
        // check client protocol type
        /////////////////////////////////////////////
        if (_validatedRequest.Client.ProtocolType != IdentityServerConstants.ProtocolTypes.OpenIdConnect)
        {
            LogError("Invalid protocol type for client",
                new
                {
                    clientId = _validatedRequest.Client.ClientId,
                    expectedProtocolType = IdentityServerConstants.ProtocolTypes.OpenIdConnect,
                    actualProtocolType = _validatedRequest.Client.ProtocolType
                });

            return Invalid(OidcConstants.TokenErrors.InvalidClient);
        }

        /////////////////////////////////////////////
        // check grant type
        /////////////////////////////////////////////
        var grantType = parameters.Get(OidcConstants.TokenRequest.GrantType);
        if (grantType.IsMissing())
        {
            LogError("Grant type is missing");
            return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        if (grantType.Length > _options.InputLengthRestrictions.GrantType)
        {
            LogError("Grant type is too long");
            return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        _validatedRequest.GrantType = grantType;

        switch (grantType)
        {
            case OidcConstants.GrantTypes.AuthorizationCode:
                return await RunValidationAsync(ValidateAuthorizationCodeRequestAsync, parameters);
            case OidcConstants.GrantTypes.ClientCredentials:
                return await RunValidationAsync(ValidateClientCredentialsRequestAsync, parameters);
            case OidcConstants.GrantTypes.Password:
                return await RunValidationAsync(ValidateResourceOwnerCredentialRequestAsync, parameters);
            case OidcConstants.GrantTypes.RefreshToken:
                return await RunValidationAsync(ValidateRefreshTokenRequestAsync, parameters);
            case OidcConstants.GrantTypes.DeviceCode:
                return await RunValidationAsync(ValidateDeviceCodeRequestAsync, parameters);
            default:
                return await RunValidationAsync(ValidateExtensionGrantRequestAsync, parameters);
        }
    }

    private async Task RunValidationAsync(Func> validationFunc, NameValueCollection parameters)
    {
        // run standard validation
        var result = await validationFunc(parameters);
        if (result.IsError)
        {
            return result;
        }

        // run custom validation
        _logger.LogTrace("Calling into custom request validator: {type}", _customRequestValidator.GetType().FullName);

        var customValidationContext = new CustomTokenRequestValidationContext { Result = result };
        await _customRequestValidator.ValidateAsync(customValidationContext);

        if (customValidationContext.Result.IsError)
        {
            if (customValidationContext.Result.Error.IsPresent())
            {
                LogError("Custom token request validator", new { error = customValidationContext.Result.Error });
            }
            else
            {
                LogError("Custom token request validator error");
            }

            return customValidationContext.Result;
        }

        LogSuccess();
        return customValidationContext.Result;
    }

    private async Task ValidateAuthorizationCodeRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start validation of authorization code token request");

        /////////////////////////////////////////////
        // check if client is authorized for grant type
        /////////////////////////////////////////////
        if (!_validatedRequest.Client.AllowedGrantTypes.ToList().Contains(GrantType.AuthorizationCode) &&
            !_validatedRequest.Client.AllowedGrantTypes.ToList().Contains(GrantType.Hybrid))
        {
            LogError("Client not authorized for code flow");
            return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        /////////////////////////////////////////////
        // validate authorization code
        /////////////////////////////////////////////
        var code = parameters.Get(OidcConstants.TokenRequest.Code);
        if (code.IsMissing())
        {
            LogError("Authorization code is missing");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (code.Length > _options.InputLengthRestrictions.AuthorizationCode)
        {
            LogError("Authorization code is too long");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _validatedRequest.AuthorizationCodeHandle = code;

        var authZcode = await _authorizationCodeStore.GetAuthorizationCodeAsync(code);
        if (authZcode == null)
        {
            LogError("Invalid authorization code", new { code });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }
        
        /////////////////////////////////////////////
        // validate client binding
        /////////////////////////////////////////////
        if (authZcode.ClientId != _validatedRequest.Client.ClientId)
        {
            LogError("Client is trying to use a code from a different client", new { clientId = _validatedRequest.Client.ClientId, codeClient = authZcode.ClientId });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        // remove code from store
        // todo: set to consumed in the future?
        await _authorizationCodeStore.RemoveAuthorizationCodeAsync(code);

        if (authZcode.CreationTime.HasExceeded(authZcode.Lifetime, _clock.UtcNow.UtcDateTime))
        {
            LogError("Authorization code expired", new { code });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        /////////////////////////////////////////////
        // populate session id
        /////////////////////////////////////////////
        if (authZcode.SessionId.IsPresent())
        {
            _validatedRequest.SessionId = authZcode.SessionId;
        }

        /////////////////////////////////////////////
        // validate code expiration
        /////////////////////////////////////////////
        if (authZcode.CreationTime.HasExceeded(_validatedRequest.Client.AuthorizationCodeLifetime, _clock.UtcNow.UtcDateTime))
        {
            LogError("Authorization code is expired");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _validatedRequest.AuthorizationCode = authZcode;
        _validatedRequest.Subject = authZcode.Subject;

        /////////////////////////////////////////////
        // validate redirect_uri
        /////////////////////////////////////////////
        var redirectUri = parameters.Get(OidcConstants.TokenRequest.RedirectUri);
        if (redirectUri.IsMissing())
        {
            LogError("Redirect URI is missing");
            return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        if (redirectUri.Equals(_validatedRequest.AuthorizationCode.RedirectUri, StringComparison.Ordinal) == false)
        {
            LogError("Invalid redirect_uri", new { redirectUri, expectedRedirectUri = _validatedRequest.AuthorizationCode.RedirectUri });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        /////////////////////////////////////////////
        // validate scopes are present
        /////////////////////////////////////////////
        if (_validatedRequest.AuthorizationCode.RequestedScopes == null ||
            !_validatedRequest.AuthorizationCode.RequestedScopes.Any())
        {
            LogError("Authorization code has no associated scopes");
            return Invalid(OidcConstants.TokenErrors.InvalidRequest);
        }

        /////////////////////////////////////////////
        // validate PKCE parameters
        /////////////////////////////////////////////
        var codeVerifier = parameters.Get(OidcConstants.TokenRequest.CodeVerifier);
        if (_validatedRequest.Client.RequirePkce || _validatedRequest.AuthorizationCode.CodeChallenge.IsPresent())
        {
            _logger.LogDebug("Client required a proof key for code exchange. Starting PKCE validation");

            var proofKeyResult = ValidateAuthorizationCodeWithProofKeyParameters(codeVerifier, _validatedRequest.AuthorizationCode);
            if (proofKeyResult.IsError)
            {
                return proofKeyResult;
            }

            _validatedRequest.CodeVerifier = codeVerifier;
        }
        else
        {
            if (codeVerifier.IsPresent())
            {
                LogError("Unexpected code_verifier: {codeVerifier}. This happens when the client is trying to use PKCE, but it is not enabled. Set RequirePkce to true.", codeVerifier);
                return Invalid(OidcConstants.TokenErrors.InvalidGrant);
            }
        }

        /////////////////////////////////////////////
        // make sure user is enabled
        /////////////////////////////////////////////
        var isActiveCtx = new IsActiveContext(_validatedRequest.AuthorizationCode.Subject, _validatedRequest.Client, IdentityServerConstants.ProfileIsActiveCallers.AuthorizationCodeValidation);
        await _profile.IsActiveAsync(isActiveCtx);

        if (isActiveCtx.IsActive == false)
        {
            LogError("User has been disabled", new { subjectId = _validatedRequest.AuthorizationCode.Subject.GetSubjectId() });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _logger.LogDebug("Validation of authorization code token request success");

        return Valid();
    }

    private async Task ValidateClientCredentialsRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start client credentials token request validation");

        /////////////////////////////////////////////
        // check if client is authorized for grant type
        /////////////////////////////////////////////
        if (!_validatedRequest.Client.AllowedGrantTypes.ToList().Contains(GrantType.ClientCredentials))
        {
            LogError("Client not authorized for client credentials flow, check the AllowedGrantTypes setting", new { clientId = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        /////////////////////////////////////////////
        // check if client is allowed to request scopes
        /////////////////////////////////////////////
        if (!await ValidateRequestedScopesAsync(parameters, ignoreImplicitIdentityScopes: true, ignoreImplicitOfflineAccess: true))
        {
            return Invalid(OidcConstants.TokenErrors.InvalidScope);
        }

        if (_validatedRequest.ValidatedResources.Resources.IdentityResources.Any())
        {
            LogError("Client cannot request OpenID scopes in client credentials flow", new { clientId = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.InvalidScope);
        }

        if (_validatedRequest.ValidatedResources.Resources.OfflineAccess)
        {
            LogError("Client cannot request a refresh token in client credentials flow", new { clientId = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.InvalidScope);
        }

        _logger.LogDebug("{clientId} credentials token request validation success", _validatedRequest.Client.ClientId);
        return Valid();
    }

    private async Task ValidateResourceOwnerCredentialRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start resource owner password token request validation");

        /////////////////////////////////////////////
        // check if client is authorized for grant type
        /////////////////////////////////////////////
        if (!_validatedRequest.Client.AllowedGrantTypes.Contains(GrantType.ResourceOwnerPassword))
        {
            LogError("Client not authorized for resource owner flow, check the AllowedGrantTypes setting", new { client_id = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        /////////////////////////////////////////////
        // check if client is allowed to request scopes
        /////////////////////////////////////////////
        if (!(await ValidateRequestedScopesAsync(parameters)))
        {
            return Invalid(OidcConstants.TokenErrors.InvalidScope);
        }

        /////////////////////////////////////////////
        // check resource owner credentials
        /////////////////////////////////////////////
        var userName = parameters.Get(OidcConstants.TokenRequest.UserName);
        var password = parameters.Get(OidcConstants.TokenRequest.Password);

        if (userName.IsMissing())
        {
            LogError("Username is missing");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (password.IsMissing())
        {
            password = "";
        }

        if (userName.Length > _options.InputLengthRestrictions.UserName ||
            password.Length > _options.InputLengthRestrictions.Password)
        {
            LogError("Username or password too long");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _validatedRequest.UserName = userName;


        /////////////////////////////////////////////
        // authenticate user
        /////////////////////////////////////////////
        var resourceOwnerContext = new ResourceOwnerPasswordValidationContext
        {
            UserName = userName,
            Password = password,
            Request = _validatedRequest
        };
        await _resourceOwnerValidator.ValidateAsync(resourceOwnerContext);

        if (resourceOwnerContext.Result.IsError)
        {
            // protect against bad validator implementations
            resourceOwnerContext.Result.Error ??= OidcConstants.TokenErrors.InvalidGrant;

            if (resourceOwnerContext.Result.Error == OidcConstants.TokenErrors.UnsupportedGrantType)
            {
                LogError("Resource owner password credential grant type not supported");
                await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, "password grant type not supported", resourceOwnerContext.Request.Client.ClientId);

                return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType, customResponse: resourceOwnerContext.Result.CustomResponse);
            }

            var errorDescription = "invalid_username_or_password";

            if (resourceOwnerContext.Result.ErrorDescription.IsPresent())
            {
                errorDescription = resourceOwnerContext.Result.ErrorDescription;
            }

            LogInformation("User authentication failed: ", errorDescription ?? resourceOwnerContext.Result.Error);
            await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, errorDescription, resourceOwnerContext.Request.Client.ClientId);

            return Invalid(resourceOwnerContext.Result.Error, errorDescription, resourceOwnerContext.Result.CustomResponse);
        }

        if (resourceOwnerContext.Result.Subject == null)
        {
            var error = "User authentication failed: no principal returned";
            LogError(error);
            await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, error, resourceOwnerContext.Request.Client.ClientId);

            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        /////////////////////////////////////////////
        // make sure user is enabled
        /////////////////////////////////////////////
        var isActiveCtx = new IsActiveContext(resourceOwnerContext.Result.Subject, _validatedRequest.Client, IdentityServerConstants.ProfileIsActiveCallers.ResourceOwnerValidation);
        await _profile.IsActiveAsync(isActiveCtx);

        if (isActiveCtx.IsActive == false)
        {
            LogError("User has been disabled", new { subjectId = resourceOwnerContext.Result.Subject.GetSubjectId() });
            await RaiseFailedResourceOwnerAuthenticationEventAsync(userName, "user is inactive", resourceOwnerContext.Request.Client.ClientId);

            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _validatedRequest.UserName = userName;
        _validatedRequest.Subject = resourceOwnerContext.Result.Subject;

        await RaiseSuccessfulResourceOwnerAuthenticationEventAsync(userName, resourceOwnerContext.Result.Subject.GetSubjectId(), resourceOwnerContext.Request.Client.ClientId);
        _logger.LogDebug("Resource owner password token request validation success.");
        return Valid(resourceOwnerContext.Result.CustomResponse);
    }

    private async Task ValidateRefreshTokenRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start validation of refresh token request");

        var refreshTokenHandle = parameters.Get(OidcConstants.TokenRequest.RefreshToken);
        if (refreshTokenHandle.IsMissing())
        {
            LogError("Refresh token is missing");
            return Invalid(OidcConstants.TokenErrors.InvalidRequest);
        }

        if (refreshTokenHandle.Length > _options.InputLengthRestrictions.RefreshToken)
        {
            LogError("Refresh token too long");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        var result = await _refreshTokenService.ValidateRefreshTokenAsync(refreshTokenHandle, _validatedRequest.Client);

        if (result.IsError)
        {
            LogWarning("Refresh token validation failed. aborting");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        _validatedRequest.RefreshToken = result.RefreshToken;
        _validatedRequest.RefreshTokenHandle = refreshTokenHandle;
        _validatedRequest.Subject = result.RefreshToken.Subject;

        _logger.LogDebug("Validation of refresh token request success");
        // todo: more logging - similar to TokenValidator before
        
        return Valid();
    }

    private async Task ValidateDeviceCodeRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start validation of device code request");

        /////////////////////////////////////////////
        // check if client is authorized for grant type
        /////////////////////////////////////////////
        if (!_validatedRequest.Client.AllowedGrantTypes.ToList().Contains(GrantType.DeviceFlow))
        {
            LogError("Client not authorized for device flow");
            return Invalid(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        /////////////////////////////////////////////
        // validate device code parameter
        /////////////////////////////////////////////
        var deviceCode = parameters.Get(OidcConstants.TokenRequest.DeviceCode);
        if (deviceCode.IsMissing())
        {
            LogError("Device code is missing");
            return Invalid(OidcConstants.TokenErrors.InvalidRequest);
        }

        if (deviceCode.Length > _options.InputLengthRestrictions.DeviceCode)
        {
            LogError("Device code too long");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        /////////////////////////////////////////////
        // validate device code
        /////////////////////////////////////////////
        var deviceCodeContext = new DeviceCodeValidationContext { DeviceCode = deviceCode, Request = _validatedRequest };
        await _deviceCodeValidator.ValidateAsync(deviceCodeContext);

        if (deviceCodeContext.Result.IsError) return deviceCodeContext.Result;

        _logger.LogDebug("Validation of authorization code token request success");

        return Valid();
    }

    private async Task ValidateExtensionGrantRequestAsync(NameValueCollection parameters)
    {
        _logger.LogDebug("Start validation of custom grant token request");

        /////////////////////////////////////////////
        // check if client is allowed to use grant type
        /////////////////////////////////////////////
        if (!_validatedRequest.Client.AllowedGrantTypes.Contains(_validatedRequest.GrantType))
        {
            LogError("Client does not have the custom grant type in the allowed list, therefore requested grant is not allowed", new { clientId = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        /////////////////////////////////////////////
        // check if a validator is registered for the grant type
        /////////////////////////////////////////////
        if (!_extensionGrantValidator.GetAvailableGrantTypes().Contains(_validatedRequest.GrantType, StringComparer.Ordinal))
        {
            LogError("No validator is registered for the grant type", new { grantType = _validatedRequest.GrantType });
            return Invalid(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        /////////////////////////////////////////////
        // check if client is allowed to request scopes
        /////////////////////////////////////////////
        if (!await ValidateRequestedScopesAsync(parameters))
        {
            return Invalid(OidcConstants.TokenErrors.InvalidScope);
        }

        /////////////////////////////////////////////
        // validate custom grant type
        /////////////////////////////////////////////
        var result = await _extensionGrantValidator.ValidateAsync(_validatedRequest);

        if (result == null)
        {
            LogError("Invalid extension grant");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (result.IsError)
        {
            if (result.Error.IsPresent())
            {
                LogError("Invalid extension grant", new { error = result.Error });
                return Invalid(result.Error, result.ErrorDescription, result.CustomResponse);
            }
            else
            {
                LogError("Invalid extension grant");
                return Invalid(OidcConstants.TokenErrors.InvalidGrant, customResponse: result.CustomResponse);
            }
        }

        if (result.Subject != null)
        {
            /////////////////////////////////////////////
            // make sure user is enabled
            /////////////////////////////////////////////
            var isActiveCtx = new IsActiveContext(
                result.Subject,
                _validatedRequest.Client,
                IdentityServerConstants.ProfileIsActiveCallers.ExtensionGrantValidation);

            await _profile.IsActiveAsync(isActiveCtx);

            if (isActiveCtx.IsActive == false)
            {
                // todo: raise event?

                LogError("User has been disabled", new { subjectId = result.Subject.GetSubjectId() });
                return Invalid(OidcConstants.TokenErrors.InvalidGrant);
            }

            _validatedRequest.Subject = result.Subject;
        }

        _logger.LogDebug("Validation of extension grant token request success");
        return Valid(result.CustomResponse);
    }

    // todo: do we want to rework the semantics of these ignore params?
    // also seems like other workflows other than CC clients can omit scopes?
    private async Task ValidateRequestedScopesAsync(NameValueCollection parameters, bool ignoreImplicitIdentityScopes = false, bool ignoreImplicitOfflineAccess = false)
    {
        var scopes = parameters.Get(OidcConstants.TokenRequest.Scope);
        if (scopes.IsMissing())
        {
            _logger.LogTrace("Client provided no scopes - checking allowed scopes list");

            if (!_validatedRequest.Client.AllowedScopes.EnumerableIsNullOrEmpty())
            {
                // this finds all the scopes the client is allowed to access
                var clientAllowedScopes = new List();
                if (!ignoreImplicitIdentityScopes)
                {
                    var resources = await _resourceStore.FindResourcesByScopeAsync(_validatedRequest.Client.AllowedScopes);
                    clientAllowedScopes.AddRange(resources.ToScopeNames().Where(x => _validatedRequest.Client.AllowedScopes.Contains(x)));
                }
                else
                {
                    var apiScopes = await _resourceStore.FindApiScopesByNameAsync(_validatedRequest.Client.AllowedScopes);
                    clientAllowedScopes.AddRange(apiScopes.Select(x => x.Name));
                }

                if (!ignoreImplicitOfflineAccess)
                {
                    if (_validatedRequest.Client.AllowOfflineAccess)
                    {
                        clientAllowedScopes.Add(IdentityServerConstants.StandardScopes.OfflineAccess);
                    }
                }

                scopes = clientAllowedScopes.Distinct().ToSpaceSeparatedString();
                _logger.LogTrace("Defaulting to: {scopes}", scopes);
            }
            else
            {
                LogError("No allowed scopes configured for client", new { clientId = _validatedRequest.Client.ClientId });
                return false;
            }
        }

        if (scopes.Length > _options.InputLengthRestrictions.Scope)
        {
            LogError("Scope parameter exceeds max allowed length");
            return false;
        }

        var requestedScopes = scopes.ParseScopesString();

        if (requestedScopes == null)
        {
            LogError("No scopes found in request");
            return false;
        }

        var resourceValidationResult = await _resourceValidator.ValidateRequestedResourcesAsync(new ResourceValidationRequest { 
            Client = _validatedRequest.Client,
            Scopes = requestedScopes
        });

        if (!resourceValidationResult.Succeeded)
        {
            if (resourceValidationResult.InvalidScopes.Any())
            {
                LogError("Invalid scopes requested");
            }
            else
            {
                LogError("Invalid scopes for client requested");
            }

            return false;
        }

        _validatedRequest.RequestedScopes = requestedScopes;
        _validatedRequest.ValidatedResources = resourceValidationResult;
        
        return true;
    }

    private TokenRequestValidationResult ValidateAuthorizationCodeWithProofKeyParameters(string codeVerifier, AuthorizationCode authZcode)
    {
        if (authZcode.CodeChallenge.IsMissing() || authZcode.CodeChallengeMethod.IsMissing())
        {
            LogError("Client is missing code challenge or code challenge method", new { clientId = _validatedRequest.Client.ClientId });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (codeVerifier.IsMissing())
        {
            LogError("Missing code_verifier");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (codeVerifier.Length < _options.InputLengthRestrictions.CodeVerifierMinLength ||
            codeVerifier.Length > _options.InputLengthRestrictions.CodeVerifierMaxLength)
        {
            LogError("code_verifier is too short or too long");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (Constants.SupportedCodeChallengeMethods.Contains(authZcode.CodeChallengeMethod) == false)
        {
            LogError("Unsupported code challenge method", new { codeChallengeMethod = authZcode.CodeChallengeMethod });
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        if (ValidateCodeVerifierAgainstCodeChallenge(codeVerifier, authZcode.CodeChallenge, authZcode.CodeChallengeMethod) == false)
        {
            LogError("Transformed code verifier does not match code challenge");
            return Invalid(OidcConstants.TokenErrors.InvalidGrant);
        }

        return Valid();
    }

    private bool ValidateCodeVerifierAgainstCodeChallenge(string codeVerifier, string codeChallenge, string codeChallengeMethod)
    {
        if (codeChallengeMethod == OidcConstants.CodeChallengeMethods.Plain)
        {
            return TimeConstantComparer.IsEqual(codeVerifier.Sha256(), codeChallenge);
        }

        var codeVerifierBytes = Encoding.ASCII.GetBytes(codeVerifier);
        var hashedBytes = codeVerifierBytes.Sha256();
        var transformedCodeVerifier = Base64Url.Encode(hashedBytes);

        return TimeConstantComparer.IsEqual(transformedCodeVerifier.Sha256(), codeChallenge);
    }

    private TokenRequestValidationResult Valid(Dictionary customResponse = null)
    {
        return new TokenRequestValidationResult(_validatedRequest, customResponse);
    }

    private TokenRequestValidationResult Invalid(string error, string errorDescription = null, Dictionary customResponse = null)
    {
        return new TokenRequestValidationResult(_validatedRequest, error, errorDescription, customResponse);
    }

    private void LogError(string message = null, object values = null)
    {
        LogWithRequestDetails(LogLevel.Error, message, values);
    }

    private void LogWarning(string message = null, object values = null)
    {
        LogWithRequestDetails(LogLevel.Warning, message, values);
    }

    private void LogInformation(string message = null, object values = null)
    {
        LogWithRequestDetails(LogLevel.Information, message, values);
    }

    private void LogWithRequestDetails(LogLevel logLevel, string message = null, object values = null)
    {
        var details = new TokenRequestValidationLog(_validatedRequest, _options.Logging.TokenRequestSensitiveValuesFilter);

        if (message.IsPresent())
        {
            try
            {
                if (values == null)
                {
                    _logger.Log(logLevel, message + ", {@details}", details);
                }
                else
                {
                    _logger.Log(logLevel, message + "{@values}, details: {@details}", values, details);
                }

            }
            catch (Exception ex)
            {
                _logger.LogError("Error logging {exception}, request details: {@details}", ex.Message, details);
            }
        }
        else
        {
            _logger.Log(logLevel, "{@details}", details);
        }
    }

    private void LogSuccess()
    {
        LogWithRequestDetails(LogLevel.Information, "Token request validation success");
    }

    private Task RaiseSuccessfulResourceOwnerAuthenticationEventAsync(string userName, string subjectId, string clientId)
    {
        return _events.RaiseAsync(new UserLoginSuccessEvent(userName, subjectId, null, interactive: false, clientId));
    }

    private Task RaiseFailedResourceOwnerAuthenticationEventAsync(string userName, string error, string clientId)
    {
        return _events.RaiseAsync(new UserLoginFailureEvent(userName, error, interactive: false, clientId: clientId));
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/TokenRevocationRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// The token revocation request validator
/// 
/// 
internal class TokenRevocationRequestValidator : ITokenRevocationRequestValidator
{
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The logger.
    public TokenRevocationRequestValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The client.
    /// 
    /// 
    /// parameters
    /// or
    /// client
    /// 
    public Task ValidateRequestAsync(NameValueCollection parameters, Client client)
    {
        _logger.LogTrace("ValidateRequestAsync called");

        if (parameters == null)
        {
            _logger.LogError("no parameters passed");
            throw new ArgumentNullException(nameof(parameters));
        }

        if (client == null)
        {
            _logger.LogError("no client passed");
            throw new ArgumentNullException(nameof(client));
        }

        ////////////////////////////
        // make sure token is present
        ///////////////////////////
        var token = parameters.Get("token");
        if (token.IsMissing())
        {
            _logger.LogError("No token found in request");
            return Task.FromResult(new TokenRevocationRequestValidationResult
            {
                IsError = true,
                Error = OidcConstants.TokenErrors.InvalidRequest
            });
        }

        var result = new TokenRevocationRequestValidationResult
        {
            IsError = false,
            Token = token,
            Client = client
        };

        ////////////////////////////
        // check token type hint
        ///////////////////////////
        var hint = parameters.Get("token_type_hint");
        if (hint.IsPresent())
        {
            if (Constants.SupportedTokenTypeHints.Contains(hint))
            {
                _logger.LogDebug("Token type hint found in request: {tokenTypeHint}", hint);
                result.TokenTypeHint = hint;
            }
            else
            {
                _logger.LogError("Invalid token type hint: {tokenTypeHint}", hint);
                result.IsError = true;
                result.Error = Constants.RevocationErrors.UnsupportedTokenType;
            }
        }

        _logger.LogDebug("ValidateRequestAsync result: {validateRequestResult}", result);

        return Task.FromResult(result);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/TokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.IdentityModel.Tokens;

namespace IdentityServer8.Validation;

internal class TokenValidator : ITokenValidator
{
    private readonly ILogger _logger;
    private readonly IdentityServerOptions _options;
    private readonly IHttpContextAccessor _context;
    private readonly IReferenceTokenStore _referenceTokenStore;
    private readonly ICustomTokenValidator _customValidator;
    private readonly IClientStore _clients;
    private readonly IProfileService _profile;
    private readonly IKeyMaterialService _keys;
    private readonly ISystemClock _clock;
    private readonly TokenValidationLog _log;

    public TokenValidator(
        IdentityServerOptions options,
        IHttpContextAccessor context,
        IClientStore clients,
        IProfileService profile,
        IReferenceTokenStore referenceTokenStore,
        IRefreshTokenStore refreshTokenStore,
        ICustomTokenValidator customValidator,
        IKeyMaterialService keys,
        ISystemClock clock,
        ILogger logger)
    {
        _options = options;
        _context = context;
        _clients = clients;
        _profile = profile;
        _referenceTokenStore = referenceTokenStore;
        _customValidator = customValidator;
        _keys = keys;
        _clock = clock;
        _logger = logger;

        _log = new TokenValidationLog();
    }

    public async Task ValidateIdentityTokenAsync(string token, string clientId = null, bool validateLifetime = true)
    {
        _logger.LogDebug("Start identity token validation");

        if (token.Length > _options.InputLengthRestrictions.Jwt)
        {
            _logger.LogError("JWT too long");
            return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        if (clientId.IsMissing())
        {
            clientId = GetClientIdFromJwt(token);

            if (clientId.IsMissing())
            {
                _logger.LogError("No clientId supplied, can't find id in identity token.");
                return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
            }
        }

        _log.ClientId = clientId;
        _log.ValidateLifetime = validateLifetime;

        var client = await _clients.FindEnabledClientByIdAsync(clientId);
        if (client == null)
        {
            _logger.LogError("Unknown or disabled client: {clientId}.", clientId);
            return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        _log.ClientName = client.ClientName;
        _logger.LogDebug("Client found: {clientId} / {clientName}", client.ClientId, client.ClientName);

        var keys = await _keys.GetValidationKeysAsync();
        var result = await ValidateJwtAsync(token, keys, audience: clientId, validateLifetime: validateLifetime);

        result.Client = client;

        if (result.IsError)
        {
            LogError("Error validating JWT");
            return result;
        }

        _logger.LogDebug("Calling into custom token validator: {type}", _customValidator.GetType().FullName);
        var customResult = await _customValidator.ValidateIdentityTokenAsync(result);

        if (customResult.IsError)
        {
            LogError("Custom validator failed: " + (customResult.Error ?? "unknown"));
            return customResult;
        }

        _log.Claims = customResult.Claims.ToClaimsDictionary();

        LogSuccess();
        return customResult;
    }

    public async Task ValidateAccessTokenAsync(string token, string expectedScope = null)
    {
        _logger.LogTrace("Start access token validation");

        _log.ExpectedScope = expectedScope;
        _log.ValidateLifetime = true;

        TokenValidationResult result;

        if (token.Contains("."))
        {
            if (token.Length > _options.InputLengthRestrictions.Jwt)
            {
                _logger.LogError("JWT too long");

                return new TokenValidationResult
                {
                    IsError = true,
                    Error = OidcConstants.ProtectedResourceErrors.InvalidToken,
                    ErrorDescription = "Token too long"
                };
            }

            _log.AccessTokenType = AccessTokenType.Jwt.ToString();
            result = await ValidateJwtAsync(
                token,
                await _keys.GetValidationKeysAsync());
        }
        else
        {
            if (token.Length > _options.InputLengthRestrictions.TokenHandle)
            {
                _logger.LogError("token handle too long");

                return new TokenValidationResult
                {
                    IsError = true,
                    Error = OidcConstants.ProtectedResourceErrors.InvalidToken,
                    ErrorDescription = "Token too long"
                };
            }

            _log.AccessTokenType = AccessTokenType.Reference.ToString();
            result = await ValidateReferenceAccessTokenAsync(token);
        }

        _log.Claims = result.Claims.ToClaimsDictionary();

        if (result.IsError)
        {
            return result;
        }

        // make sure client is still active (if client_id claim is present)
        var clientClaim = result.Claims.FirstOrDefault(c => c.Type == JwtClaimTypes.ClientId);
        if (clientClaim != null)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientClaim.Value);
            if (client == null)
            {
                _logger.LogError("Client deleted or disabled: {clientId}", clientClaim.Value);

                result.IsError = true;
                result.Error = OidcConstants.ProtectedResourceErrors.InvalidToken;
                result.Claims = null;

                return result;
            }
        }

        // make sure user is still active (if sub claim is present)
        var subClaim = result.Claims.FirstOrDefault(c => c.Type == JwtClaimTypes.Subject);
        if (subClaim != null)
        {
            var principal = Principal.Create("tokenvalidator", result.Claims.ToArray());

            if (result.ReferenceTokenId.IsPresent())
            {
                principal.Identities.First().AddClaim(new Claim(JwtClaimTypes.ReferenceTokenId, result.ReferenceTokenId));
            }

            var isActiveCtx = new IsActiveContext(principal, result.Client, IdentityServerConstants.ProfileIsActiveCallers.AccessTokenValidation);
            await _profile.IsActiveAsync(isActiveCtx);

            if (isActiveCtx.IsActive == false)
            {
                _logger.LogError("User marked as not active: {subject}", subClaim.Value);

                result.IsError = true;
                result.Error = OidcConstants.ProtectedResourceErrors.InvalidToken;
                result.Claims = null;

                return result;
            }
        }

        // check expected scope(s)
        if (expectedScope.IsPresent())
        {
            var scope = result.Claims.FirstOrDefault(c => c.Type == JwtClaimTypes.Scope && c.Value == expectedScope);
            if (scope == null)
            {
                LogError($"Checking for expected scope {expectedScope} failed");
                return Invalid(OidcConstants.ProtectedResourceErrors.InsufficientScope);
            }
        }

        _logger.LogDebug("Calling into custom token validator: {type}", _customValidator.GetType().FullName);
        var customResult = await _customValidator.ValidateAccessTokenAsync(result);

        if (customResult.IsError)
        {
            LogError("Custom validator failed: " + (customResult.Error ?? "unknown"));
            return customResult;
        }

        // add claims again after custom validation
        _log.Claims = customResult.Claims.ToClaimsDictionary();

        LogSuccess();
        return customResult;
    }

    private async Task ValidateJwtAsync(string jwt, IEnumerable validationKeys, bool validateLifetime = true, string audience = null)
    {
        var handler = new JwtSecurityTokenHandler();
        handler.InboundClaimTypeMap.Clear();

        var parameters = new TokenValidationParameters
        {
            ValidIssuer = _context.HttpContext.GetIdentityServerIssuerUri(),
            IssuerSigningKeys = validationKeys.Select(k => k.Key),
            ValidateLifetime = validateLifetime
        };

        if (audience.IsPresent())
        {
            parameters.ValidAudience = audience;
        }
        else
        {
            parameters.ValidateAudience = false;
        }

        try
        {
            var id = handler.ValidateToken(jwt, parameters, out var securityToken);
            var jwtSecurityToken = securityToken as JwtSecurityToken;

            // if no audience is specified, we make at least sure that it is an access token
            if (audience.IsMissing())
            {
                if (_options.AccessTokenJwtType.IsPresent())
                {
                    var type = jwtSecurityToken.Header.Typ;
                    if (!string.Equals(type, _options.AccessTokenJwtType))
                    {
                        return new TokenValidationResult
                        {
                            IsError = true,
                            Error = "invalid JWT token type"
                        };
                    }

                }
            }
            
            // if access token contains an ID, log it
            var jwtId = id.FindFirst(JwtClaimTypes.JwtId);
            if (jwtId != null)
            {
                _log.JwtId = jwtId.Value;
            }

            // load the client that belongs to the client_id claim
            Client client = null;
            var clientId = id.FindFirst(JwtClaimTypes.ClientId);
            if (clientId != null)
            {
                client = await _clients.FindEnabledClientByIdAsync(clientId.Value);
                if (client == null)
                {
                    throw new InvalidOperationException("Client does not exist anymore.");
                }
            }

            var claims = id.Claims.ToList();
            
            // check the scope format (array vs space delimited string)
            var scopes = claims.Where(c => c.Type == JwtClaimTypes.Scope).ToArray();
            if (scopes.Any())
            {
                foreach (var scope in scopes)
                {
                    if (scope.Value.Contains(" "))
                    {
                        claims.Remove(scope);
                        
                        var values = scope.Value.Split(' ', StringSplitOptions.RemoveEmptyEntries);
                        foreach (var value in values)
                        {
                            claims.Add(new Claim(JwtClaimTypes.Scope, value));
                        }
                    }
                }
            }

            return new TokenValidationResult
            {
                IsError = false,

                Claims = claims,
                Client = client,
                Jwt = jwt
            };
        }
        catch (SecurityTokenExpiredException expiredException)
        {
            _logger.LogInformation(expiredException, "JWT token validation error: {exception}", expiredException.Message);
            return Invalid(OidcConstants.ProtectedResourceErrors.ExpiredToken);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "JWT token validation error: {exception}", ex.Message);
            return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }
    }

    private async Task ValidateReferenceAccessTokenAsync(string tokenHandle)
    {
        _log.TokenHandle = tokenHandle;
        var token = await _referenceTokenStore.GetReferenceTokenAsync(tokenHandle);

        if (token == null)
        {
            LogError("Invalid reference token.");
            return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        if (token.CreationTime.HasExceeded(token.Lifetime, _clock.UtcNow.UtcDateTime))
        {
            LogError("Token expired.");

            await _referenceTokenStore.RemoveReferenceTokenAsync(tokenHandle);
            return Invalid(OidcConstants.ProtectedResourceErrors.ExpiredToken);
        }

        // load the client that is defined in the token
        Client client = null;
        if (token.ClientId != null)
        {
            client = await _clients.FindEnabledClientByIdAsync(token.ClientId);
        }

        if (client == null)
        {
            LogError($"Client deleted or disabled: {token.ClientId}");
            return Invalid(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        return new TokenValidationResult
        {
            IsError = false,

            Client = client,
            Claims = ReferenceTokenToClaims(token),
            ReferenceToken = token,
            ReferenceTokenId = tokenHandle
        };
    }

    private IEnumerable ReferenceTokenToClaims(Token token)
    {
        var claims = new List
        {
            new Claim(JwtClaimTypes.Issuer, token.Issuer),
            new Claim(JwtClaimTypes.NotBefore, new DateTimeOffset(token.CreationTime).ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64),
            new Claim(JwtClaimTypes.Expiration, new DateTimeOffset(token.CreationTime).AddSeconds(token.Lifetime).ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64)
        };

        foreach (var aud in token.Audiences)
        {
            claims.Add(new Claim(JwtClaimTypes.Audience, aud));
        }

        claims.AddRange(token.Claims);
        return claims;
    }

    private string GetClientIdFromJwt(string token)
    {
        try
        {
            var jwt = new JwtSecurityToken(token);
            var clientId = jwt.Audiences.FirstOrDefault();

            return clientId;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Malformed JWT token: {exception}", ex.Message);
            return null;
        }
    }

    private TokenValidationResult Invalid(string error)
    {
        return new TokenValidationResult
        {
            IsError = true,
            Error = error
        };
    }

    private void LogError(string message)
    {
        _logger.LogError(message + "\n{@logMessage}", _log);
    }

    private void LogSuccess()
    {
        _logger.LogDebug("Token validation success\n{@logMessage}", _log);
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/UserInfoRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Default userinfo request validator
/// 
/// 
internal class UserInfoRequestValidator : IUserInfoRequestValidator
{
    private readonly ITokenValidator _tokenValidator;
    private readonly IProfileService _profile;
    private readonly ILogger _logger;

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The token validator.
    /// The profile service
    /// The logger.
    public UserInfoRequestValidator(
        ITokenValidator tokenValidator, 
        IProfileService profile,
        ILogger logger)
    {
        _tokenValidator = tokenValidator;
        _profile = profile;
        _logger = logger;
    }

    /// 
    /// Validates a userinfo request.
    /// 
    /// The access token.
    /// 
    /// 
    public async Task ValidateRequestAsync(string accessToken)
    {
        // the access token needs to be valid and have at least the openid scope
        var tokenResult = await _tokenValidator.ValidateAccessTokenAsync(
            accessToken,
            IdentityServerConstants.StandardScopes.OpenId);

        if (tokenResult.IsError)
        {
            return new UserInfoRequestValidationResult
            {
                IsError = true,
                Error = tokenResult.Error
            };
        }

        // the token must have a one sub claim
        var subClaim = tokenResult.Claims.SingleOrDefault(c => c.Type == JwtClaimTypes.Subject);
        if (subClaim == null)
        {
            _logger.LogError("Token contains no sub claim");

            return new UserInfoRequestValidationResult
            {
                IsError = true,
                Error = OidcConstants.ProtectedResourceErrors.InvalidToken
            };
        }

        // create subject from incoming access token
        var claims = tokenResult.Claims.Where(x => !Constants.Filters.ProtocolClaimsFilter.Contains(x.Type));
        var subject = Principal.Create("UserInfo", claims.ToArray());

        // make sure user is still active
        var isActiveContext = new IsActiveContext(subject, tokenResult.Client, IdentityServerConstants.ProfileIsActiveCallers.UserInfoRequestValidation);
        await _profile.IsActiveAsync(isActiveContext);

        if (isActiveContext.IsActive == false)
        {
            _logger.LogError("User is not active: {sub}", subject.GetSubjectId());

            return new UserInfoRequestValidationResult
            {
                IsError = true,
                Error = OidcConstants.ProtectedResourceErrors.InvalidToken
            };
        }

        return new UserInfoRequestValidationResult
        {
            IsError = false,
            TokenValidationResult = tokenResult,
            Subject = subject
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/X509NameSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for an X.509 certificate based client secret using the common name
/// 
public class X509NameSecretValidator : ISecretValidator
{
    private readonly ILogger _logger;

    /// 
    /// ctor
    /// 
    /// 
    public X509NameSecretValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    public Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var fail = Task.FromResult(new SecretValidationResult { Success = false });

        if (parsedSecret.Type != ParsedSecretTypes.X509Certificate)
        {
            _logger.LogDebug("X509 name secret validator cannot process {type}", parsedSecret.Type ?? "null");
            return fail;
        }

        if (!(parsedSecret.Credential is X509Certificate2 cert))
        {
            throw new InvalidOperationException("Credential is not a x509 certificate.");
        }

        var name = cert.Subject;
        if (name == null)
        {
            _logger.LogWarning("No subject/name found in X509 certificate.");
            return fail;
        }

        var nameSecrets = secrets.Where(s => s.Type == SecretTypes.X509CertificateName);
        if (!nameSecrets.Any())
        {
            _logger.LogDebug("No x509 name secrets configured for client.");
            return fail;
        }

        foreach (var nameSecret in nameSecrets)
        {
            if (name.Equals(nameSecret.Value, StringComparison.Ordinal))
            {
                var result = new SecretValidationResult
                {
                    Success = true,
                    Confirmation = cert.CreateThumbprintCnf()
                };

                return Task.FromResult(result);
            }
        }

        _logger.LogDebug("No matching x509 name secret found.");
        return fail;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Default/X509ThumbprintSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for an X.509 certificate based client secret using the thumbprint
/// 
public class X509ThumbprintSecretValidator : ISecretValidator
{
    private readonly ILogger _logger;

    /// 
    /// ctor
    /// 
    /// 
    public X509ThumbprintSecretValidator(ILogger logger)
    {
        _logger = logger;
    }

    /// 
    public Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        var fail = Task.FromResult(new SecretValidationResult { Success = false });

        if (parsedSecret.Type != ParsedSecretTypes.X509Certificate)
        {
            _logger.LogDebug("X509 thumbprint secret validator cannot process {type}", parsedSecret.Type ?? "null");
            return fail;
        }

        if (!(parsedSecret.Credential is X509Certificate2 cert))
        {
            throw new InvalidOperationException("Credential is not a x509 certificate.");
        }

        var thumbprint = cert.Thumbprint;
        if (thumbprint == null)
        {
            _logger.LogWarning("No thumbprint found in X509 certificate.");
            return fail;
        }

        var thumbprintSecrets = secrets.Where(s => s.Type == SecretTypes.X509CertificateThumbprint);
        if (!thumbprintSecrets.Any())
        {
            _logger.LogDebug("No thumbprint secrets configured for client.");
            return fail;
        }

        foreach (var thumbprintSecret in thumbprintSecrets)
        {
            if (thumbprint.Equals(thumbprintSecret.Value, StringComparison.OrdinalIgnoreCase))
            {
                var result = new SecretValidationResult
                {
                    Success = true,
                    Confirmation = cert.CreateThumbprintCnf()
                };

                return Task.FromResult(result);
            }
        }

        _logger.LogDebug("No matching x509 thumbprint secret found.");
        return fail;
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/IApiSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for handling API client authentication.
/// 
public interface IApiSecretValidator
{
    /// 
    /// Tries to authenticate an API client based on the incoming request
    /// 
    /// The context.
    /// 
    Task ValidateAsync(HttpContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/IAuthorizeRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
///  Authorize endpoint request validator.
/// 
public interface IAuthorizeRequestValidator
{
    /// 
    ///  Validates authorize request parameters.
    /// 
    /// 
    /// 
    /// 
    Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject = null);
}


================================================
FILE: src/IdentityServer8/src/Validation/IClientConfigurationValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for handling client authentication
/// 
public interface IClientConfigurationValidator
{
    /// 
    /// Determines whether the configuration of a client is valid.
    /// 
    /// The context.
    /// 
    Task ValidateAsync(ClientConfigurationValidationContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/IClientSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for handling client authentication
/// 
public interface IClientSecretValidator
{
    /// 
    /// Tries to authenticate a client based on the incoming request
    /// 
    /// The context.
    /// 
    Task ValidateAsync(HttpContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/ICustomAuthorizeRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Allows inserting custom validation logic into authorize and token requests
/// 
public interface ICustomAuthorizeRequestValidator
{
    /// 
    /// Custom validation logic for the authorize request.
    /// 
    /// The context.
    Task ValidateAsync(CustomAuthorizeRequestValidationContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/ICustomTokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Allows inserting custom validation logic into token requests
/// 
public interface ICustomTokenRequestValidator
{
    /// 
    /// Custom validation logic for a token request.
    /// 
    /// The context.
    /// 
    /// The validation result
    /// 
    Task ValidateAsync(CustomTokenRequestValidationContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/ICustomTokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Allows inserting custom token validation logic
/// 
public interface ICustomTokenValidator
{
    /// 
    /// Custom validation logic for access tokens.
    /// 
    /// The validation result so far.
    /// The validation result
    Task ValidateAccessTokenAsync(TokenValidationResult result);

    /// 
    /// Custom validation logic for identity tokens.
    /// 
    /// The validation result so far.
    /// The validation result
    Task ValidateIdentityTokenAsync(TokenValidationResult result);
}


================================================
FILE: src/IdentityServer8/src/Validation/IDeviceAuthorizationRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
///  Device authorization endpoint request validator.
/// 
public interface IDeviceAuthorizationRequestValidator
{
    /// 
    ///  Validates authorize request parameters.
    /// 
    /// 
    /// 
    /// 
    Task ValidateAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult);
}


================================================
FILE: src/IdentityServer8/src/Validation/IDeviceCodeValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// The device code validator
/// 
public interface IDeviceCodeValidator
{
    /// 
    /// Validates the device code.
    /// 
    /// The context.
    /// 
    Task ValidateAsync(DeviceCodeValidationContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/IEndSessionRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
///  Validates end session requests.
/// 
public interface IEndSessionRequestValidator
{
    /// 
    /// Validates end session endpoint requests.
    /// 
    /// 
    /// 
    /// 
    Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject);

    /// 
    ///  Validates requests from logout page iframe to trigger single signout.
    /// 
    /// 
    /// 
    Task ValidateCallbackAsync(NameValueCollection parameters);
}


================================================
FILE: src/IdentityServer8/src/Validation/IExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Handles validation of token requests using custom grant types
/// 
public interface IExtensionGrantValidator
{
    /// 
    /// Validates the custom grant request.
    /// 
    /// The context.
    /// 
    /// A principal
    /// 
    Task ValidateAsync(ExtensionGrantValidationContext context);

    /// 
    /// Returns the grant type this validator can deal with
    /// 
    /// 
    /// The type of the grant.
    /// 
    string GrantType { get; }
}


================================================
FILE: src/IdentityServer8/src/Validation/IIntrospectionRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Interface for the introspection request validator
/// 
public interface IIntrospectionRequestValidator
{
    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The API.
    /// 
    Task ValidateAsync(NameValueCollection parameters, ApiResource api);
}


================================================
FILE: src/IdentityServer8/src/Validation/IRedirectUriValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the logic when validating redirect and post logout redirect URIs.
/// 
public interface IRedirectUriValidator
{
    /// 
    /// Determines whether a redirect URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// true is the URI is valid; false otherwise.
    Task IsRedirectUriValidAsync(string requestedUri, Client client);
    
    /// 
    /// Determines whether a post logout URI is valid for a client.
    /// 
    /// The requested URI.
    /// The client.
    /// true is the URI is valid; false otherwise.
    Task IsPostLogoutRedirectUriValidAsync(string requestedUri, Client client);
}


================================================
FILE: src/IdentityServer8/src/Validation/IResourceOwnerPasswordValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Handles validation of resource owner password credentials
/// 
public interface IResourceOwnerPasswordValidator
{
    /// 
    /// Validates the resource owner password credential
    /// 
    /// The context.
    Task ValidateAsync(ResourceOwnerPasswordValidationContext context);
}


================================================
FILE: src/IdentityServer8/src/Validation/IResourceValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validates requested resources (scopes and resource indicators)
/// 
public interface IResourceValidator
{
    // todo: should this be used anywhere we re-create tokens? do we need to re-run scope validation?

    /// 
    /// Validates the requested resources for the client.
    /// 
    Task ValidateRequestedResourcesAsync(ResourceValidationRequest request);
}


================================================
FILE: src/IdentityServer8/src/Validation/IScopeParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Allows parsing raw scopes values into structured scope values.
/// 
public interface IScopeParser
{
    // todo: test return no error, and no parsed scopes. how do callers behave?
    /// 
    /// Parses the requested scopes.
    /// 
    ParsedScopesResult ParseScopeValues(IEnumerable scopeValues);
}


================================================
FILE: src/IdentityServer8/src/Validation/ISecretParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// A service for parsing secrets found on the request
/// 
public interface ISecretParser
{
    /// 
    /// Tries to find a secret on the context that can be used for authentication
    /// 
    /// The HTTP context.
    /// 
    /// A parsed secret
    /// 
    Task ParseAsync(HttpContext context);

    /// 
    /// Returns the authentication method name that this parser implements
    /// 
    /// 
    /// The authentication method.
    /// 
    string AuthenticationMethod { get; }
}


================================================
FILE: src/IdentityServer8/src/Validation/ISecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Service for validating a received secret against a stored secret
/// 
public interface ISecretValidator
{
    /// 
    /// Validates a secret
    /// 
    /// The stored secrets.
    /// The received secret.
    /// A validation result
    Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret);
}


================================================
FILE: src/IdentityServer8/src/Validation/ISecretsListParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Parser for finding the best secret in an Enumerable List
/// 
public interface ISecretsListParser
{
    /// 
    /// Tries to find the best secret on the context that can be used for authentication
    /// 
    /// The HTTP context.
    /// 
    /// A parsed secret
    /// 
    Task ParseAsync(HttpContext context);

    /// 
    /// Gets all available authentication methods.
    /// 
    /// 
    IEnumerable GetAvailableAuthenticationMethods();
}


================================================
FILE: src/IdentityServer8/src/Validation/ISecretsListValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for an Enumerable List of Secrets
/// 
public interface ISecretsListValidator
{
    /// 
    /// Validates a list of secrets
    /// 
    /// The stored secrets.
    /// The received secret.
    /// A validation result
    Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret);
}


================================================
FILE: src/IdentityServer8/src/Validation/ITokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Interface for the token request validator
/// 
public interface ITokenRequestValidator
{
    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The client validation result.
    /// 
    Task ValidateRequestAsync(NameValueCollection parameters, ClientSecretValidationResult clientValidationResult);
}


================================================
FILE: src/IdentityServer8/src/Validation/ITokenRevocationRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Interface for the token revocation request validator
/// 
public interface ITokenRevocationRequestValidator
{
    /// 
    /// Validates the request.
    /// 
    /// The parameters.
    /// The client.
    /// 
    Task ValidateRequestAsync(NameValueCollection parameters, Client client);
}


================================================
FILE: src/IdentityServer8/src/Validation/ITokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Interface for the token validator
/// 
public interface ITokenValidator
{
    /// 
    /// Validates an access token.
    /// 
    /// The access token.
    /// The expected scope.
    /// 
    Task ValidateAccessTokenAsync(string token, string expectedScope = null);
    
    /// 
    /// Validates an identity token.
    /// 
    /// The token.
    /// The client identifier.
    /// if set to true the lifetime gets validated. Otherwise not.
    /// 
    Task ValidateIdentityTokenAsync(string token, string clientId = null, bool validateLifetime = true);
}


================================================
FILE: src/IdentityServer8/src/Validation/IUserInfoRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validator for userinfo requests
/// 
public interface IUserInfoRequestValidator
{
    /// 
    /// Validates a userinfo request.
    /// 
    /// The access token.
    /// 
    Task ValidateRequestAsync(string accessToken);
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/AuthorizeRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for authorize requests
/// 
public class AuthorizeRequestValidationResult : ValidationResult
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    public AuthorizeRequestValidationResult(ValidatedAuthorizeRequest request)
    {
        ValidatedRequest = request;
        IsError = false;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// The error.
    /// The error description.
    public AuthorizeRequestValidationResult(ValidatedAuthorizeRequest request, string error, string errorDescription = null)
    {
        ValidatedRequest = request;
        IsError = true;
        Error = error;
        ErrorDescription = errorDescription;
    }

    /// 
    /// Gets or sets the validated request.
    /// 
    /// 
    /// The validated request.
    /// 
    public ValidatedAuthorizeRequest ValidatedRequest { get; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/BearerTokenUsageType.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Validation;

public enum BearerTokenUsageType
{
    AuthorizationHeader = 0,
    PostBody = 1,
    QueryString = 2
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/BearerTokenUsageValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models usage of a bearer token
/// 
public class BearerTokenUsageValidationResult
{
    /// 
    /// Gets or sets a value indicating whether the token was found.
    /// 
    /// 
    ///   true if the token was found; otherwise, false.
    /// 
    public bool TokenFound { get; set; }

    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }

    /// 
    /// Gets or sets the usage type.
    /// 
    /// 
    /// The type of the usage.
    /// 
    public BearerTokenUsageType UsageType { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ClientSecretValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for client validation
/// 
public class ClientSecretValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// Gets or sets the secret used to authenticate the client.
    /// 
    /// 
    /// The secret.
    /// 
    public ParsedSecret Secret { get; set; }

    /// 
    /// Gets or sets the value of the confirmation method (will become the cnf claim). Must be a JSON object.
    /// 
    /// 
    /// The confirmation.
    /// 
    public string Confirmation { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/DeviceAuthorizationRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for device authorization requests
/// 
public class DeviceAuthorizationRequestValidationResult : ValidationResult
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    public DeviceAuthorizationRequestValidationResult(ValidatedDeviceAuthorizationRequest request)
    {
        IsError = false;

        ValidatedRequest = request;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The request.
    /// The error.
    /// The error description.
    public DeviceAuthorizationRequestValidationResult(ValidatedDeviceAuthorizationRequest request, string error, string errorDescription = null)
    {
        IsError = true;

        Error = error;
        ErrorDescription = errorDescription;
        ValidatedRequest = request;
    }

    /// 
    /// Gets the validated request.
    /// 
    /// 
    /// The validated request.
    /// 
    public ValidatedDeviceAuthorizationRequest ValidatedRequest { get; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/DeviceCodeValidationContext.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for device code validation request.
/// 
public class DeviceCodeValidationContext
{
    /// 
    /// Gets or sets the device code.
    /// 
    /// 
    /// The device code.
    /// 
    public string DeviceCode { get; set; }

    /// 
    /// Gets or sets the request.
    /// 
    /// 
    /// The request.
    /// 
    public ValidatedTokenRequest Request { get; set; }

    /// 
    /// Gets or sets the result.
    /// 
    /// 
    /// The result.
    /// 
    public TokenRequestValidationResult Result { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/EndSessionCallbackValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for end session callback requests.
/// 
/// 
public class EndSessionCallbackValidationResult : ValidationResult
{
    /// 
    /// Gets the client front-channel logout urls.
    /// 
    public IEnumerable FrontChannelLogoutUrls { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/EndSessionValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for end session requests
/// 
/// 
public class EndSessionValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the validated request.
    /// 
    /// 
    /// The validated request.
    /// 
    public ValidatedEndSessionRequest ValidatedRequest { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/GrantValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the result of custom grant validation.
/// 
public class GrantValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the principal which represents the result of the validation.
    /// 
    /// 
    /// The principal.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Custom fields for the token response
    /// 
    public Dictionary CustomResponse { get; set; } = new Dictionary();

    /// 
    /// Initializes a new instance of the  class with no subject.
    /// Warning: the resulting access token will only contain the client identity.
    /// 
    public GrantValidationResult(Dictionary customResponse = null)
    {
        IsError = false;
        CustomResponse = customResponse;
    }

    /// 
    /// Initializes a new instance of the  class with a given principal.
    /// Warning: the principal needs to include the required claims - it is recommended to use the other constructor that does validation.
    /// 
    public GrantValidationResult(ClaimsPrincipal principal, Dictionary customResponse = null)
    {
        IsError = false;

        if (principal.Identities.Count() != 1) throw new InvalidOperationException("only a single identity supported");
        if (principal.FindFirst(JwtClaimTypes.Subject) == null) throw new InvalidOperationException("sub claim is missing");
        if (principal.FindFirst(JwtClaimTypes.IdentityProvider) == null) throw new InvalidOperationException("idp claim is missing");
        if (principal.FindFirst(JwtClaimTypes.AuthenticationMethod) == null) throw new InvalidOperationException("amr claim is missing");
        if (principal.FindFirst(JwtClaimTypes.AuthenticationTime) == null) throw new InvalidOperationException("auth_time claim is missing");

        Subject = principal;
        CustomResponse = customResponse;
    }

    /// 
    /// Initializes a new instance of the  class with an error and description.
    /// 
    /// The error.
    /// The error description.
    /// Custom response elements
    public GrantValidationResult(TokenRequestErrors error, string errorDescription = null, Dictionary customResponse = null)
    {
        Error = ConvertTokenErrorEnumToString(error);
        ErrorDescription = errorDescription;
        CustomResponse = customResponse;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject claim used to uniquely identifier the user.
    /// The authentication method which describes the custom grant type.
    /// Additional claims that will be maintained in the principal. 
    /// If you want these claims to appear in token, you need to add them explicitly in your custom implementation of  service.
    /// The identity provider.
    /// The custom response.
    public GrantValidationResult(
        string subject,
        string authenticationMethod,
        IEnumerable claims = null,
        string identityProvider = IdentityServerConstants.LocalIdentityProvider,
        Dictionary customResponse = null)
        : this(subject, authenticationMethod, DateTime.UtcNow, claims, identityProvider, customResponse)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The subject claim used to uniquely identifier the user.
    /// The authentication method which describes the custom grant type.
    /// The UTC date/time of authentication.
    /// Additional claims that will be maintained in the principal.
    /// If you want these claims to appear in token, you need to add them explicitly in your custom implementation of  service.
    /// The identity provider.
    /// The custom response.
    public GrantValidationResult(
        string subject,
        string authenticationMethod,
        DateTime authTime,
        IEnumerable claims = null,
        string identityProvider = IdentityServerConstants.LocalIdentityProvider,
        Dictionary customResponse = null)
    {
        IsError = false;

        var resultClaims = new List
        {
            new Claim(JwtClaimTypes.Subject, subject),
            new Claim(JwtClaimTypes.AuthenticationMethod, authenticationMethod),
            new Claim(JwtClaimTypes.IdentityProvider, identityProvider),
            new Claim(JwtClaimTypes.AuthenticationTime, new DateTimeOffset(authTime).ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64)
        };

        if (!claims.EnumerableIsNullOrEmpty())
        {
            resultClaims.AddRange(claims);
        }

        var id = new ClaimsIdentity(authenticationMethod);
        id.AddClaims(resultClaims.Distinct(new ClaimComparer()));

        Subject = new ClaimsPrincipal(id);
        CustomResponse = customResponse;
    }

    private string ConvertTokenErrorEnumToString(TokenRequestErrors error)
    {
        return error switch
        {
            TokenRequestErrors.InvalidClient => OidcConstants.TokenErrors.InvalidClient,
            TokenRequestErrors.InvalidGrant => OidcConstants.TokenErrors.InvalidGrant,
            TokenRequestErrors.InvalidRequest => OidcConstants.TokenErrors.InvalidRequest,
            TokenRequestErrors.InvalidScope => OidcConstants.TokenErrors.InvalidScope,
            TokenRequestErrors.UnauthorizedClient => OidcConstants.TokenErrors.UnauthorizedClient,
            TokenRequestErrors.UnsupportedGrantType => OidcConstants.TokenErrors.UnsupportedGrantType,
            TokenRequestErrors.InvalidTarget => OidcConstants.TokenErrors.InvalidTarget,
            _ => throw new InvalidOperationException("invalid token error")
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/IntrospectionRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for introspection request
/// 
/// 
public class IntrospectionRequestValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the request parameters.
    /// 
    /// 
    /// The parameters.
    /// 
    public NameValueCollection Parameters { get; set; }

    /// 
    /// Gets or sets the API.
    /// 
    /// 
    /// The API.
    /// 
    public ApiResource Api { get; set; }

    /// 
    /// Gets or sets a value indicating whether the token is active.
    /// 
    /// 
    ///   true if the token is active; otherwise, false.
    /// 
    public bool IsActive { get; set; }

    /// 
    /// Gets or sets the claims.
    /// 
    /// 
    /// The claims.
    /// 
    public IEnumerable Claims { get; set; }

    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }
}

/// 
/// Failure reasons for introspection request
/// 
public enum IntrospectionRequestValidationFailureReason
{
    /// 
    /// none
    /// 
    None,

    /// 
    /// missing token
    /// 
    MissingToken,

    /// 
    /// invalid token
    /// 
    InvalidToken,

    /// 
    /// invalid scope
    /// 
    InvalidScope
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/JwtRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the result of JWT request validation.
/// 
public class JwtRequestValidationResult : ValidationResult
{
    /// 
    /// The key/value pairs from the JWT payload of a successfuly validated request.
    /// 
    public Dictionary Payload { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ParsedScopeValidationError.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models an error parsing a scope.
/// 
public class ParsedScopeValidationError
{
    /// 
    /// Ctor
    /// 
    /// 
    /// 
    public ParsedScopeValidationError(string rawValue, string error)
    {
        if (String.IsNullOrWhiteSpace(rawValue))
        {
            throw new ArgumentNullException(nameof(rawValue));
        }

        if (String.IsNullOrWhiteSpace(error))
        {
            throw new ArgumentNullException(nameof(error));
        }

        RawValue = rawValue;
        Error = error;
    }

    /// 
    /// The original (raw) value of the scope.
    /// 
    public string RawValue { get; set; }

    /// 
    /// Error message describing why the raw scope failed to be parsed.
    /// 
    public string Error { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ParsedScopeValue.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models a parsed scope value.
/// 
public class ParsedScopeValue
{
    /// 
    /// Ctor
    /// 
    /// 
    public ParsedScopeValue(string rawValue)
        : this(rawValue, rawValue, null)
    {
    }

    /// 
    /// Ctor
    /// 
    /// 
    /// 
    /// 
    public ParsedScopeValue(string rawValue, string parsedName, string parsedParameter)
    {
        if (String.IsNullOrWhiteSpace(rawValue))
        {
            throw new ArgumentNullException(nameof(rawValue));
        }

        if (String.IsNullOrWhiteSpace(parsedName))
        {
            throw new ArgumentNullException(nameof(parsedName));
        }

        RawValue = rawValue;
        ParsedName = parsedName;
        ParsedParameter = parsedParameter;
    }

    /// 
    /// The original (raw) value of the scope.
    /// 
    public string RawValue { get; set; }

    /// 
    /// The parsed name of the scope. If the scope has no structure, the parsed name will be the same as the raw value.
    /// 
    public string ParsedName { get; set; }

    // future: maybe this should be something w/ more structure? dictionary?
    /// 
    /// The parameter value of the parsed scope. If the scope has no structure, then the value will be null.
    /// 
    public string ParsedParameter { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ParsedScopesResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Represents the result of scope parsing.
/// 
public class ParsedScopesResult
{
    /// 
    /// The valid parsed scopes.
    /// 
    public ICollection ParsedScopes { get; set; } = new HashSet();

    /// 
    /// The errors encountered while parsing.
    /// 
    public ICollection Errors { get; set; } = new HashSet();

    /// 
    /// Indicates if the result of parsing the scopes was successful.
    /// 
    public bool Succeeded => Errors == null || !Errors.Any();
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ResourceValidationRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the request to validate scopes and resource indicators for a client.
/// 
public class ResourceValidationRequest
{
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// The requested scope values.
    /// 
    public IEnumerable Scopes { get; set; }

    // /// 
    // /// The requested resource indicators.
    // /// 
    //  todo: add back when we support resource indicators
    // public IEnumerable ResourceIndicators { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ResourceValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Result of validation of requested scopes and resource indicators.
/// 
public class ResourceValidationResult
{
    /// 
    /// Ctor
    /// 
    public ResourceValidationResult()
    {
    }

    /// 
    /// Ctor
    /// 
    /// 
    public ResourceValidationResult(Resources resources)
    {
        Resources = resources;
        ParsedScopes = resources.ToScopeNames().Select(x => new ParsedScopeValue(x)).ToList();
    }

    /// 
    /// Ctor
    /// 
    /// 
    /// 
    public ResourceValidationResult(Resources resources, IEnumerable parsedScopeValues)
    {
        Resources = resources;
        ParsedScopes = parsedScopeValues.ToList();
    }

    /// 
    /// Indicates if the result was successful.
    /// 
    public bool Succeeded => ParsedScopes.Any() && !InvalidScopes.Any();

    /// 
    /// The resources of the result.
    /// 
    public Resources Resources { get; set; } = new Resources();

    /// 
    /// The parsed scopes represented by the result.
    /// 
    public ICollection ParsedScopes { get; set; } = new HashSet();

    /// 
    /// The original (raw) scope values represented by the validated result.
    /// 
    public IEnumerable RawScopeValues => ParsedScopes.Select(x => x.RawValue);

    /// 
    /// The requested scopes that are invalid.
    /// 
    public ICollection InvalidScopes { get; set; } = new HashSet();

    /// 
    /// Returns new result filted by the scope values.
    /// 
    /// 
    /// 
    public ResourceValidationResult Filter(IEnumerable scopeValues)
    {
        scopeValues ??= Enumerable.Empty();

        var offline = scopeValues.Contains(IdentityServerConstants.StandardScopes.OfflineAccess);

        var parsedScopesToKeep = ParsedScopes.Where(x => scopeValues.Contains(x.RawValue)).ToArray();
        var parsedScopeNamesToKeep = parsedScopesToKeep.Select(x => x.ParsedName).ToArray();

        var identityToKeep = Resources.IdentityResources.Where(x => parsedScopeNamesToKeep.Contains(x.Name));
        var apiScopesToKeep = Resources.ApiScopes.Where(x => parsedScopeNamesToKeep.Contains(x.Name));

        var apiScopesNamesToKeep = apiScopesToKeep.Select(x => x.Name).ToArray();
        var apiResourcesToKeep = Resources.ApiResources.Where(x => x.Scopes.Any(y => apiScopesNamesToKeep.Contains(y)));

        var resources = new Resources(identityToKeep, apiResourcesToKeep, apiScopesToKeep)
        {
            OfflineAccess = offline
        };
        
        return new ResourceValidationResult()
        {
            Resources = resources,
            ParsedScopes = parsedScopesToKeep
        };
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ScopeSecretValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for API validation
/// 
public class ApiSecretValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the resource.
    /// 
    /// 
    /// The resource.
    /// 
    public ApiResource Resource { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/SecretValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for secrets
/// 
public class SecretValidationResult : ValidationResult
{
    /// 
    /// Gets or sets a value indicating whether the secret validation was successful.
    /// 
    /// 
    ///   true if success; otherwise, false.
    /// 
    public bool Success { get; set; }

    /// 
    /// Gets or sets the value of the confirmation method (will become the cnf claim). Must be a JSON object.
    /// 
    /// 
    /// The confirmation.
    /// 
    public string Confirmation { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/TokenRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for token requests
/// 
public class TokenRequestValidationResult : ValidationResult
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The validated request.
    /// The custom response.
    public TokenRequestValidationResult(ValidatedTokenRequest validatedRequest, Dictionary customResponse = null)
    {
        IsError = false;

        ValidatedRequest = validatedRequest;
        CustomResponse = customResponse;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The validated request.
    /// The error.
    /// The error description.
    /// The custom response.
    public TokenRequestValidationResult(ValidatedTokenRequest validatedRequest, string error, string errorDescription = null, Dictionary customResponse = null)
    {
        IsError = true;

        Error = error;
        ErrorDescription = errorDescription;
        ValidatedRequest = validatedRequest;
        CustomResponse = customResponse;
    }

    /// 
    /// Gets the validated request.
    /// 
    /// 
    /// The validated request.
    /// 
    public ValidatedTokenRequest ValidatedRequest { get; }

    /// 
    /// Gets or sets the custom response.
    /// 
    /// 
    /// The custom response.
    /// 
    public Dictionary CustomResponse { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/TokenRevocationRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the validation result of access tokens and id tokens.
/// 
public class TokenRevocationRequestValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the token type hint.
    /// 
    /// 
    /// The token type hint.
    /// 
    public string TokenTypeHint { get; set; }
    
    /// 
    /// Gets or sets the token.
    /// 
    /// 
    /// The token.
    /// 
    public string Token { get; set; }

    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/TokenValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models the validation result of access tokens and id tokens.
/// 
public class TokenValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the claims.
    /// 
    /// 
    /// The claims.
    /// 
    public IEnumerable Claims { get; set; }
    
    /// 
    /// Gets or sets the JWT.
    /// 
    /// 
    /// The JWT.
    /// 
    public string Jwt { get; set; }

    /// 
    /// Gets or sets the reference token (in case of access token validation).
    /// 
    /// 
    /// The reference token.
    /// 
    public Token ReferenceToken { get; set; }

    /// 
    /// Gets or sets the reference token identifier (in case of access token validation).
    /// 
    /// 
    /// The reference token identifier.
    /// 
    public string ReferenceTokenId { get; set; }

    /// 
    /// Gets or sets the refresh token (in case of refresh token validation).
    /// 
    /// 
    /// The reference token identifier.
    /// 
    public RefreshToken RefreshToken { get; set; }

    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/UserInfoRequestValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Validation result for userinfo requests
/// 
public class UserInfoRequestValidationResult : ValidationResult
{
    /// 
    /// Gets or sets the token validation result.
    /// 
    /// 
    /// The token validation result.
    /// 
    public TokenValidationResult TokenValidationResult { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidatedAuthorizeRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models a validated request to the authorize endpoint.
/// 
public class ValidatedAuthorizeRequest : ValidatedRequest
{
    /// 
    /// Gets or sets the type of the response.
    /// 
    /// 
    /// The type of the response.
    /// 
    public string ResponseType { get; set; }

    /// 
    /// Gets or sets the response mode.
    /// 
    /// 
    /// The response mode.
    /// 
    public string ResponseMode { get; set; }

    /// 
    /// Gets or sets the grant type.
    /// 
    /// 
    /// The grant type.
    /// 
    public string GrantType { get; set; }

    /// 
    /// Gets or sets the redirect URI.
    /// 
    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }

    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The requested scopes.
    /// 
    // todo: consider replacing with extension method to access Raw collection; would neeed to be done wholesale for all props.
    public List RequestedScopes { get; set; }

    /// 
    /// Gets or sets a value indicating whether consent was shown.
    /// 
    /// 
    ///   true if consent was shown; otherwise, false.
    /// 
    public bool WasConsentShown { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets the state.
    /// 
    /// 
    /// The state.
    /// 
    public string State { get; set; }

    /// 
    /// Gets or sets the UI locales.
    /// 
    /// 
    /// The UI locales.
    /// 
    public string UiLocales { get; set; }

    /// 
    /// Gets or sets a value indicating whether the request was an OpenID Connect request.
    /// 
    /// 
    /// true if the request was an OpenID Connect request; otherwise, false.
    /// 
    public bool IsOpenIdRequest { get; set; }

    /// 
    /// Gets or sets a value indicating whether this instance is API resource request.
    /// 
    /// 
    /// true if this instance is API resource request; otherwise, false.
    /// 
    public bool IsApiResourceRequest { get; set; }

    /// 
    /// Gets or sets the nonce.
    /// 
    /// 
    /// The nonce.
    /// 
    public string Nonce { get; set; }

    /// 
    /// Gets or sets the authentication context reference classes.
    /// 
    /// 
    /// The authentication context reference classes.
    /// 
    public List AuthenticationContextReferenceClasses { get; set; }

    /// 
    /// Gets or sets the display mode.
    /// 
    /// 
    /// The display mode.
    /// 
    public string DisplayMode { get; set; }

    /// 
    /// Gets or sets the collection of prompt modes.
    /// 
    /// 
    /// The collection of prompt modes.
    /// 
    public IEnumerable PromptModes { get; set; } = Enumerable.Empty();

    /// 
    /// Gets or sets the maximum age.
    /// 
    /// 
    /// The maximum age.
    /// 
    public int? MaxAge { get; set; }

    /// 
    /// Gets or sets the login hint.
    /// 
    /// 
    /// The login hint.
    /// 
    public string LoginHint { get; set; }

    /// 
    /// Gets or sets the code challenge
    /// 
    /// 
    /// The code challenge
    /// 
    public string CodeChallenge { get; set; }

    /// 
    /// Gets or sets the code challenge method
    /// 
    /// 
    /// The code challenge method
    /// 
    public string CodeChallengeMethod { get; set; }

    /// 
    /// Gets or sets the validated contents of the request object (if present)
    /// 
    /// 
    /// The request object values
    /// 
    public Dictionary RequestObjectValues { get; set; } = new Dictionary();

    /// 
    /// Gets or sets the request object (either passed by value or retrieved by reference)
    /// 
    /// 
    /// The request object
    /// 
    public string RequestObject { get; set; }
    
    /// 
    /// Gets a value indicating whether an access token was requested.
    /// 
    /// 
    /// true if an access token was requested; otherwise, false.
    /// 
    public bool AccessTokenRequested => ResponseType == OidcConstants.ResponseTypes.IdTokenToken ||
                                        ResponseType == OidcConstants.ResponseTypes.Code ||
                                        ResponseType == OidcConstants.ResponseTypes.CodeIdToken ||
                                        ResponseType == OidcConstants.ResponseTypes.CodeToken ||
                                        ResponseType == OidcConstants.ResponseTypes.CodeIdTokenToken;



    /// 
    /// Initializes a new instance of the  class.
    /// 
    public ValidatedAuthorizeRequest()
    {
        RequestedScopes = new List();
        AuthenticationContextReferenceClasses = new List();
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidatedDeviceAuthorizationRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models a validated request to the device authorization endpoint.
/// 
public class ValidatedDeviceAuthorizationRequest : ValidatedRequest
{
    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable RequestedScopes { get; set; }

    /// 
    /// Gets or sets a value indicating whether this instance is open identifier request.
    /// 
    /// 
    ///   true if this instance is open identifier request; otherwise, false.
    /// 
    public bool IsOpenIdRequest { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidatedEndSessionRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Represents a validated end session (logout) request
/// 
public class ValidatedEndSessionRequest : ValidatedRequest
{
    /// 
    /// Gets a value indicating whether this instance is authenticated.
    /// 
    /// 
    /// true if this instance is authenticated; otherwise, false.
    /// 
    public bool IsAuthenticated => Client != null;

    /// 
    /// Gets or sets the post-logout URI.
    /// 
    /// 
    /// The post-logout URI.
    /// 
    public string PostLogOutUri { get; set; }
    
    /// 
    /// Gets or sets the state.
    /// 
    /// 
    /// The state.
    /// 
    public string State { get; set; }

    /// 
    ///  Ids of clients known to have an authentication session for user at end session time
    /// 
    public IEnumerable ClientIds { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidatedRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Base class for a validate authorize or token request
/// 
public class ValidatedRequest
{
    /// 
    /// Gets or sets the raw request data
    /// 
    /// 
    /// The raw.
    /// 
    public NameValueCollection Raw { get; set; }

    /// 
    /// Gets or sets the client.
    /// 
    /// 
    /// The client.
    /// 
    public Client Client { get; set; }

    /// 
    /// Gets or sets the secret used to authenticate the client.
    /// 
    /// 
    /// The parsed secret.
    /// 
    public ParsedSecret Secret { get; set; }

    /// 
    /// Gets or sets the effective access token lifetime for the current request.
    /// This value is initally read from the client configuration but can be modified in the request pipeline
    /// 
    public int AccessTokenLifetime { get; set; }

    /// 
    /// Gets or sets the client claims for the current request.
    /// This value is initally read from the client configuration but can be modified in the request pipeline
    /// 
    public ICollection ClientClaims { get; set; } = new HashSet(new ClaimComparer());

    /// 
    /// Gets or sets the effective access token type for the current request.
    /// This value is initally read from the client configuration but can be modified in the request pipeline
    /// 
    public AccessTokenType AccessTokenType { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId { get; set; }
    
    /// 
    /// Gets or sets the identity server options.
    /// 
    /// 
    /// The options.
    /// 
    public IdentityServerOptions Options { get; set; }

    /// 
    /// Gets or sets the validated resources for the request.
    /// 
    /// 
    /// The validated resources.
    /// 
    public ResourceValidationResult ValidatedResources { get; set; } = new ResourceValidationResult();

    /// 
    /// Gets or sets the value of the confirmation method (will become the cnf claim). Must be a JSON object.
    /// 
    /// 
    /// The confirmation.
    /// 
    public string Confirmation { get; set; }

    /// 
    /// Gets or sets the client ID that should be used for the current request (this is useful for token exchange scenarios)
    /// 
    /// 
    /// The client ID
    /// 
    public string ClientId { get; set; }

    /// 
    /// Sets the client and the appropriate request specific settings.
    /// 
    /// The client.
    /// The client secret (optional).
    /// The confirmation.
    /// client
    public void SetClient(Client client, ParsedSecret secret = null, string confirmation = "")
    {
        Client = client ?? throw new ArgumentNullException(nameof(client));
        Secret = secret;
        Confirmation = confirmation;
        ClientId = client.ClientId;

        AccessTokenLifetime = client.AccessTokenLifetime;
        AccessTokenType = client.AccessTokenType;
        ClientClaims = client.Claims.Select(c => new Claim(c.Type, c.Value, c.ValueType)).ToList();
    }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidatedTokenRequest.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Models a validated request to the token endpoint.
/// 
public class ValidatedTokenRequest : ValidatedRequest
{
    /// 
    /// Gets or sets the type of the grant.
    /// 
    /// 
    /// The type of the grant.
    /// 
    public string GrantType { get; set; }
    
    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable RequestedScopes { get; set; }

    /// 
    /// Gets or sets the username used in the request.
    /// 
    /// 
    /// The name of the user.
    /// 
    public string UserName { get; set; }
    
    /// 
    /// Gets or sets the refresh token.
    /// 
    /// 
    /// The refresh token.
    /// 
    public RefreshToken RefreshToken { get; set; }
    
    /// 
    /// Gets or sets the refresh token handle.
    /// 
    /// 
    /// The refresh token handle.
    /// 
    public string RefreshTokenHandle { get; set; }

    /// 
    /// Gets or sets the authorization code.
    /// 
    /// 
    /// The authorization code.
    /// 
    public AuthorizationCode AuthorizationCode { get; set; }

    /// 
    /// Gets or sets the authorization code handle.
    /// 
    /// 
    /// The authorization code handle.
    /// 
    public string AuthorizationCodeHandle { get; set; }

    /// 
    /// Gets or sets the code verifier.
    /// 
    /// 
    /// The code verifier.
    /// 
    public string CodeVerifier { get; set; }

    /// 
    /// Gets or sets the device code.
    /// 
    /// 
    /// The device code.
    /// 
    public DeviceCode DeviceCode { get; set; }
}


================================================
FILE: src/IdentityServer8/src/Validation/Models/ValidationResult.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Validation;

/// 
/// Minimal validation result class (base-class for more complext validation results)
/// 
public class ValidationResult
{
    /// 
    /// Gets or sets a value indicating whether the validation was successful.
    /// 
    /// 
    ///   true if the validation is failed; otherwise, false.
    /// 
    public bool IsError { get; set; } = true;

    /// 
    /// Gets or sets the error.
    /// 
    /// 
    /// The error.
    /// 
    public string Error { get; set; }

    /// 
    /// Gets or sets the error description.
    /// 
    /// 
    /// The error description.
    /// 
    public string ErrorDescription { get; set; }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/ClientAssertionClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using IdentityServer.IntegrationTests.Common;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Microsoft.IdentityModel.Tokens;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Text;
using System.Text.Json;
using Xunit;


namespace IdentityServer.IntegrationTests.Clients;

public class ClientAssertionClient
{
    private const string TokenEndpoint = "https://idsvr8/connect/token";
    private const string ClientId = "certificate_base64_valid";

    private readonly HttpClient _client;

    public ClientAssertionClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Valid_client_with_manual_payload_should_succeed()
    {
        var token = CreateToken(ClientId);
        var requestBody = new FormUrlEncodedContent(new Dictionary
            {
                { "client_id", ClientId },
                { "client_assertion_type", "urn:ietf:params:oauth:client-assertion-type:jwt-bearer" },
                { "client_assertion", token },
                { "grant_type", "client_credentials" },
                { "scope", "api1" }
            });

        var response = await GetToken(requestBody);

        AssertValidToken(response);
    }

    [Fact]
    public async Task Valid_client_should_succeed()
    {
        var token = CreateToken(ClientId);

        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientCredentialStyle = ClientCredentialStyle.PostBody,
            GrantType = "client_credentials",
            ClientId = ClientId,
            ClientAssertion =
            {
                Type = OidcConstants.ClientAssertionTypes.JwtBearer,
                Value = token
            },

            Scope = "api1"
        });

        AssertValidToken(response);
    }

    [Fact]
    public async Task Valid_client_with_implicit_clientId_should_succeed()
    {
        var token = CreateToken(ClientId);

        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientCredentialStyle = ClientCredentialStyle.PostBody,
            GrantType = "client_credentials",
            ClientAssertion =
            {
                Type = OidcConstants.ClientAssertionTypes.JwtBearer,
                Value = token
            },

            Scope = "api1"
        });

        AssertValidToken(response);
    }

    [Fact]
    public async Task Valid_client_with_token_replay_should_fail()
    {
        var token = CreateToken(ClientId);

        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientCredentialStyle = ClientCredentialStyle.PostBody,
            GrantType = "client_credentials",
            ClientId = ClientId,
            ClientAssertion =
            {
                Type = OidcConstants.ClientAssertionTypes.JwtBearer,
                Value = token
            },

            Scope = "api1"
        });

        AssertValidToken(response);

        // replay
        response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientCredentialStyle = ClientCredentialStyle.PostBody,
            GrantType = "client_credentials",
            ClientId = ClientId,
            ClientAssertion =
            {
                Type = OidcConstants.ClientAssertionTypes.JwtBearer,
                Value = token
            },

            Scope = "api1"
        });

        response.IsError.Should().BeTrue();
        response.Error.Should().Be("invalid_client");
    }

    [Fact]
    public async Task Client_with_invalid_secret_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "client_credentials",
            ClientCredentialStyle = ClientCredentialStyle.PostBody,
            ClientId = ClientId,

            ClientAssertion =
            {
                Type = OidcConstants.ClientAssertionTypes.JwtBearer,
                Value = "invalid"
            },

            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.Error.Should().Be(OidcConstants.TokenErrors.InvalidClient);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
    }

    [Fact]
    public async Task Invalid_client_should_fail()
    {
        const string clientId = "certificate_base64_invalid";
        var token = CreateToken(clientId);

        var tokenRequest = new ClientCredentialsTokenRequest();
        tokenRequest.Address = TokenEndpoint;
        tokenRequest.ClientId = clientId;
        tokenRequest.GrantType = "client_credentials";
        tokenRequest.ClientAssertion.Type = OidcConstants.ClientAssertionTypes.JwtBearer;
        tokenRequest.ClientAssertion.Value = token;
        tokenRequest.Scope = "api1";
        tokenRequest.ClientCredentialStyle = ClientCredentialStyle.PostBody;
        var response = await _client.RequestTokenAsync(tokenRequest);


        response.IsError.Should().Be(true);
        response.Error.Should().Be(OidcConstants.TokenErrors.InvalidClient);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
    }

    private async Task GetToken(FormUrlEncodedContent body)
    {
        var response = await _client.PostAsync(TokenEndpoint, body);
        return await ProtocolResponse.FromHttpResponseAsync(response);
    }

    private void AssertValidToken(TokenResponse response)
    {
        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);

        payload.Keys.Should().Contain("iss");
        payload.Keys.Should().Contain("client_id");

        payload["iss"].ValueKind.Should().Be(JsonValueKind.String);
        payload["client_id"].ValueKind.Should().Be(JsonValueKind.String);
        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be(ClientId);



        payload["scope"].ValueKind.Should().Be(JsonValueKind.Array);


        var scopes = payload["scope"].EnumerateArray();
        scopes.First().ToString().Should().Be("api1");

        payload["aud"].ToString().Should().Be("api");
    }

    private Dictionary GetPayload(TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonSerializer.Deserialize>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }

    private string CreateToken(string clientId, DateTime? nowOverride = null)
    {
        var certificate = TestCert.Load();
        var now = nowOverride ?? DateTime.UtcNow;

        var token = new JwtSecurityToken(
                clientId,
                TokenEndpoint,
                new List()
                {
                    new Claim("jti", Guid.NewGuid().ToString()),
                    new Claim(JwtClaimTypes.Subject, clientId),
                    new Claim(JwtClaimTypes.IssuedAt, new DateTimeOffset(now).ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64)
                },
                now,
                now.AddMinutes(1),
                new SigningCredentials(
                    new X509SecurityKey(certificate),
                    SecurityAlgorithms.RsaSha256
                )
            );

        var tokenHandler = new JwtSecurityTokenHandler();
        return tokenHandler.WriteToken(token);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/ClientCredentialsAndResourceOwnerClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class ClientCredentialsandResourceOwnerClient
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public ClientCredentialsandResourceOwnerClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Resource_scope_should_be_requestable_via_client_credentials()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.and.ro",
            ClientSecret = "secret",
            Scope = "api1"
        });

        response.IsError.Should().Be(false);
    }

    [Fact]
    public async Task Openid_scope_should_not_be_requestable_via_client_credentials()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.and.ro",
            ClientSecret = "secret",
            Scope = "openid api1"
        });

        response.IsError.Should().Be(true);
    }

    [Fact]
    public async Task Openid_scope_should_be_requestable_via_password()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.and.ro",
            ClientSecret = "secret",
            Scope = "openid",

            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
    }

    [Fact]
    public async Task Openid_and_resource_scope_should_be_requestable_via_password()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.and.ro",
            ClientSecret = "secret",
            Scope = "openid api1",

            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/ClientCredentialsClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using System.Net;
using System.Text;
using System.Text.Json;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class ClientCredentialsClient
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public ClientCredentialsClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Invalid_endpoint_should_return_404()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint + "invalid",
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Http);
        response.Error.Should().Be("Not Found");
        response.HttpStatusCode.Should().Be(HttpStatusCode.NotFound);
    }

    [Fact]
    public async Task Valid_request_single_audience_should_return_expected_payload()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);

        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client");

        payload["aud"].ToString().Should().Be("api");
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");
        
        payload["aud"].ToString().Should().Be("api");

        var scopes = payload["scope"].EnumerateArray().Select(x => x.GetString());
        scopes.First().ToString().Should().Be("api1");
    }

    [Fact]
    public async Task Valid_request_multiple_audiences_should_return_expected_payload()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1 other_api"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);

        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client");

     
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");

        var audiences = payload["aud"].EnumerateArray().Select(x => x.GetString());
        audiences.Count().Should().Be(2);
        audiences.Should().Contain("api");
        audiences.Should().Contain("other_api");

        var scopes = payload["scope"].EnumerateArray().Select(x => x.ToString());
        scopes.First().ToString().Should().Be("api1");
    }

    [Fact]
    public async Task Valid_request_with_confirmation_should_return_expected_payload()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.cnf",
            ClientSecret = "foo",
            Scope = "api1"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(9);


        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client.cnf");

        payload["aud"].ToString().Should().Be("api");


        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");



        var scopes = payload["scope"].EnumerateArray().Select(x => x.GetString());
        scopes.First().ToString().Should().Be("api1");

        payload["cnf"].ValueKind.Should().Be(JsonValueKind.Array);
        var cnfArray = payload["cnf"].EnumerateArray().ToList();
        cnfArray.Count.Should().Be(1);
        var elArray= cnfArray.First().EnumerateArray().ToList();
        elArray.Count.Should().Be(1);
        elArray.First().GetString().Should().Be("foo");

    }

    [Fact]
    public async Task Requesting_multiple_scopes_should_return_expected_payload()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1 api2"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);

        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client");

        payload["aud"].ToString().Should().Be("api");
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");
        


        var scopes = payload["scope"].EnumerateArray().Select(x => x.GetString());
        scopes.Count().Should().Be(2);
        scopes.First().ToString().Should().Be("api1");
        scopes.Skip(1).First().ToString().Should().Be("api2");
    }

    [Fact]
    public async Task Request_with_no_explicit_scopes_should_return_expected_payload()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);



        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client");



        var scopes = payload["scope"].EnumerateArray().Select(x => x.GetString());


        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");

        var audiences = payload["aud"].EnumerateArray().Select(x=> x.GetString());
        audiences.Count().Should().Be(2);
        audiences.Should().Contain("api");
        audiences.Should().Contain("other_api");


        scopes.Count().Should().Be(3);
        scopes.Should().Contain("api1");
        scopes.Should().Contain("api2");
        scopes.Should().Contain("other_api");
    }

    [Fact]
    public async Task Client_without_default_scopes_skipping_scope_parameter_should_return_error()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.no_default_scopes",
            ClientSecret = "secret"
        });

        response.IsError.Should().Be(true);
        response.ExpiresIn.Should().Be(0);
        response.TokenType.Should().BeNull();
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();
        response.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
    }

    [Fact]
    public async Task Request_posting_client_secret_in_body_should_succeed()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1",

            ClientCredentialStyle = ClientCredentialStyle.PostBody
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);


        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client");

        payload["aud"].ToString().Should().Be("api");

        var scopes = payload["scope"].EnumerateArray();
        scopes.First().ToString().Should().Be("api1");
    }


    [Fact]
    public async Task Request_For_client_with_no_secret_and_basic_authentication_should_succeed()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.no_secret",
            Scope = "api1"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);
        
        payload["iss"].ToString().Should().Be("https://idsvr8");
        payload["client_id"].ToString().Should().Be("client.no_secret");

        var scopes = payload["scope"].EnumerateArray();
        scopes.First().ToString().Should().Be("api1");
    }

    [Fact]
    public async Task Request_with_invalid_client_secret_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "invalid",
            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.Error.Should().Be("invalid_client");
    }

    [Fact]
    public async Task Unknown_client_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "invalid",
            ClientSecret = "secret",
            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_client");
    }

    [Fact]
    public async Task Implicit_client_should_not_use_client_credential_grant()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "implicit",
            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("unauthorized_client");
    }

    [Fact]
    public async Task Implicit_and_client_creds_client_should_not_use_client_credential_grant_without_secret()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "implicit_and_client_creds",
            ClientSecret = "invalid",
            Scope = "api1"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_client");
    }


    [Fact]
    public async Task Requesting_unknown_scope_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "unknown"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_scope");
    }

    [Fact]
    public async Task Client_explicitly_requesting_identity_scope_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client.identityscopes",
            ClientSecret = "secret",
            Scope = "openid api1"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_scope");
    }

    [Fact]
    public async Task Client_explicitly_requesting_offline_access_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1 offline_access"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_scope");
    }

    [Fact]
    public async Task Requesting_unauthorized_scope_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api3"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_scope");
    }

    [Fact]
    public async Task Requesting_authorized_and_unauthorized_scopes_should_fail()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1 api3"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_scope");
    }

    private Dictionary GetPayload(TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonSerializer.Deserialize>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/CustomTokenRequestValidatorClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using IdentityServer8.Extensions;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using System.Text.Json;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class CustomTokenRequestValidatorClient
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public CustomTokenRequestValidatorClient()
    {
        var val = new TestCustomTokenRequestValidator();
        Startup.CustomTokenRequestValidator = val;

        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Client_credentials_request_should_contain_custom_response()
    {
        var response = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,

            ClientId = "client",
            ClientSecret = "secret",
            Scope = "api1"
        });
        ValidateCustomFields(response);
    }

    [Fact]
    public async Task Resource_owner_credentials_request_should_contain_custom_response()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,

            ClientId = "roclient",
            ClientSecret = "secret",
            Scope = "api1",

            UserName = "bob",
            Password = "bob"
        });

        ValidateCustomFields(response);
    }

    [Fact]
    public async Task Refreshing_a_token_should_contain_custom_response()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,

            ClientId = "roclient",
            ClientSecret = "secret",
            Scope = "api1 offline_access",

            UserName = "bob",
            Password = "bob"
        });

        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        ValidateCustomFields(response);
    }

    [Fact]
    public async Task Extension_grant_request_should_contain_custom_response()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },
                { "custom_credential", "custom credential"}
            }
        });

        ValidateCustomFields(response);
    }

     private Dictionary GetFields(JsonElement json)
    {
        return json.ToObject>();
    }
    private void ValidateCustomFields(TokenResponse response)
    {
        var fields = GetFields(response.Json);
        fields["custom"].ToString().Should().Be("custom");

    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/CustomTokenResponseClients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using IdentityServer8.Extensions;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Text;
using System.Text.Json;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class CustomTokenResponseClients
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public CustomTokenResponseClients()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Resource_owner_success_should_return_custom_response()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            UserName = "bob",
            Password = "bob",
            Scope = "api1"
        });

        // raw fields
        var fields = GetFields(response);
        fields["string_value"].GetString().Should().Be("some_string");
        fields["int_value"].GetInt64().Should().Be(42);

        JsonElement temp;
        fields.TryGetValue("identity_token", out temp).Should().BeFalse();
        fields.TryGetValue("refresh_token", out temp).Should().BeFalse();
        fields.TryGetValue("error", out temp).Should().BeFalse();
        fields.TryGetValue("error_description", out temp).Should().BeFalse();
        fields.TryGetValue("token_type", out temp).Should().BeTrue();
        fields.TryGetValue("expires_in", out temp).Should().BeTrue();

        var responseObject = fields["dto"];
        responseObject.Should().NotBeNull();

        var responseDto = GetDto(responseObject);
        var dto = CustomResponseDto.Create;

        responseDto.string_value.Should().Be(dto.string_value);
        responseDto.int_value.Should().Be(dto.int_value);
        responseDto.nested.string_value.Should().Be(dto.nested.string_value);
        responseDto.nested.int_value.Should().Be(dto.nested.int_value);


        // token client response
        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();


        // token content
        var payload = GetPayload(response);
        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "roclient");
        payload.Should().Contain("sub", "bob");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("password");
    }

    [Fact]
    public async Task Resource_owner_failure_should_return_custom_error_response()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            UserName = "bob",
            Password = "invalid",
            Scope = "api1"
        });

        // raw fields
        var fields = GetFields(response);
        fields["string_value"].ToString().Should().Be("some_string");
        fields["int_value"].GetInt64().Should().Be(42);

        JsonElement temp;
        fields.TryGetValue("identity_token", out temp).Should().BeFalse();
        fields.TryGetValue("refresh_token", out temp).Should().BeFalse();
        fields.TryGetValue("error", out temp).Should().BeTrue();
        fields.TryGetValue("error_description", out temp).Should().BeTrue();
        fields.TryGetValue("token_type", out temp).Should().BeFalse();
        fields.TryGetValue("expires_in", out temp).Should().BeFalse();

        var responseObject = fields["dto"];
        responseObject.Should().NotBeNull();

        var responseDto = GetDto(responseObject);
        var dto = CustomResponseDto.Create;

        responseDto.string_value.Should().Be(dto.string_value);
        responseDto.int_value.Should().Be(dto.int_value);
        responseDto.nested.string_value.Should().Be(dto.nested.string_value);
        responseDto.nested.int_value.Should().Be(dto.nested.int_value);


        // token client response
        response.IsError.Should().Be(true);
        response.Error.Should().Be("invalid_grant");
        response.ErrorDescription.Should().Be("invalid_credential");
        response.ExpiresIn.Should().Be(0);
        response.TokenType.Should().BeNull();
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();
    }

    [Fact]
    public async Task Extension_grant_success_should_return_custom_response()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },
                { "outcome", "succeed"}
            }
        });


        // raw fields
        var fields = GetFields(response);
        fields["string_value"].ToString().Should().Be("some_string");
        fields["int_value"].GetInt64().Should().Be(42);

        JsonElement temp;
        fields.TryGetValue("identity_token", out temp).Should().BeFalse();
        fields.TryGetValue("refresh_token", out temp).Should().BeFalse();
        fields.TryGetValue("error", out temp).Should().BeFalse();
        fields.TryGetValue("error_description", out temp).Should().BeFalse();
        fields.TryGetValue("token_type", out temp).Should().BeTrue();
        fields.TryGetValue("expires_in", out temp).Should().BeTrue();

        var responseObject = fields["dto"];
        responseObject.Should().NotBeNull();

        var responseDto = GetDto(responseObject);
        var dto = CustomResponseDto.Create;

        responseDto.string_value.Should().Be(dto.string_value);
        responseDto.int_value.Should().Be(dto.int_value);
        responseDto.nested.string_value.Should().Be(dto.nested.string_value);
        responseDto.nested.int_value.Should().Be(dto.nested.int_value);


        // token client response
        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();


        // token content
        var payload = GetPayload(response);
        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");
        payload.Should().Contain("sub", "bob");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("custom");

    }

    [Fact]
    public async Task Extension_grant_failure_should_return_custom_error_response()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },
                { "outcome", "fail"}
            }
        });

        var s = response.Json.ToString();
        var fd = GetFieldsD(response);
        // raw fields
        var fields = GetFields(response);
        fields["string_value"].ToString().Should().Be("some_string");
        fields["int_value"].GetInt64().Should().Be(42);

        JsonElement temp;
        fields.TryGetValue("identity_token", out temp).Should().BeFalse();
        fields.TryGetValue("refresh_token", out temp).Should().BeFalse();
        fields.TryGetValue("error", out temp).Should().BeTrue();
        fields.TryGetValue("error_description", out temp).Should().BeTrue();
        fields.TryGetValue("token_type", out temp).Should().BeFalse();
        fields.TryGetValue("expires_in", out temp).Should().BeFalse();

        var responseObject = fields["dto"];
        responseObject.Should().NotBeNull();

        var responseDto = GetDto(responseObject);
        var dto = CustomResponseDto.Create;

        responseDto.string_value.Should().Be(dto.string_value);
        responseDto.int_value.Should().Be(dto.int_value);
        responseDto.nested.string_value.Should().Be(dto.nested.string_value);
        responseDto.nested.int_value.Should().Be(dto.nested.int_value);


        // token client response
        response.IsError.Should().Be(true);
        response.Error.Should().Be("invalid_grant");
        response.ErrorDescription.Should().Be("invalid_credential");
        response.ExpiresIn.Should().Be(0);
        response.TokenType.Should().BeNull();
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();
    }

    private CustomResponseDto GetDto(JsonElement responseObject)
    {
        return responseObject.ToObject();
    }

    private Dictionary GetFieldsD(TokenResponse response)
    {
        return response.Json.ToObject>();
    }


    private Dictionary GetFields(TokenResponse response)
    {
        return GetFields(response.Json);
    }

    private Dictionary GetFields(JsonElement json)
    {
        return json.ToObject>();
    }

    private Dictionary GetPayload(TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonConvert.DeserializeObject>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/DiscoveryClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class DiscoveryClientTests
{
    private const string DiscoveryEndpoint = "https://server/.well-known/openid-configuration";

    private readonly HttpClient _client;

    public DiscoveryClientTests()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Discovery_document_should_have_expected_values()
    {
        var doc = await _client.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
        {
            Address = DiscoveryEndpoint,
            Policy =
            {
                ValidateIssuerName = false
            }
        });

        // endpoints
        doc.TokenEndpoint.Should().Be("https://server/connect/token");
        doc.AuthorizeEndpoint.Should().Be("https://server/connect/authorize");
        doc.IntrospectionEndpoint.Should().Be("https://server/connect/introspect");
        doc.EndSessionEndpoint.Should().Be("https://server/connect/endsession");

        // jwk
        doc.KeySet.Keys.Count.Should().Be(1);
        doc.KeySet.Keys.First().E.Should().NotBeNull();
        doc.KeySet.Keys.First().N.Should().NotBeNull();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/ExtensionGrantClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.IdentityModel.Tokens.Jwt;
using System.Net;
using System.Text;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class ExtensionGrantClient
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public ExtensionGrantClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Valid_client_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "scope", "api1" }
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        var unixNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var exp = Int64.Parse(payload["exp"].ToString());
        exp.Should().BeLessThan(unixNow + 3605);
        exp.Should().BeGreaterThan(unixNow + 3595);

        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("custom");
    }

    [Fact]
    public async Task Valid_client_with_extra_claim_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "extra_claim", "extra_value" },
                { "scope", "api1" }
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        var unixNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var exp = Int64.Parse(payload["exp"].ToString());
        exp.Should().BeLessThan(unixNow + 3605);
        exp.Should().BeGreaterThan(unixNow + 3595);

        payload.Count().Should().Be(13);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");
        payload.Should().Contain("extra_claim", "extra_value");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("custom");
    }

    [Fact]
    public async Task Valid_client_with_refreshed_extra_claim_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "extra_claim", "extra_value" },
                { "scope", "api1 offline_access" }
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var refreshResponse = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            
            ClientId = "client.custom",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        refreshResponse.IsError.Should().BeFalse();
        refreshResponse.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        refreshResponse.ExpiresIn.Should().Be(3600);
        refreshResponse.TokenType.Should().Be("Bearer");
        refreshResponse.IdentityToken.Should().BeNull();
        refreshResponse.RefreshToken.Should().NotBeNull();

        var payload = GetPayload(refreshResponse);

        var unixNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var exp = Int64.Parse(payload["exp"].ToString());
        exp.Should().BeLessThan(unixNow + 3605);
        exp.Should().BeGreaterThan(unixNow + 3595);

        payload.Count().Should().Be(13);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");
        payload.Should().Contain("extra_claim", "extra_value");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("custom");
    }

    [Fact]
    public async Task Valid_client_no_subject_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom.nosubject",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "scope", "api1" }
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(8);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");
    }

    [Fact]
    public async Task Valid_client_with_default_scopes_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.custom");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("custom");

        var scopes = payload["scope"] as JArray;
        scopes.Count().Should().Be(3);
        scopes.First().ToString().Should().Be("api1");
        scopes.Skip(1).First().ToString().Should().Be("api2");
        scopes.Skip(2).First().ToString().Should().Be("offline_access");
    }

    [Fact]
    public async Task Valid_client_missing_grant_specific_data_should_fail()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" }
            }
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        response.ErrorDescription.Should().Be("invalid_custom_credential");
    }

    [Fact]
    public async Task Valid_client_using_unsupported_grant_type_should_fail()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "invalid",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "scope", "api1" }
            }
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("unsupported_grant_type");
    }

    [Fact]
    public async Task Valid_client_using_unauthorized_grant_type_should_fail()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "custom2",

            ClientId = "client.custom",
            ClientSecret = "secret",

            Parameters =
            {
                { "custom_credential", "custom credential"},
                { "scope", "api1" }
            }
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("unsupported_grant_type");
    }

    [Fact(Skip = "needs improvement")]
    public async Task Dynamic_lifetime_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "lifetime", "5000"},
                { "sub",  "818727"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(5000);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        var unixNow = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var exp = Int64.Parse(payload["exp"].ToString());
        exp.Should().BeLessThan(unixNow + 5005);
        exp.Should().BeGreaterThan(unixNow + 4995);

        payload.Count().Should().Be(10);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.dynamic");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("delegation");
    }

    [Fact]
    public async Task Dynamic_token_type_jwt_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "type", "jwt"},
                { "sub",  "818727"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        response.AccessToken.Should().Contain(".");
    }

    [Fact]
    public async Task Impersonate_client_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "type", "jwt"},
                { "impersonated_client", "impersonated_client_id"},
                { "sub",  "818727"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        response.AccessToken.Should().Contain(".");

        var jwt = new JwtSecurityToken(response.AccessToken);
        jwt.Payload["client_id"].Should().Be("impersonated_client_id");
    }

    [Fact]
    public async Task Dynamic_token_type_reference_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "type", "reference"},
                { "sub",  "818727"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        response.AccessToken.Should().NotContain(".");
    }

    [Fact]
    public async Task Dynamic_client_claims_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "claim", "extra_claim"},
                { "sub",  "818727"}
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(13);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.dynamic");
        payload.Should().Contain("sub", "818727");
        payload.Should().Contain("idp", "local");

        payload.Should().Contain("client_extra", "extra_claim");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("delegation");
    }

    [Fact]
    public async Task Dynamic_client_claims_no_sub_should_succeed()
    {
        var response = await _client.RequestTokenAsync(new TokenRequest
        {
            Address = TokenEndpoint,
            GrantType = "dynamic",

            ClientId = "client.dynamic",
            ClientSecret = "secret",

            Parameters =
            {
                { "scope", "api1" },

                { "claim", "extra_claim"},
            }
        });

        response.IsError.Should().BeFalse();
        response.HttpStatusCode.Should().Be(HttpStatusCode.OK);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(9);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "client.dynamic");
        payload.Should().Contain("client_extra", "extra_claim");

        payload["aud"].Should().Be("api");

        var scopes = payload["scope"] as JArray;
        scopes.First().ToString().Should().Be("api1");
    }

    private Dictionary GetPayload(TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonConvert.DeserializeObject>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/RefreshTokenClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class RefreshTokenClient
{
    private const string TokenEndpoint = "https://server/connect/token";
    private const string RevocationEndpoint = "https://server/connect/revocation";

    private readonly HttpClient _client;

    public RefreshTokenClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Requesting_a_refresh_token_without_identity_scopes_should_return_expected_results()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();
    }

    [Fact]
    public async Task Requesting_a_refresh_token_with_identity_scopes_should_return_expected_results()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().NotBeNull();
        response.RefreshToken.Should().NotBeNull();
    }

    [Fact]
    public async Task Refreshing_a_refresh_token_with_reuse_should_return_same_refresh_token()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient.reuse",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt1 = response.RefreshToken;

        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient.reuse",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().NotBeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt2 = response.RefreshToken;

        rt1.Should().BeEquivalentTo(rt2);
    }
    
    [Fact]
    public async Task Refreshing_a_refresh_token_with_one_time_only_should_return_different_refresh_token()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt1 = response.RefreshToken;

        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().NotBeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt2 = response.RefreshToken;

        rt1.Should().NotBeEquivalentTo(rt2);
    }
    
    [Fact]
    public async Task Replaying_a_rotated_token_should_fail()
    {
        // request initial token
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt1 = response.RefreshToken;

        // refresh token
        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = response.RefreshToken
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().NotBeNull();
        response.RefreshToken.Should().NotBeNull();
        
        // refresh token (again)
        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = rt1
        });

        response.IsError.Should().BeTrue();
        response.Error.Should().Be("invalid_grant");
    }
    
    [Fact]
    public async Task Using_a_valid_refresh_token_should_succeed()
    {
        // request initial token
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt1 = response.RefreshToken;

        // refresh token
        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = rt1
        });

        response.IsError.Should().BeFalse();
    }
    
    [Fact]
    public async Task Using_a_revoked_refresh_token_should_fail()
    {
        // request initial token
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var rt1 = response.RefreshToken;

        // revoke refresh token
        var revocationResponse = await _client.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = RevocationEndpoint,

            ClientId = "roclient",
            ClientSecret = "secret",

            Token = rt1,
            TokenTypeHint = "refresh_token"
        });

        revocationResponse.IsError.Should().Be(false);
        
        // refresh token
        response = await _client.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            RefreshToken = rt1
        });

        response.IsError.Should().BeTrue();
        response.Error.Should().Be("invalid_grant");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/ResourceOwnerClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Net;
using System.Text;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class ResourceOwnerClient
{
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;

    public ResourceOwnerClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Valid_user_should_succeed_with_expected_response_payload()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "roclient");
        payload.Should().Contain("sub", "88421113");
        payload.Should().Contain("idp", "local");
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");
        
        payload["aud"].Should().Be("api");

        var scopes = ((JArray)payload["scope"]).Select(x => x.ToString());
        scopes.Count().Should().Be(1);
        scopes.Should().Contain("api1");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("pwd");
    }

    [Fact]
    public async Task Request_with_no_explicit_scopes_should_return_allowed_scopes()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNull();

        var payload = GetPayload(response);
        
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "roclient");
        payload.Should().Contain("sub", "88421113");
        payload.Should().Contain("idp", "local");

        payload["aud"].Should().Be("api");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("pwd");

        var scopes = ((JArray)payload["scope"]).Select(x => x.ToString());
        scopes.Count().Should().Be(8);

        // {[  "address",  "api1",  "api2", "api4.with.roles", "email",  "offline_access",  "openid", "role"]}

        scopes.Should().Contain("address");
        scopes.Should().Contain("api1");
        scopes.Should().Contain("api2");
        scopes.Should().Contain("api4.with.roles");
        scopes.Should().Contain("email");
        scopes.Should().Contain("offline_access");
        scopes.Should().Contain("openid");
        scopes.Should().Contain("roles");
    }

    [Fact]
    public async Task Request_containing_identity_scopes_should_return_expected_payload()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid email api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().BeNull();

        var payload = GetPayload(response);

        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "roclient");
        payload.Should().Contain("sub", "88421113");
        payload.Should().Contain("idp", "local");
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");

        payload["aud"].Should().Be("api");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("pwd");

        var scopes = ((JArray)payload["scope"]).Select(x=>x.ToString());
        scopes.Count().Should().Be(3);
        scopes.Should().Contain("api1");
        scopes.Should().Contain("email");
        scopes.Should().Contain("openid");
    }

    [Fact]
    public async Task Request_for_refresh_token_should_return_expected_payload()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid email api1 offline_access",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().Be(false);
        response.ExpiresIn.Should().Be(3600);
        response.TokenType.Should().Be("Bearer");
        response.IdentityToken.Should().BeNull();
        response.RefreshToken.Should().NotBeNullOrWhiteSpace();

        var payload = GetPayload(response);

        payload.Count().Should().Be(12);
        payload.Should().Contain("iss", "https://idsvr8");
        payload.Should().Contain("client_id", "roclient");
        payload.Should().Contain("sub", "88421113");
        payload.Should().Contain("idp", "local");
        payload.Keys.Should().Contain("jti");
        payload.Keys.Should().Contain("iat");

        payload["aud"].Should().Be("api");

        var amr = payload["amr"] as JArray;
        amr.Count().Should().Be(1);
        amr.First().ToString().Should().Be("pwd");

        var scopes = ((JArray)payload["scope"]).Select(x => x.ToString());
        scopes.Count().Should().Be(4);
        scopes.Should().Contain("api1");
        scopes.Should().Contain("email");
        scopes.Should().Contain("offline_access");
        scopes.Should().Contain("openid");
    }

    [Fact]
    public async Task Unknown_user_should_fail()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "unknown",
            Password = "bob"
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_grant");
    }
    
    [Fact]
    public async Task User_with_empty_password_should_succeed()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "bob_no_password"
        });

        response.IsError.Should().Be(false);
    }

    [Theory]
    [InlineData("invalid")]
    [InlineData("")]
    public async Task User_with_invalid_password_should_fail(string password)
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "bob",
            Password = password
        });

        response.IsError.Should().Be(true);
        response.ErrorType.Should().Be(ResponseErrorType.Protocol);
        response.HttpStatusCode.Should().Be(HttpStatusCode.BadRequest);
        response.Error.Should().Be("invalid_grant");
    }


    private static Dictionary GetPayload(IdentityModel.Client.TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonConvert.DeserializeObject>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/RevocationClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Net.Http;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class RevocationClient
{
    private const string TokenEndpoint = "https://server/connect/token";
    private const string RevocationEndpoint = "https://server/connect/revocation";
    private const string IntrospectionEndpoint = "https://server/connect/introspect";

    private readonly HttpClient _client;

    public RevocationClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Revoking_reference_token_should_invalidate_token()
    {
        // request acccess token
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient.reference",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        // introspect - should be active
        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api",
            ClientSecret = "secret",

            Token = response.AccessToken
        });

        introspectionResponse.IsActive.Should().Be(true);

        // revoke access token
        var revocationResponse = await _client.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = RevocationEndpoint,
            ClientId = "roclient.reference",
            ClientSecret = "secret",

            Token = response.AccessToken
        });

        // introspect - should be inactive
        introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api",
            ClientSecret = "secret",

            Token = response.AccessToken
        });

        introspectionResponse.IsActive.Should().Be(false);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/Clients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Cryptography.X509Certificates;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Models;

namespace IdentityServer.IntegrationTests.Clients.Setup;

internal class Clients
{
    public static IEnumerable Get()
    {
        return new List
        {
            ///////////////////////////////////////////
            // Console Client Credentials Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "client",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowOfflineAccess = true,

                AllowedScopes =
                {
                    "api1", "api2", "other_api"
                }
            },
            new Client
            {
                ClientId = "client.cnf",
                ClientSecrets =
                {
                    new Secret
                    {
                        Type = "confirmation.test",
                        Description = "Test for cnf claim",
                        Value = "foo"
                    }
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowOfflineAccess = true,

                AllowedScopes =
                {
                    "api1", "api2"
                }
            },
            new Client
            {
                ClientId = "client.and.ro",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ResourceOwnerPasswordAndClientCredentials,

                AllowedScopes =
                {
                    "openid",
                    "api1", "api2"
                }
            },
            new Client
            {
                ClientId = "client.identityscopes",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,

                AllowedScopes =
                {
                    "openid", "profile",
                    "api1", "api2"
                }
            },
            new Client
            {
                ClientId = "client.no_default_scopes",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials
            },
            new Client
            {
                ClientId = "client.no_secret",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                RequireClientSecret = false,
                AllowedScopes = { "api1" }
            },

            ///////////////////////////////////////////
            // Console Resource Owner Flow Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                RefreshTokenUsage = TokenUsage.OneTimeOnly,

                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Email,
                    IdentityServerConstants.StandardScopes.Address,
                    "roles",
                    "api1", "api2", "api4.with.roles"
                }
            },
            new Client
            {
                ClientId = "roclient.reuse",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,

                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    IdentityServerConstants.StandardScopes.OpenId,
                    IdentityServerConstants.StandardScopes.Email,
                    IdentityServerConstants.StandardScopes.Address,
                    "roles",
                    "api1", "api2", "api4.with.roles"
                },

                RefreshTokenUsage = TokenUsage.ReUse
            },

            /////////////////////////////////////////
            // Console Custom Grant Flow Sample
            ////////////////////////////////////////
            new Client
            {
                ClientId = "client.custom",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = { "custom", "custom.nosubject" },

                AllowedScopes =
                {
                    "api1", "api2"
                },

                AllowOfflineAccess = true
            },
            new Client
            {
                ClientId = "client.dynamic",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = { "dynamic" },

                AllowedScopes =
                {
                    "api1", "api2"
                },

                AlwaysSendClientClaims = true
            },

            ///////////////////////////////////////////
            // Introspection Client Sample
            //////////////////////////////////////////
            new Client
            {
                ClientId = "roclient.reference",
                ClientSecrets =
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,

                AllowOfflineAccess = true,
                AllowedScopes =
                {
                    "api1", "api2"
                },

                AccessTokenType = AccessTokenType.Reference
            },

            new Client
            {
                ClientName = "Client with Base64 encoded X509 Certificate",
                ClientId = "certificate_base64_valid",
                Enabled = true,

                ClientSecrets =
                {
                    new Secret
                    {
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value = Convert.ToBase64String(TestCert.Load().Export(X509ContentType.Cert))
                    }
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,

                AllowedScopes = new List
                {
                    "api1", "api2"
                }
            },

            new Client
            {
                ClientId = "implicit",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = {"api1"},
                RedirectUris = { "http://implicit" }
            },
            new Client
            {
                ClientId = "implicit_and_client_creds",
                AllowedGrantTypes = GrantTypes.ImplicitAndClientCredentials,
                AllowedScopes = {"api1"},
                RedirectUris = { "http://implicit_and_client_creds" }
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/ConfirmationSecretValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Newtonsoft.Json;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class ConfirmationSecretValidator : ISecretValidator
{
    public Task ValidateAsync(IEnumerable secrets, ParsedSecret parsedSecret)
    {
        if (secrets.Any())
        {
            if (secrets.First().Type == "confirmation.test")
            {
                var cnf = new Dictionary
                {
                    { "x5t#S256", "foo" }
                };

                var result = new SecretValidationResult
                {
                    Success = true,
                    Confirmation = JsonConvert.SerializeObject(cnf)
                };

                return Task.FromResult(result);
            }
        }

        return Task.FromResult(new SecretValidationResult { Success = false });
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/CustomProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Microsoft.Extensions.Logging;

namespace IdentityServer.IntegrationTests.Clients.Setup;

class CustomProfileService : TestUserProfileService
{
    public CustomProfileService(TestUserStore users, ILogger logger) : base(users, logger)
    { }

    public override async Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        await base.GetProfileDataAsync(context);

        if (context.Subject.Identity.AuthenticationType == "custom")
        {
            var extraClaim = context.Subject.FindFirst("extra_claim");
            if (extraClaim != null)
            {
                context.IssuedClaims.Add(extraClaim);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/CustomResponseDto.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class CustomResponseDto
{
    public string string_value { get; set; }
    public int int_value { get; set; }

    public CustomResponseDto nested { get; set; }

    public static CustomResponseDto Create
    {
        get
        {
            return new CustomResponseDto
            {
                string_value = "dto_string",
                int_value = 43,
                nested = new CustomResponseDto
                {
                    string_value = "dto_nested_string",
                    int_value = 44
                }
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/CustomResponseExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class CustomResponseExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var response = new Dictionary
        {
            { "string_value", "some_string" },
            { "int_value", 42 },
            { "dto",  CustomResponseDto.Create }
        };

        var credential = context.Request.Raw.Get("outcome");

        if (credential == "succeed")
        {
            context.Result = new GrantValidationResult("bob", "custom", customResponse: response);
        }
        else
        {
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid_credential", response);
        }

        return Task.CompletedTask;
    }

    public string GrantType
    {
        get { return "custom"; }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/CustomResponseResourceOwnerValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class CustomResponseResourceOwnerValidator : IResourceOwnerPasswordValidator
{
    public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
    {
        var response = new Dictionary
        {
            { "string_value", "some_string" },
            { "int_value", 42 },
            { "dto",  CustomResponseDto.Create }
        };

        if (context.UserName == context.Password)
        {
            context.Result = new GrantValidationResult(context.UserName, "password", customResponse: response);
        }
        else
        {
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid_credential", response);
        }

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/DynamicParameterExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class DynamicParameterExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var impersonatedClient = context.Request.Raw.Get("impersonated_client");
        var lifetime = context.Request.Raw.Get("lifetime");
        var extraClaim = context.Request.Raw.Get("claim");
        var tokenType = context.Request.Raw.Get("type");
        var sub = context.Request.Raw.Get("sub");

        if (!string.IsNullOrEmpty(impersonatedClient))
        {
            context.Request.ClientId = impersonatedClient;
        }

        if (!string.IsNullOrEmpty(lifetime))
        {
            context.Request.AccessTokenLifetime = int.Parse(lifetime);
        }

        if (!string.IsNullOrEmpty(tokenType))
        {
            if (tokenType == "jwt")
            {
                context.Request.AccessTokenType = AccessTokenType.Jwt;
            }
            else if (tokenType == "reference")
            {
                context.Request.AccessTokenType = AccessTokenType.Reference;
            }
        }

        if (!string.IsNullOrEmpty(extraClaim))
        {
            context.Request.ClientClaims.Add(new Claim("extra", extraClaim));
        }

        if (!string.IsNullOrEmpty(sub))
        {
            context.Result = new GrantValidationResult(sub, "delegation");
        }
        else
        {
            context.Result = new GrantValidationResult();
        }

        return Task.CompletedTask;
    }

    public string GrantType => "dynamic";
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/ExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class ExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var credential = context.Request.Raw.Get("custom_credential");
        var extraClaim = context.Request.Raw.Get("extra_claim");

        if (credential != null)
        {
            if (extraClaim != null)
            {
                context.Result = new GrantValidationResult(
                    subject: "818727",
                    claims: new[] { new Claim("extra_claim", extraClaim) },
                    authenticationMethod: GrantType);
            }
            else
            {
                context.Result = new GrantValidationResult(subject: "818727", authenticationMethod: GrantType);
            }
        }
        else
        {
            // custom error message
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid_custom_credential");
        }

        return Task.CompletedTask;
    }

    public string GrantType =>  "custom";
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/ExtensionGrantValidator2.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class ExtensionGrantValidator2 : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var credential = context.Request.Raw.Get("custom_credential");

        if (credential != null)
        {
            // valid credential
            context.Result = new GrantValidationResult("818727", "custom");
        }
        else
        {
            // custom error message
            context.Result = new GrantValidationResult(IdentityServer8.Models.TokenRequestErrors.InvalidGrant, "invalid custom credential");
        }

        return Task.CompletedTask;
    }

    public string GrantType => "custom2";
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/NoSubjectExtensionGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class NoSubjectExtensionGrantValidator : IExtensionGrantValidator
{
    public Task ValidateAsync(ExtensionGrantValidationContext context)
    {
        var credential = context.Request.Raw.Get("custom_credential");

        if (credential != null)
        {
            context.Result = new GrantValidationResult();
        }
        else
        {
            // custom error message
            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid custom credential");
        }

        return Task.CompletedTask;
    }

    public string GrantType => "custom.nosubject";
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/Scopes.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8.Models;

namespace IdentityServer.IntegrationTests.Clients.Setup;

internal class Scopes
{
    public static IEnumerable GetIdentityScopes()
    {
        return new IdentityResource[]
        {
            new IdentityResources.OpenId(),
            new IdentityResources.Email(),
            new IdentityResources.Address(),
            new IdentityResource("roles", new[] { "role" })
        };
    }

    public static IEnumerable GetApiResources()
    {
        return new List
        {
            new ApiResource
            {
                Name = "api",
                ApiSecrets =
                {
                    new Secret("secret".Sha256())
                },
                Scopes = { "api1", "api2", "api3", "api4.with.roles" }
            },
            new ApiResource("other_api")
            {
                Scopes = { "other_api" }
            }
        };
    }

    public static IEnumerable GetApiScopes()
    {
        return new ApiScope[]
        {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            },
            new ApiScope
            {
                Name = "api3"
            },
            new ApiScope
            {
                Name = "api4.with.roles",
                UserClaims = { "role" }
            },
            new ApiScope
            {
                Name = "other_api",
            },
        };
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Configuration;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class Startup
{
    static public ICustomTokenRequestValidator CustomTokenRequestValidator { get; set; } 

    public void ConfigureServices(IServiceCollection services)
    {
        services.AddAuthentication();

        var builder = services.AddIdentityServer(options =>
        {
            options.IssuerUri = "https://idsvr8";

            options.Events = new EventsOptions
            {
                RaiseErrorEvents = true,
                RaiseFailureEvents = true,
                RaiseInformationEvents = true,
                RaiseSuccessEvents = true
            };
        });

        builder.AddInMemoryClients(Clients.Get());
        builder.AddInMemoryIdentityResources(Scopes.GetIdentityScopes());
        builder.AddInMemoryApiResources(Scopes.GetApiResources());
        builder.AddInMemoryApiScopes(Scopes.GetApiScopes());
        builder.AddTestUsers(Users.Get());

        builder.AddDeveloperSigningCredential(persistKey: false);

        builder.AddExtensionGrantValidator();
        builder.AddExtensionGrantValidator();
        builder.AddExtensionGrantValidator();
        builder.AddExtensionGrantValidator();

        builder.AddProfileService();

        builder.AddJwtBearerClientAuthentication();
        builder.AddSecretValidator();

        // add a custom token request validator if set
        if (CustomTokenRequestValidator != null)
        {
            builder.Services.AddTransient(r => CustomTokenRequestValidator);
        }
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseIdentityServer();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/StartupWithCustomTokenResponses.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Configuration;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class StartupWithCustomTokenResponses
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddAuthentication();

        var builder = services.AddIdentityServer(options =>
        {
            options.IssuerUri = "https://idsvr8";

            options.Events = new EventsOptions
            {
                RaiseErrorEvents = true,
                RaiseFailureEvents = true,
                RaiseInformationEvents = true,
                RaiseSuccessEvents = true
            };
        });

        builder.AddInMemoryClients(Clients.Get());
        builder.AddInMemoryIdentityResources(Scopes.GetIdentityScopes());
        builder.AddInMemoryApiResources(Scopes.GetApiResources());
        builder.AddInMemoryApiScopes(Scopes.GetApiScopes());

        builder.AddDeveloperSigningCredential(persistKey: false);

        services.AddTransient();
        builder.AddExtensionGrantValidator();
    }

    public void Configure(IApplicationBuilder app)
    {
        app.UseIdentityServer();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/TestCustomTokenRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer8.Validation;

namespace IdentityServer.IntegrationTests.Clients.Setup;

public class TestCustomTokenRequestValidator : ICustomTokenRequestValidator
{
    public Task ValidateAsync(CustomTokenRequestValidationContext context)
    {
        context.Result.CustomResponse = new Dictionary
        {
            {"custom", "custom" }
        };

        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/Setup/Users.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Security.Claims;
using IdentityModel;
using IdentityServer8;
using IdentityServer8.Test;

namespace IdentityServer.IntegrationTests.Clients.Setup;

internal static class Users
{
    public static List Get()
    {
        var users = new List
        {
            new TestUser{SubjectId = "818727", Username = "alice", Password = "alice", 
                Claims = new Claim[]
                {
                    new Claim(JwtClaimTypes.Name, "Alice Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Alice"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "AliceSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.Role, "Admin"),
                    new Claim(JwtClaimTypes.Role, "Geek"),
                    new Claim(JwtClaimTypes.WebSite, "http://alice.com"),
                    new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json)
                }
            },
            new TestUser{SubjectId = "88421113", Username = "bob", Password = "bob", 
                Claims = new Claim[]
                {
                    new Claim(JwtClaimTypes.Name, "Bob Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Bob"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.Role, "Developer"),
                    new Claim(JwtClaimTypes.Role, "Geek"),
                    new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                    new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json)
                }
            },
            new TestUser{SubjectId = "88421113", Username = "bob_no_password", 
                Claims = new Claim[]
                {
                    new Claim(JwtClaimTypes.Name, "Bob Smith"),
                    new Claim(JwtClaimTypes.GivenName, "Bob"),
                    new Claim(JwtClaimTypes.FamilyName, "Smith"),
                    new Claim(JwtClaimTypes.Email, "BobSmith@email.com"),
                    new Claim(JwtClaimTypes.EmailVerified, "true", ClaimValueTypes.Boolean),
                    new Claim(JwtClaimTypes.Role, "Developer"),
                    new Claim(JwtClaimTypes.Role, "Geek"),
                    new Claim(JwtClaimTypes.WebSite, "http://bob.com"),
                    new Claim(JwtClaimTypes.Address, @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json)
                }
            }
        };

        return users;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Clients/UserInfoClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Clients.Setup;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Xunit;

namespace IdentityServer.IntegrationTests.Clients;

public class UserInfoEndpointClient
{
    private const string TokenEndpoint = "https://server/connect/token";
    private const string UserInfoEndpoint = "https://server/connect/userinfo";

    private readonly HttpClient _client;

    public UserInfoEndpointClient()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _client = server.CreateClient();
    }

    [Fact]
    public async Task Valid_client_with_GET_should_succeed()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid email api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = response.AccessToken
        });

        userInfo.IsError.Should().BeFalse();
        userInfo.Claims.Count().Should().Be(3);

        userInfo.Claims.Should().Contain(c => c.Type == "sub" && c.Value == "88421113");
        userInfo.Claims.Should().Contain(c => c.Type == "email" && c.Value == "BobSmith@email.com");
        userInfo.Claims.Should().Contain(c => c.Type == "email_verified" && c.Value == "true");
    }

    [Fact]
    public async Task Request_address_scope_should_return_expected_response()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid address",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = response.AccessToken
        });

        userInfo.IsError.Should().BeFalse();
        userInfo.Claims.First().Value.Should().Be("{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }");
    }

    [Fact]
    public async Task Using_a_token_with_no_identity_scope_should_fail()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = response.AccessToken
        });

        userInfo.IsError.Should().BeTrue();
        userInfo.HttpStatusCode.Should().Be(HttpStatusCode.Forbidden);
    }

    [Fact]
    public async Task Using_a_token_with_an_identity_scope_but_no_openid_should_fail()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "email api1",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = response.AccessToken
        });

        userInfo.IsError.Should().BeTrue();
        userInfo.HttpStatusCode.Should().Be(HttpStatusCode.Forbidden);
    }

    [Fact]
    public async Task Invalid_token_should_fail()
    {
        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = "invalid"
        });

        userInfo.IsError.Should().BeTrue();
        userInfo.HttpStatusCode.Should().Be(HttpStatusCode.Unauthorized);
    }

    [Fact]
    public async Task Complex_json_should_be_correct()
    {
        var response = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "roclient",
            ClientSecret = "secret",

            Scope = "openid email api1 api4.with.roles roles",
            UserName = "bob",
            Password = "bob"
        });

        response.IsError.Should().BeFalse();

        var payload = GetPayload(response);

        var scopes = ((JArray) payload["scope"]).Select(x => x.ToString()).ToArray();
        scopes.Length.Should().Be(5);
        scopes.Should().Contain("openid");
        scopes.Should().Contain("email");
        scopes.Should().Contain("api1");
        scopes.Should().Contain("api4.with.roles");
        scopes.Should().Contain("roles");

        var roles = ((JArray) payload["role"]).Select(x => x.ToString()).ToArray();
        roles.Length.Should().Be(2);
        roles.Should().Contain("Geek");
        roles.Should().Contain("Developer");

        var userInfo = await _client.GetUserInfoAsync(new UserInfoRequest
        {
            Address = UserInfoEndpoint,
            Token = response.AccessToken
        });

        //roles = ((JArray)userInfo.Json["role"]).Select(x => x.ToString()).ToArray();
        roles = userInfo.Json.TryGetStringArray("role").ToArray();
        roles.Length.Should().Be(2);
        roles.Should().Contain("Geek");
        roles.Should().Contain("Developer");
    }

    private Dictionary GetPayload(TokenResponse response)
    {
        var token = response.AccessToken.Split('.').Skip(1).Take(1).First();
        var dictionary = JsonConvert.DeserializeObject>(
            Encoding.UTF8.GetString(Base64Url.Decode(token)));

        return dictionary;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/BrowserClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Net.Http;

namespace IdentityServer.IntegrationTests.Common;

public class BrowserClient : HttpClient
{
    public BrowserClient(BrowserHandler browserHandler)
        : base(browserHandler)
    {
        BrowserHandler = browserHandler;
    }

    public BrowserHandler BrowserHandler { get; private set; }

    public bool AllowCookies
    {
        get { return BrowserHandler.AllowCookies; }
        set { BrowserHandler.AllowCookies = value; }
    }
    public bool AllowAutoRedirect
    {
        get { return BrowserHandler.AllowAutoRedirect; }
        set { BrowserHandler.AllowAutoRedirect = value; }
    }
    public int ErrorRedirectLimit
    {
        get { return BrowserHandler.ErrorRedirectLimit; }
        set { BrowserHandler.ErrorRedirectLimit = value; }
    }
    public int StopRedirectingAfter
    {
        get { return BrowserHandler.StopRedirectingAfter; }
        set { BrowserHandler.StopRedirectingAfter = value; }
    }

    internal void RemoveCookie(string uri, string name)
    {
        BrowserHandler.RemoveCookie(uri, name);
    }

    internal System.Net.Cookie GetCookie(string uri, string name)
    {
        return BrowserHandler.GetCookie(uri, name);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/BrowserHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace IdentityServer.IntegrationTests.Common;

// thanks to Damian Hickey for this awesome sample
// https://github.com/damianh/OwinHttpMessageHandler/blob/master/src/OwinHttpMessageHandler/OwinHttpMessageHandler.cs
public class BrowserHandler : DelegatingHandler
{
    private CookieContainer _cookieContainer = new CookieContainer();

    public bool AllowCookies { get; set; } = true;
    public bool AllowAutoRedirect { get; set; } = true;
    public int ErrorRedirectLimit { get; set; } = 20;
    public int StopRedirectingAfter { get; set; } = Int32.MaxValue;

    public BrowserHandler(HttpMessageHandler next)
        : base(next)
    {
    }

    protected async override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var response = await SendCookiesAsync(request, cancellationToken);

        int redirectCount = 0;

        while (AllowAutoRedirect && 
            (300 <= (int)response.StatusCode && (int)response.StatusCode < 400) &&
            redirectCount < StopRedirectingAfter)
        {
            if (redirectCount >= ErrorRedirectLimit)
            {
                throw new InvalidOperationException(string.Format("Too many redirects. Error limit = {0}", redirectCount));
            }

            var location = response.Headers.Location;
            if (!location.IsAbsoluteUri)
            {
                location = new Uri(response.RequestMessage.RequestUri, location);
            }

            request = new HttpRequestMessage(HttpMethod.Get, location);

            response = await SendCookiesAsync(request, cancellationToken).ConfigureAwait(false);

            redirectCount++;
        }

        return response;
    }

    internal Cookie GetCookie(string uri, string name)
    {
        return _cookieContainer.GetCookies(new Uri(uri)).Cast().Where(x => x.Name == name).FirstOrDefault();
    }

    internal void RemoveCookie(string uri, string name)
    {
        var cookie = _cookieContainer.GetCookies(new Uri(uri)).Cast().Where(x=>x.Name == name).FirstOrDefault();
        if (cookie != null)
        {
            cookie.Expired = true;
        }
    }

    protected async Task SendCookiesAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        if (AllowCookies)
        {
            string cookieHeader = _cookieContainer.GetCookieHeader(request.RequestUri);
            if (!string.IsNullOrEmpty(cookieHeader))
            {
                request.Headers.Add("Cookie", cookieHeader);
            }
        }

        var response = await base.SendAsync(request, cancellationToken);

        if (AllowCookies && response.Headers.Contains("Set-Cookie"))
        {
            var responseCookieHeader = string.Join(",", response.Headers.GetValues("Set-Cookie"));
            _cookieContainer.SetCookies(request.RequestUri, responseCookieHeader);
        }

        return response;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/IdentityServerPipeline.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Test;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace IdentityServer.IntegrationTests.Common;

public class IdentityServerPipeline
{
    public const string BaseUrl = "https://server";
    public const string LoginPage = BaseUrl + "/account/login";
    public const string ConsentPage = BaseUrl + "/account/consent";
    public const string ErrorPage = BaseUrl + "/home/error";

    public const string DeviceAuthorization = BaseUrl + "/connect/deviceauthorization";
    public const string DiscoveryEndpoint = BaseUrl + "/.well-known/openid-configuration";
    public const string DiscoveryKeysEndpoint = BaseUrl + "/.well-known/openid-configuration/jwks";
    public const string AuthorizeEndpoint = BaseUrl + "/connect/authorize";
    public const string TokenEndpoint = BaseUrl + "/connect/token";
    public const string RevocationEndpoint = BaseUrl + "/connect/revocation";
    public const string UserInfoEndpoint = BaseUrl + "/connect/userinfo";
    public const string IntrospectionEndpoint = BaseUrl + "/connect/introspect";
    public const string IdentityTokenValidationEndpoint = BaseUrl + "/connect/identityTokenValidation";
    public const string EndSessionEndpoint = BaseUrl + "/connect/endsession";
    public const string EndSessionCallbackEndpoint = BaseUrl + "/connect/endsession/callback";
    public const string CheckSessionEndpoint = BaseUrl + "/connect/checksession";

    public const string FederatedSignOutPath = "/signout-oidc";
    public const string FederatedSignOutUrl = BaseUrl + FederatedSignOutPath;

    public IdentityServerOptions Options { get; set; }
    public List Clients { get; set; } = new List();
    public List IdentityScopes { get; set; } = new List();
    public List ApiResources { get; set; } = new List();
    public List ApiScopes { get; set; } = new List();
    public List Users { get; set; } = new List();

    public TestServer Server { get; set; }
    public HttpMessageHandler Handler { get; set; }

    public BrowserClient BrowserClient { get; set; }
    public HttpClient BackChannelClient { get; set; }

    public MockMessageHandler BackChannelMessageHandler { get; set; } = new MockMessageHandler();
    public MockMessageHandler JwtRequestMessageHandler { get; set; } = new MockMessageHandler();

    public event Action OnPreConfigureServices = services => { };
    public event Action OnPostConfigureServices = services => { };
    public event Action OnPreConfigure = app => { };
    public event Action OnPostConfigure = app => { };

    public Func> OnFederatedSignout;

    public void Initialize(string basePath = null, bool enableLogging = false)
    {
        var builder = new WebHostBuilder();
        builder.ConfigureServices(ConfigureServices);
        builder.Configure(app =>
        {
            if (basePath != null)
            {
                app.Map(basePath, map =>
                {
                    ConfigureApp(map);
                });
            }
            else
            {
                ConfigureApp(app);
            }
        });

        if (enableLogging)
        {
            builder.ConfigureLogging((ctx, b) => b.AddConsole());
        }

        Server = new TestServer(builder);
        Handler = Server.CreateHandler();

        BrowserClient = new BrowserClient(new BrowserHandler(Handler));
        BackChannelClient = new HttpClient(Handler);
    }

    public void ConfigureServices(IServiceCollection services)
    {
        OnPreConfigureServices(services);

        services.AddAuthentication(opts =>
        {
            opts.AddScheme("external", scheme =>
            {
                scheme.DisplayName = "External";
                scheme.HandlerType = typeof(MockExternalAuthenticationHandler);
            });
        });
        services.AddTransient(svcs =>
        {
            var handler = new MockExternalAuthenticationHandler(svcs.GetRequiredService());
            if (OnFederatedSignout != null) handler.OnFederatedSignout = OnFederatedSignout;
            return handler;
        });

        services.AddIdentityServer(options =>
        {
            Options = options;

            options.Events = new EventsOptions
            {
                RaiseErrorEvents = true,
                RaiseFailureEvents = true,
                RaiseInformationEvents = true,
                RaiseSuccessEvents = true
            };
        })
        .AddInMemoryClients(Clients)
        .AddInMemoryIdentityResources(IdentityScopes)
        .AddInMemoryApiResources(ApiResources)
        .AddInMemoryApiScopes(ApiScopes)
        .AddTestUsers(Users)
        .AddDeveloperSigningCredential(persistKey: false);

        services.AddHttpClient(IdentityServerConstants.HttpClients.BackChannelLogoutHttpClient)
            .AddHttpMessageHandler(() => BackChannelMessageHandler);

        services.AddHttpClient(IdentityServerConstants.HttpClients.JwtRequestUriHttpClient)
            .AddHttpMessageHandler(() => JwtRequestMessageHandler);

        OnPostConfigureServices(services);
    }

    public void ConfigureApp(IApplicationBuilder app)
    {
        OnPreConfigure(app);

        app.UseIdentityServer();

        // UI endpoints
        app.Map(Constants.UIConstants.DefaultRoutePaths.Login.EnsureLeadingSlash(), path =>
        {
            path.Run(ctx => OnLogin(ctx));
        });
        app.Map(Constants.UIConstants.DefaultRoutePaths.Logout.EnsureLeadingSlash(), path =>
        {
            path.Run(ctx => OnLogout(ctx));
        });
        app.Map(Constants.UIConstants.DefaultRoutePaths.Consent.EnsureLeadingSlash(), path =>
        {
            path.Run(ctx => OnConsent(ctx));
        });
        app.Map(Constants.UIConstants.DefaultRoutePaths.Error.EnsureLeadingSlash(), path =>
        {
            path.Run(ctx => OnError(ctx));
        });

        OnPostConfigure(app);
    }

    public bool LoginWasCalled { get; set; }
    public AuthorizationRequest LoginRequest { get; set; }
    public ClaimsPrincipal Subject { get; set; }
    public bool FollowLoginReturnUrl { get; set; }

    private async Task OnLogin(HttpContext ctx)
    {
        LoginWasCalled = true;
        await ReadLoginRequest(ctx);
        await IssueLoginCookie(ctx);
    }

    private async Task ReadLoginRequest(HttpContext ctx)
    {
        var interaction = ctx.RequestServices.GetRequiredService();
        LoginRequest = await interaction.GetAuthorizationContextAsync(ctx.Request.Query["returnUrl"].FirstOrDefault());
    }

    private async Task IssueLoginCookie(HttpContext ctx)
    {
        if (Subject != null)
        {
            var props = new AuthenticationProperties();
            await ctx.SignInAsync(Subject, props);
            Subject = null;
            var url = ctx.Request.Query[Options.UserInteraction.LoginReturnUrlParameter].FirstOrDefault();
            if (url != null)
            {
                ctx.Response.RedirectIfAllowed(url);
            }
        }
    }

    public bool LogoutWasCalled { get; set; }
    public LogoutRequest LogoutRequest { get; set; }

    private async Task OnLogout(HttpContext ctx)
    {
        LogoutWasCalled = true;
        await ReadLogoutRequest(ctx);
        await ctx.SignOutAsync();
    }

    private async Task ReadLogoutRequest(HttpContext ctx)
    {
        var interaction = ctx.RequestServices.GetRequiredService();
        LogoutRequest = await interaction.GetLogoutContextAsync(ctx.Request.Query["logoutId"].FirstOrDefault());
    }

    public bool ConsentWasCalled { get; set; }
    public AuthorizationRequest ConsentRequest { get; set; }
    public ConsentResponse ConsentResponse { get; set; }

    private async Task OnConsent(HttpContext ctx)
    {
        ConsentWasCalled = true;
        await ReadConsentMessage(ctx);
        await CreateConsentResponse(ctx);
    }

    private async Task ReadConsentMessage(HttpContext ctx)
    {
        var interaction = ctx.RequestServices.GetRequiredService();
        ConsentRequest = await interaction.GetAuthorizationContextAsync(ctx.Request.Query["returnUrl"].FirstOrDefault());
    }

    private async Task CreateConsentResponse(HttpContext ctx)
    {
        if (ConsentRequest != null && ConsentResponse != null)
        {
            var interaction = ctx.RequestServices.GetRequiredService();
            await interaction.GrantConsentAsync(ConsentRequest, ConsentResponse);
            ConsentResponse = null;

            var url = ctx.Request.Query[Options.UserInteraction.ConsentReturnUrlParameter].FirstOrDefault();
            if (url != null)
            {
                ctx.Response.RedirectIfAllowed(url);
            }
        }
    }

    public bool ErrorWasCalled { get; set; }
    public ErrorMessage ErrorMessage { get; set; }

    private async Task OnError(HttpContext ctx)
    {
        ErrorWasCalled = true;
        await ReadErrorMessage(ctx);
    }

    private async Task ReadErrorMessage(HttpContext ctx)
    {
        var interaction = ctx.RequestServices.GetRequiredService();
        ErrorMessage = await interaction.GetErrorContextAsync(ctx.Request.Query["errorId"].FirstOrDefault());
    }

    /* helpers */
    public async Task LoginAsync(ClaimsPrincipal subject)
    {
        var old = BrowserClient.AllowAutoRedirect;
        BrowserClient.AllowAutoRedirect = false;

        Subject = subject;
        await BrowserClient.GetAsync(LoginPage);

        BrowserClient.AllowAutoRedirect = old;
    }

    public async Task LoginAsync(string subject)
    {
        await LoginAsync(new IdentityServerUser(subject).CreatePrincipal());
    }

    public void RemoveLoginCookie()
    {
        BrowserClient.RemoveCookie(BaseUrl, IdentityServerConstants.DefaultCookieAuthenticationScheme);
    }
    public void RemoveSessionCookie()
    {
        BrowserClient.RemoveCookie(BaseUrl, IdentityServerConstants.DefaultCheckSessionCookieName);
    }
    public Cookie GetSessionCookie()
    {
        return BrowserClient.GetCookie(BaseUrl, IdentityServerConstants.DefaultCheckSessionCookieName);
    }

    public string CreateAuthorizeUrl(
        string clientId = null,
        string responseType = null,
        string scope = null,
        string redirectUri = null,
        string state = null,
        string nonce = null,
        string loginHint = null,
        string acrValues = null,
        string responseMode = null,
        string codeChallenge = null,
        string codeChallengeMethod = null,
        object extra = null)
    {
        Parameters prms = extra is null ? null : Parameters.FromObject(extra);
        var url = new RequestUrl(AuthorizeEndpoint).CreateAuthorizeUrl(
            clientId: clientId,
            responseType: responseType,
            scope: scope,
            redirectUri: redirectUri,
            state: state,
            nonce: nonce,
            loginHint: loginHint,
            acrValues: acrValues,
            responseMode: responseMode,
            codeChallenge: codeChallenge,
            codeChallengeMethod: codeChallengeMethod,
            extra: prms);
        return url;
    }

    public AuthorizeResponse ParseAuthorizationResponseUrl(string url)
    {
        return new AuthorizeResponse(url);
    }

    public async Task RequestAuthorizationEndpointAsync(
        string clientId,
        string responseType,
        string scope = null,
        string redirectUri = null,
        string state = null,
        string nonce = null,
        string loginHint = null,
        string acrValues = null,
        string responseMode = null,
        string codeChallenge = null,
        string codeChallengeMethod = null,
        object extra = null)
    {
        var old = BrowserClient.AllowAutoRedirect;
        BrowserClient.AllowAutoRedirect = false;

        var url = CreateAuthorizeUrl(clientId, responseType, scope, redirectUri, state, nonce, loginHint, acrValues, responseMode, codeChallenge, codeChallengeMethod, extra);
        var result = await BrowserClient.GetAsync(url);
        result.StatusCode.Should().Be(HttpStatusCode.Found);

        BrowserClient.AllowAutoRedirect = old;

        var redirect = result.Headers.Location.ToString();
        if (redirect.StartsWith(IdentityServerPipeline.ErrorPage))
        {
            // request error page in pipeline so we can get error info
            await BrowserClient.GetAsync(redirect);

            // no redirect to client
            return null;
        }

        return new AuthorizeResponse(redirect);
    }
}

public class MockMessageHandler : DelegatingHandler
{
    public bool InvokeWasCalled { get; set; }
    public Func OnInvoke { get; set; }
    public HttpResponseMessage Response { get; set; } = new HttpResponseMessage(HttpStatusCode.OK);

    protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        InvokeWasCalled = true;

        if (OnInvoke != null)
        {
            await OnInvoke.Invoke(request);
        }
        return Response;
    }
}

public class MockExternalAuthenticationHandler :
    IAuthenticationHandler,
    IAuthenticationSignInHandler,
    IAuthenticationRequestHandler
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private HttpContext HttpContext => _httpContextAccessor.HttpContext;

    public Func> OnFederatedSignout =
        async context =>
        {
            await context.SignOutAsync();
            return true;
        };

    public MockExternalAuthenticationHandler(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }

    public async Task HandleRequestAsync()
    {
        if (HttpContext.Request.Path == IdentityServerPipeline.FederatedSignOutPath)
        {
            return await OnFederatedSignout(HttpContext);
        }

        return false;
    }

    public Task AuthenticateAsync()
    {
        return Task.FromResult(AuthenticateResult.NoResult());
    }

    public Task ChallengeAsync(AuthenticationProperties properties)
    {
        return Task.CompletedTask;
    }

    public Task ForbidAsync(AuthenticationProperties properties)
    {
        return Task.CompletedTask;
    }

    public Task InitializeAsync(AuthenticationScheme scheme, HttpContext context)
    {
        return Task.CompletedTask;
    }

    public Task SignInAsync(ClaimsPrincipal user, AuthenticationProperties properties)
    {
        return Task.CompletedTask;
    }

    public Task SignOutAsync(AuthenticationProperties properties)
    {
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/MessageHandlerWrapper.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace IdentityServer.IntegrationTests.Common;

public class MessageHandlerWrapper : DelegatingHandler
{
    public HttpResponseMessage Response { get; set; }

    public MessageHandlerWrapper(HttpMessageHandler handler)
        : base(handler)
    {
    }

    protected async override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        Response = await base.SendAsync(request, cancellationToken);
        return Response;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/NetworkHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace IdentityServer.IntegrationTests.Common;

public class NetworkHandler : HttpMessageHandler
{
    enum Behavior
    {
        Throw,
        ReturnError,
        ReturnDocument
    }

    private readonly Exception _exception;
    private readonly Behavior _behavior;
    private readonly HttpStatusCode _statusCode;
    private readonly string _reason;
    private readonly string _document;
    private readonly Func _selector;
    private readonly Func _action;

    public HttpRequestMessage Request { get; set; }
    public string Body { get; set; }

    public NetworkHandler(Exception exception)
    {
        _exception = exception;
        _behavior = Behavior.Throw;
    }

    public NetworkHandler(HttpStatusCode statusCode, string reason)
    {
        _statusCode = statusCode;
        _reason = reason;

        _behavior = Behavior.ReturnError;
    }

    public NetworkHandler(string document, HttpStatusCode statusCode)
    {
        _statusCode = statusCode;
        _document = document;
        _behavior = Behavior.ReturnDocument;
    }

    public NetworkHandler(Func documentSelector, HttpStatusCode statusCode)
    {
        _statusCode = statusCode;
        _selector = documentSelector;
        _behavior = Behavior.ReturnDocument;
    }

    public NetworkHandler(Func action)
    {
        _action = action;
    }

    protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
    {
        Request = request;
        Body = await SafeReadContentFrom(request);

        if (_action != null)
        {
            return _action(request);
        }

        if (_behavior == Behavior.Throw) throw _exception;

        var response = new HttpResponseMessage(_statusCode);

        if (_behavior == Behavior.ReturnError)
        {
            response.ReasonPhrase = _reason;
        }

        if (_behavior == Behavior.ReturnDocument)
        {
            if (_selector != null)
            {
                response.Content = new StringContent(_selector(request));
            }
            else
            {
                response.Content = new StringContent(_document);
            }
        }

        return response;
    }

    private async Task SafeReadContentFrom(HttpRequestMessage request)
    {
        if (request.Content == null) return null;

        return await request.Content.ReadAsStringAsync();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Common/TestCert.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Security.Cryptography.X509Certificates;

namespace IdentityServer.IntegrationTests.Common;

internal static class TestCert
{
    public static X509Certificate2 Load()
    {
        var cert = Path.Combine(System.AppContext.BaseDirectory, "identityserver_testing.pfx");
        return new X509Certificate2(cert, "password");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Conformance/Basic/ClientAuthenticationTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Conformance.Basic;

public class ClientAuthenticationTests 
{
    private const string Category = "Conformance.Basic.ClientAuthenticationTests";

    private IdentityServerPipeline _pipeline = new IdentityServerPipeline();

    public ClientAuthenticationTests()
    {
        _pipeline.IdentityScopes.Add(new IdentityResources.OpenId());
        _pipeline.Clients.Add(new Client
        {
            Enabled = true,
            ClientId = "code_pipeline.Client",
            ClientSecrets = new List
            {
                new Secret("secret".Sha512())
            },

            AllowedGrantTypes = GrantTypes.Code,
            AllowedScopes = { "openid" },

            RequireConsent = false,
            RequirePkce = false,
            RedirectUris = new List
            {
                "https://code_pipeline.Client/callback",
                "https://code_pipeline.Client/callback?foo=bar&baz=quux"
            }
        });

        _pipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
               {
                    new Claim("name", "Bob Loblaw"),
                    new Claim("email", "bob@loblaw.com"),
                    new Claim("role", "Attorney")
               }
        });

        _pipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Token_endpoint_supports_client_authentication_with_basic_authentication_with_POST()
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();

        _pipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _pipeline.CreateAuthorizeUrl(
                       clientId: "code_pipeline.Client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_pipeline.Client/callback?foo=bar&baz=quux",
                       nonce: nonce);
        var response = await _pipeline.BrowserClient.GetAsync(url);

        var authorization = _pipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
        authorization.Code.Should().NotBeNull();

        var code = authorization.Code;

        // backchannel client
        var wrapper = new MessageHandlerWrapper(_pipeline.Handler);
        var tokenClient = new HttpClient(wrapper);
        var tokenResult = await tokenClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = "code_pipeline.Client",
            ClientSecret = "secret",

            Code = code,
            RedirectUri = "https://code_pipeline.Client/callback?foo=bar&baz=quux"
        });

        tokenResult.IsError.Should().BeFalse();
        tokenResult.HttpErrorReason.Should().Be("OK");
        tokenResult.TokenType.Should().Be("Bearer");
        tokenResult.AccessToken.Should().NotBeNull();
        tokenResult.ExpiresIn.Should().BeGreaterThan(0);
        tokenResult.IdentityToken.Should().NotBeNull();

        wrapper.Response.Headers.CacheControl.NoCache.Should().BeTrue();
        wrapper.Response.Headers.CacheControl.NoStore.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Token_endpoint_supports_client_authentication_with_form_encoded_authentication_in_POST_body()
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();

        _pipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _pipeline.CreateAuthorizeUrl(
                       clientId: "code_pipeline.Client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_pipeline.Client/callback?foo=bar&baz=quux",
                       nonce: nonce);
        var response = await _pipeline.BrowserClient.GetAsync(url);

        var authorization = _pipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
        authorization.Code.Should().NotBeNull();

        var code = authorization.Code;

        // backchannel client
        var wrapper = new MessageHandlerWrapper(_pipeline.Handler);
        var tokenClient = new HttpClient(wrapper);
        var tokenResult = await tokenClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = "code_pipeline.Client",
            ClientSecret = "secret",
            ClientCredentialStyle = ClientCredentialStyle.PostBody,

            Code = code,
            RedirectUri = "https://code_pipeline.Client/callback?foo=bar&baz=quux"
        });

        tokenResult.IsError.Should().BeFalse();
        tokenResult.HttpErrorReason.Should().Be("OK");
        tokenResult.TokenType.Should().Be("Bearer");
        tokenResult.AccessToken.Should().NotBeNull();
        tokenResult.ExpiresIn.Should().BeGreaterThan(0);
        tokenResult.IdentityToken.Should().NotBeNull();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Conformance/Basic/CodeFlowTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Conformance.Basic;

public class CodeFlowTests 
{
    private const string Category = "Conformance.Basic.CodeFlowTests";

    private IdentityServerPipeline _pipeline = new IdentityServerPipeline();

    public CodeFlowTests()
    {
        _pipeline.IdentityScopes.Add(new IdentityResources.OpenId());
        _pipeline.Clients.Add(new Client
        {
            Enabled = true,
            ClientId = "code_pipeline.Client",
            ClientSecrets = new List
            {
                new Secret("secret".Sha512())
            },

            AllowedGrantTypes = GrantTypes.Code,
            AllowedScopes = { "openid" },

            RequireConsent = false,
            RequirePkce = false,
            RedirectUris = new List
            {
                "https://code_pipeline.Client/callback",
                "https://code_pipeline.Client/callback?foo=bar&baz=quux"
            }
        });

        _pipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
               {
                    new Claim("name", "Bob Loblaw"),
                    new Claim("email", "bob@loblaw.com"),
                    new Claim("role", "Attorney")
               }
        });

        _pipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task No_state_should_not_result_in_shash()
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();

        _pipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _pipeline.CreateAuthorizeUrl(
                       clientId: "code_pipeline.Client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_pipeline.Client/callback?foo=bar&baz=quux",
                       nonce: nonce);
        var response = await _pipeline.BrowserClient.GetAsync(url);

        var authorization = _pipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
        authorization.Code.Should().NotBeNull();

        var code = authorization.Code;

        // backchannel client
        var wrapper = new MessageHandlerWrapper(_pipeline.Handler);
        var tokenClient = new HttpClient(wrapper);
        var tokenResult = await tokenClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = "code_pipeline.Client",
            ClientSecret = "secret",

            Code = code,
            RedirectUri = "https://code_pipeline.Client/callback?foo=bar&baz=quux"
        });

        tokenResult.IsError.Should().BeFalse();
        tokenResult.HttpErrorReason.Should().Be("OK");
        tokenResult.TokenType.Should().Be("Bearer");
        tokenResult.AccessToken.Should().NotBeNull();
        tokenResult.ExpiresIn.Should().BeGreaterThan(0);
        tokenResult.IdentityToken.Should().NotBeNull();

        var token = new JwtSecurityToken(tokenResult.IdentityToken);
        
        var s_hash = token.Claims.FirstOrDefault(c => c.Type == "s_hash");
        s_hash.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task State_should_result_in_shash()
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();

        _pipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _pipeline.CreateAuthorizeUrl(
                       clientId: "code_pipeline.Client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_pipeline.Client/callback?foo=bar&baz=quux",
                       state: "state",
                       nonce: nonce);
        var response = await _pipeline.BrowserClient.GetAsync(url);

        var authorization = _pipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
        authorization.Code.Should().NotBeNull();

        var code = authorization.Code;

        // backchannel client
        var wrapper = new MessageHandlerWrapper(_pipeline.Handler);
        var tokenClient = new HttpClient(wrapper);
        var tokenResult = await tokenClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = "code_pipeline.Client",
            ClientSecret = "secret",

            Code = code,
            RedirectUri = "https://code_pipeline.Client/callback?foo=bar&baz=quux"
        });

        tokenResult.IsError.Should().BeFalse();
        tokenResult.HttpErrorReason.Should().Be("OK");
        tokenResult.TokenType.Should().Be("Bearer");
        tokenResult.AccessToken.Should().NotBeNull();
        tokenResult.ExpiresIn.Should().BeGreaterThan(0);
        tokenResult.IdentityToken.Should().NotBeNull();

        var token = new JwtSecurityToken(tokenResult.IdentityToken);
        
        var s_hash = token.Claims.FirstOrDefault(c => c.Type == "s_hash");
        s_hash.Should().NotBeNull();
        s_hash.Value.Should().Be(CryptoHelper.CreateHashClaimValue("state", "RS256"));
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Conformance/Basic/RedirectUriTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Conformance.Basic;

public class RedirectUriTests
{
    private const string Category = "Conformance.Basic.RedirectUriTests";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public RedirectUriTests()
    {
        _mockPipeline.Initialize();

        _mockPipeline.Clients.Add(new Client
        {
            Enabled = true,
            ClientId = "code_client",
            ClientSecrets = new List
            {
                new Secret("secret".Sha512())
            },

            AllowedGrantTypes = GrantTypes.Code,
            AllowedScopes = { "openid" },

            RequireConsent = false,
            RequirePkce = false,
            RedirectUris = new List
            {
                "https://code_client/callback",
                "https://code_client/callback?foo=bar&baz=quux"
            }
        });

        _mockPipeline.IdentityScopes.Add(new IdentityResources.OpenId());

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
                {
                    new Claim("name", "Bob Loblaw"),
                    new Claim("email", "bob@loblaw.com"),
                    new Claim("role", "Attorney")
                }
        });
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Reject_redirect_uri_not_matching_registered_redirect_uri()
    {
        await _mockPipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var state = Guid.NewGuid().ToString();

        var url = _mockPipeline.CreateAuthorizeUrl(
                       clientId: "code_client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://bad",
                       state: state,
                       nonce: nonce);
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Reject_request_without_redirect_uri_when_multiple_registered()
    {
        await _mockPipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var state = Guid.NewGuid().ToString();

        var url = _mockPipeline.CreateAuthorizeUrl(
                      clientId: "code_client",
                      responseType: "code",
                      scope: "openid",
                      // redirectUri deliberately absent 
                      redirectUri: null,
                      state: state,
                      nonce: nonce);
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Preserves_query_parameters_in_redirect_uri()
    {
        await _mockPipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var state = Guid.NewGuid().ToString();

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _mockPipeline.CreateAuthorizeUrl(
                       clientId: "code_client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_client/callback?foo=bar&baz=quux",
                       state: state,
                       nonce: nonce);
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://code_client/callback?");
        var authorization = _mockPipeline.ParseAuthorizationResponseUrl(response.Headers.Location.ToString());
        authorization.Code.Should().NotBeNull();
        authorization.State.Should().Be(state);
        var query = Microsoft.AspNetCore.WebUtilities.QueryHelpers.ParseQuery(response.Headers.Location.Query);
        query["foo"].ToString().Should().Be("bar");
        query["baz"].ToString().Should().Be("quux");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Rejects_redirect_uri_when_query_parameter_does_not_match()
    {
        await _mockPipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var state = Guid.NewGuid().ToString();

        var url = _mockPipeline.CreateAuthorizeUrl(
                       clientId: "code_client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_client/callback?baz=quux&foo=bar",
                       state: state,
                       nonce: nonce);
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Conformance/Basic/ResponseTypeResponseModeTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Conformance.Basic;

public class ResponseTypeResponseModeTests
{
    private const string Category = "Conformance.Basic.ResponseTypeResponseModeTests";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public ResponseTypeResponseModeTests()
    {
        _mockPipeline.Initialize();
        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        _mockPipeline.Clients.Add(new Client
        {
            Enabled = true,
            ClientId = "code_client",
            ClientSecrets = new List
            {
                new Secret("secret".Sha512())
            },

            AllowedGrantTypes = GrantTypes.Code,
            AllowedScopes = { "openid" },

            RequireConsent = false,
            RequirePkce = false,
            RedirectUris = new List
            {
                "https://code_client/callback"
            }
        });

        _mockPipeline.IdentityScopes.Add(new IdentityResources.OpenId());

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
                {
                    new Claim("name", "Bob Loblaw"),
                    new Claim("email", "bob@loblaw.com"),
                    new Claim("role", "Attorney")
                }
        });
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Request_with_response_type_code_supported()
    {
        await _mockPipeline.LoginAsync("bob");

        var metadata = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.DiscoveryEndpoint);
        metadata.StatusCode.Should().Be(HttpStatusCode.OK);

        var state = Guid.NewGuid().ToString();
        var nonce = Guid.NewGuid().ToString();

        var url = _mockPipeline.CreateAuthorizeUrl(
                       clientId: "code_client",
                       responseType: "code",
                       scope: "openid",
                       redirectUri: "https://code_client/callback",
                       state: state,
                       nonce: nonce);
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        response.StatusCode.Should().Be(HttpStatusCode.Found);

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.Code.Should().NotBeNull();
        authorization.State.Should().Be(state);
    }

    // this might not be in sync with the actual conformance tests
    // since we dead-end on the error page due to changes 
    // to follow the RFC to address open redirect in original OAuth RFC
    [Fact]
    [Trait("Category", Category)]
    public async Task Request_missing_response_type_rejected()
    {
        await _mockPipeline.LoginAsync("bob");

        var state = Guid.NewGuid().ToString();
        var nonce = Guid.NewGuid().ToString();

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "code_client",
            responseType: null, // missing
            scope: "openid",
            redirectUri: "https://code_client/callback",
            state: state,
            nonce: nonce);

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("unsupported_response_type");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Conformance/Pkce/PkceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Conformance.Pkce;

public class PkceTests
{
    private const string Category = "PKCE";

    private IdentityServerPipeline _pipeline = new IdentityServerPipeline();

    private Client client;

    private const string client_id = "code_client";
    private const string client_id_optional = "code_client_optional";
    private const string client_id_plain = "code_plain_client";
    private const string client_id_pkce = "codewithproofkey_client";
    private const string client_id_pkce_plain = "codewithproofkey_plain_client";


    private string redirect_uri = "https://code_client/callback";
    private string code_verifier = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
    private string client_secret = "secret";
    private string response_type = "code";

    public PkceTests()
    {
        _pipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                    new Claim("name", "Bob Loblaw"),
                    new Claim("email", "bob@loblaw.com"),
                    new Claim("role", "Attorney")
            }
        });
        _pipeline.IdentityScopes.Add(new IdentityResources.OpenId());

        _pipeline.Clients.Add(client = new Client
        {
            Enabled = true,
            ClientId = client_id,
            ClientSecrets = new List
            {
                new Secret(client_secret.Sha256())
            },

            AllowedGrantTypes = GrantTypes.Code,
            RequirePkce = true,

            AllowedScopes = { "openid" },

            RequireConsent = false,
            RedirectUris = new List
            {
                redirect_uri
            }
        });
        _pipeline.Clients.Add(client = new Client
        {
            Enabled = true,
            ClientId = client_id_optional,
            ClientSecrets = new List
            {
                new Secret(client_secret.Sha256())
            },

            AllowedGrantTypes = GrantTypes.Code,
            RequirePkce = false,

            AllowedScopes = { "openid" },

            RequireConsent = false,
            RedirectUris = new List
            {
                redirect_uri
            }
        });
        _pipeline.Clients.Add(client = new Client
        {
            Enabled = true,
            ClientId = client_id_pkce,
            ClientSecrets = new List
            {
                new Secret(client_secret.Sha256())
            },

            AllowedGrantTypes = GrantTypes.Code,
            RequirePkce = true,

            AllowedScopes = { "openid" },

            RequireConsent = false,
            RedirectUris = new List
            {
                redirect_uri
            }
        });

        // allow plain text PKCE
        _pipeline.Clients.Add(client = new Client
        {
            Enabled = true,
            ClientId = client_id_plain,
            ClientSecrets = new List
            {
                new Secret(client_secret.Sha256())
            },

            AllowedGrantTypes = GrantTypes.Code,
            RequirePkce = true,
            AllowPlainTextPkce = true,

            AllowedScopes = { "openid" },

            RequireConsent = false,
            RedirectUris = new List
            {
                redirect_uri
            }
        });
        _pipeline.Clients.Add(client = new Client
        {
            Enabled = true,
            ClientId = client_id_pkce_plain,
            ClientSecrets = new List
            {
                new Secret(client_secret.Sha256())
            },

            AllowedGrantTypes = GrantTypes.Code,
            RequirePkce = true,
            AllowPlainTextPkce = true,

            AllowedScopes = { "openid" },

            RequireConsent = false,
            RedirectUris = new List
            {
                redirect_uri
            }
        });

        _pipeline.Initialize();
    }

    [Theory]
    [InlineData(client_id)]
    [InlineData(client_id_pkce)]
    [Trait("Category", Category)]
    public async Task Client_cannot_use_plain_code_challenge_method(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        _pipeline.ErrorWasCalled.Should().BeTrue();
        _pipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
    }

    [Theory]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Client_can_use_plain_code_challenge_method(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = code_verifier
        });

        tokenResponse.IsError.Should().BeFalse();
        tokenResponse.TokenType.Should().Be("Bearer");
        tokenResponse.AccessToken.Should().NotBeNull();
        tokenResponse.IdentityToken.Should().NotBeNull();
        tokenResponse.ExpiresIn.Should().BeGreaterThan(0);
    }

    [Theory]
    [InlineData(client_id)]
    [InlineData(client_id_pkce)]
    [Trait("Category", Category)]
    public async Task Client_can_use_sha256_code_challenge_method(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = Sha256OfCodeVerifier(code_verifier);
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Sha256);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = code_verifier
        });

        tokenResponse.IsError.Should().BeFalse();
        tokenResponse.TokenType.Should().Be("Bearer");
        tokenResponse.AccessToken.Should().NotBeNull();
        tokenResponse.IdentityToken.Should().NotBeNull();
        tokenResponse.ExpiresIn.Should().BeGreaterThan(0);
    }

    [Theory]
    [InlineData(client_id_pkce)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Authorize_request_needs_code_challenge(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce);

        authorizeResponse.Should().BeNull();
    }
    
    [Fact]
    [Trait("Category", Category)]
    public async Task Code_verifier_should_not_be_accepted_if_no_code_challenge_was_used()
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(client_id_optional,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = client_id_optional,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = code_verifier
        });

        tokenResponse.IsError.Should().BeTrue();
    }

    [Theory]
    [InlineData(client_id)]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Authorize_request_code_challenge_cannot_be_too_short(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge:"a");

        _pipeline.ErrorWasCalled.Should().BeTrue();
        _pipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
    }

    [Theory]
    [InlineData(client_id)]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Authorize_request_code_challenge_cannot_be_too_long(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: new string('a', _pipeline.Options.InputLengthRestrictions.CodeChallengeMaxLength + 1)
        );

        _pipeline.ErrorWasCalled.Should().BeTrue();
        _pipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
    }

    [Theory]
    [InlineData(client_id)]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Authorize_request_needs_supported_code_challenge_method(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: "unknown_code_challenge_method"
        );

        authorizeResponse.Should().BeNull();
    }

    [Theory]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Token_request_needs_code_verifier(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
        });

        tokenResponse.IsError.Should().BeTrue();
        tokenResponse.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
    }

    [Theory]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Token_request_code_verifier_cannot_be_too_short(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = "a"
        });

        tokenResponse.IsError.Should().BeTrue();
        tokenResponse.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
    }

    [Theory]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Token_request_code_verifier_cannot_be_too_long(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = new string('a', _pipeline.Options.InputLengthRestrictions.CodeVerifierMaxLength + 1)
        });

        tokenResponse.IsError.Should().BeTrue();
        tokenResponse.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
    }

    [Theory]
    [InlineData(client_id_plain)]
    [InlineData(client_id_pkce_plain)]
    [Trait("Category", Category)]
    public async Task Token_request_code_verifier_must_match_with_code_chalenge(string clientId)
    {
        await _pipeline.LoginAsync("bob");

        var nonce = Guid.NewGuid().ToString();
        var code_challenge = code_verifier;
        var authorizeResponse = await _pipeline.RequestAuthorizationEndpointAsync(clientId,
            response_type,
            IdentityServerConstants.StandardScopes.OpenId,
            redirect_uri,
            nonce: nonce,
            codeChallenge: code_challenge,
            codeChallengeMethod: OidcConstants.CodeChallengeMethods.Plain);

        authorizeResponse.IsError.Should().BeFalse();

        var code = authorizeResponse.Code;

        var tokenResponse = await _pipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = clientId,
            ClientSecret = client_secret,

            Code = code,
            RedirectUri = redirect_uri,
            CodeVerifier = "mismatched_code_verifier"
        });

        tokenResponse.IsError.Should().BeTrue();
        tokenResponse.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
    }

    private static string Sha256OfCodeVerifier(string codeVerifier)
    {
        var codeVerifierBytes = Encoding.ASCII.GetBytes(codeVerifier);
        var hashedBytes = codeVerifierBytes.Sha256();
        var transformedCodeVerifier = Base64Url.Encode(hashedBytes);

        return transformedCodeVerifier;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Authorize/AuthorizeTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Default;
using IdentityServer8.Test;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Authorize;

public class AuthorizeTests
{
    private const string Category = "Authorize endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    private Client _client1;

    public AuthorizeTests()
    {
        _mockPipeline.Clients.AddRange(new Client[] {
            _client1 = new Client
            {
                ClientId = "client1",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,

                AllowedScopes = new List { "openid", "profile" },
                RedirectUris = new List { "https://client1/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client2",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = true,

                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client2/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client3",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,

                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client3/callback" },
                AllowAccessTokensViaBrowser = true,
                EnableLocalLogin = false,
                IdentityProviderRestrictions = new List { "google" }
            },
            new Client
            {
                ClientId = "client4",
                AllowedGrantTypes = GrantTypes.Code,
                RequireClientSecret = false,
                RequireConsent = false,
                RequirePkce = false,
                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client4/callback" },
            },

        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                Scopes = { "api1", "api2" }
            }
        });
        _mockPipeline.ApiScopes.AddRange(new ApiScope[] {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            }
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_request_should_not_return_404()
    {
        var response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.AuthorizeEndpoint);

        response.StatusCode.Should().NotBe(HttpStatusCode.NotFound);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task post_request_without_form_should_return_415()
    {
        var response = await _mockPipeline.BrowserClient.PostAsync(IdentityServerPipeline.AuthorizeEndpoint, new StringContent("foo"));

        response.StatusCode.Should().Be(HttpStatusCode.UnsupportedMediaType);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task post_request_should_return_200()
    {
        var response = await _mockPipeline.BrowserClient.PostAsync(IdentityServerPipeline.AuthorizeEndpoint,
            new FormUrlEncodedContent(
                new Dictionary { }));

        response.StatusCode.Should().Be(HttpStatusCode.OK);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_request_should_not_return_500()
    {
        var response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.AuthorizeEndpoint);

        ((int) response.StatusCode).Should().BeLessThan(500);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task anonymous_user_should_be_redirected_to_login_page()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
    }

    [Theory]
    [InlineData((Type) null)]
    [InlineData(typeof(QueryStringAuthorizationParametersMessageStore))]
    [InlineData(typeof(DistributedCacheAuthorizationParametersMessageStore))]
    [Trait("Category", Category)]
    public async Task signin_request_should_have_authorization_params(Type storeType)
    {
        if (storeType != null)
        {
            _mockPipeline.OnPostConfigureServices += services =>
            {
                services.AddTransient(typeof(IAuthorizationParametersMessageStore), storeType);
            };
            _mockPipeline.Initialize();
        }

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            loginHint: "login_hint_value",
            acrValues: "acr_1 acr_2 tenant:tenant_value idp:idp_value",
            extra: new
            {
                display = "popup", // must use a valid value from the spec for display
                ui_locales = "ui_locale_value",
                custom_foo = "foo_value"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url + "&foo=bar");

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be("client1");
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });
        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("bar");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signin_response_should_allow_successful_authorization_response()
    {
        _mockPipeline.Subject = new IdentityServerUser("bob").CreatePrincipal();
        _mockPipeline.BrowserClient.StopRedirectingAfter = 2;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client1/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.IdentityToken.Should().NotBeNull();
        authorization.State.Should().Be("123_state");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authenticated_user_with_valid_request_should_receive_authorization_response()
    {
        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client1/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.IdentityToken.Should().NotBeNull();
        authorization.State.Should().Be("123_state");
    }

    [Theory]
    [InlineData((Type) null)]
    [InlineData(typeof(QueryStringAuthorizationParametersMessageStore))]
    [InlineData(typeof(DistributedCacheAuthorizationParametersMessageStore))]
    [Trait("Category", Category)]
    public async Task login_response_and_consent_response_should_receive_authorization_response(Type storeType)
    {
        if (storeType != null)
        {
            _mockPipeline.OnPostConfigureServices += services =>
            {
                services.AddTransient(typeof(IAuthorizationParametersMessageStore), storeType);
            };
            _mockPipeline.Initialize();
        }

        _mockPipeline.Subject = new IdentityServerUser("bob").CreatePrincipal();

        _mockPipeline.ConsentResponse = new ConsentResponse()
        {
            ScopesValuesConsented = new string[] { "openid", "api1", "profile" }
        };

        _mockPipeline.BrowserClient.StopRedirectingAfter = 4;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token token",
            scope: "openid profile api1 api2",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client2/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.IdentityToken.Should().NotBeNull();
        authorization.State.Should().Be("123_state");
        var scopes = authorization.Scope.Split(' ');
        scopes.Should().BeEquivalentTo(new string[] { "profile", "api1", "openid" });
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task idp_should_be_passed_to_login_page()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid profile",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: "idp:google");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.IdP.Should().Be("google");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task idp_not_allowed_by_client_should_not_be_passed_to_login_page()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid profile",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: "idp:facebook");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.IdP.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task user_idp_not_allowed_by_client_should_cause_login_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid profile",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.IdP.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task for_invalid_client_error_page_should_not_receive_client_id()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: null,
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://invalid",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.ClientId.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task error_page_should_receive_client_id()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://invalid",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.ClientId.Should().Be("client1");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_redirect_uri_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://invalid",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("redirect_uri");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_redirect_uri_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://invalid",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_client_id_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1_invalid",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_client_id_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1_invalid",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_redirect_uri_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1_invalid",
            responseType: "id_token",
            scope: "openid",
            //redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("client");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_redirect_uri_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1_invalid",
            responseType: "id_token",
            scope: "openid",
            //redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task malformed_redirect_uri_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1_invalid",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "invalid-uri",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("client");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task disabled_client_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        _client1.Enabled = false;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task disabled_client_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        _client1.Enabled = false;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_protocol_for_client_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        _client1.ProtocolType = "invalid";

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("protocol");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_protocol_for_client_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        _client1.ProtocolType = "invalid";

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_type_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "invalid",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnsupportedResponseType);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_type_should_not_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "invalid",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().BeNull();
        _mockPipeline.ErrorMessage.ResponseMode.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_mode_for_flow_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            responseMode: "query",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("response_mode");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_mode_for_flow_should_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            responseMode: "query",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_mode_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            responseMode: "invalid",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.UnsupportedResponseType);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("response_mode");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_response_mode_should_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            responseMode: "invalid",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_scope_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            //scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("scope");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_scope_should_pass_return_url_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            //scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task explicit_response_mode_should_be_passed_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            responseMode: "form_post",
            //scope: "openid", // this will cause the error
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("form_post");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task scope_too_long_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: new string('x', 500),
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("scope");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_openid_scope_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "profile",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("scope");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("openid");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task client_not_allowed_access_to_scope_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid email",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("scope");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_nonce_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state"
        //nonce: "123_nonce"
        );
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("nonce");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task nonce_too_long_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: new string('x', 500));
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("nonce");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task locale_too_long_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            extra: new { ui_locales = new string('x', 500) });
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("ui_locales");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task invalid_max_age_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            extra: new { max_age = "invalid" });
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("max_age");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task negative_max_age_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            extra: new { max_age = "-10" });
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("max_age");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task login_hint_too_long_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            loginHint: new string('x', 500));
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("login_hint");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task acr_values_too_long_should_show_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: new string('x', 500));
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Contain("acr_values");
        _mockPipeline.ErrorMessage.RedirectUri.Should().StartWith("https://client1/callback");
        _mockPipeline.ErrorMessage.ResponseMode.Should().Be("fragment");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task overlapping_identity_scopes_and_api_scopes_should_show_error_page()
    {
        _mockPipeline.IdentityScopes.Add(new IdentityResource("foo", "Foo", new string[] { "name" }));
        _mockPipeline.IdentityScopes.Add(new IdentityResource("bar", "Bar", new string[] { "name" }));
        _mockPipeline.ApiScopes.Add(new ApiScope("foo", "Foo"));
        _mockPipeline.ApiScopes.Add(new ApiScope("bar", "Bar"));

        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid foo bar",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");


        Func a = async () => await _mockPipeline.BrowserClient.GetAsync(url);
        await a.Should().ThrowAsync();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task ui_locales_should_be_passed_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: new string('x', 500),
            extra: new { ui_locales = "fr-FR" });
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.UiLocales.Should().Be("fr-FR");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task display_mode_should_be_passed_to_error_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: new string('x', 500),
            extra: new { display = "popup" });
        await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.ErrorMessage.DisplayMode.Should().Be("popup");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task unicode_values_in_url_should_be_processed_correctly()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        url = url.Replace(IdentityServerPipeline.BaseUrl, "https://грант.рф");

        var result = await _mockPipeline.BackChannelClient.GetAsync(url);
        result.Headers.Location.Authority.Should().Be("xn--80af5akm.xn--p1ai");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task code_flow_with_fragment_response_type_should_be_allowed()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client4",
            responseType: "code",
            responseMode: "fragment",
            scope: "openid",
            redirectUri: "https://client4/callback",
            state: "123_state",
            nonce: "123_nonce");

        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.LoginWasCalled.Should().BeTrue();
    }


    [Fact]
    [Trait("Category", Category)]
    public async Task prompt_login_should_show_login_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid profile",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce",
            extra: new { prompt = "login" }
        );
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Authorize/ConsentTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Default;
using IdentityServer8.Test;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Authorize;

public class ConsentTests
{
    private const string Category = "Authorize and consent tests";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public ConsentTests()
    {
        _mockPipeline.Clients.AddRange(new Client[] {
            new Client
            {
                ClientId = "client1",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid", "profile" },
                RedirectUris = new List { "https://client1/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client2",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = true,
                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client2/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client3",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client3/callback" },
                AllowAccessTokensViaBrowser = true,
                IdentityProviderRestrictions = new List { "google" }
            }
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                Scopes = { "api1", "api2" }
            }
        });

        _mockPipeline.ApiScopes.AddRange(new ApiScope[]
        {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            }
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task client_requires_consent_should_show_consent_page()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce"
        );
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ConsentWasCalled.Should().BeTrue();
    }

    [Theory]
    [InlineData((Type)null)]
    [InlineData(typeof(QueryStringAuthorizationParametersMessageStore))]
    [InlineData(typeof(DistributedCacheAuthorizationParametersMessageStore))]
    [Trait("Category", Category)]
    public async Task consent_page_should_have_authorization_params(Type storeType)
    {
        if (storeType != null)
        {
            _mockPipeline.OnPostConfigureServices += services =>
            {
                services.AddTransient(typeof(IAuthorizationParametersMessageStore), storeType);
            };
            _mockPipeline.Initialize();
        }

        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token token",
            scope: "openid api1 api2",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce",
            acrValues: "acr_1 acr_2 tenant:tenant_value",
            extra: new
            {
                display = "popup", // must use a valid value form the spec for display
                ui_locales = "ui_locale_value",
                custom_foo = "foo_value"
            }
        );
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ConsentRequest.Should().NotBeNull();
        _mockPipeline.ConsentRequest.Client.ClientId.Should().Be("client2");
        _mockPipeline.ConsentRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.ConsentRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.ConsentRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.ConsentRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });
        _mockPipeline.ConsentRequest.Parameters.AllKeys.Should().Contain("custom_foo");
        _mockPipeline.ConsentRequest.Parameters["custom_foo"].Should().Be("foo_value");
        _mockPipeline.ConsentRequest.ValidatedResources.RawScopeValues.Should().BeEquivalentTo(new string[] { "api2", "openid", "api1" });
    }

    [Theory]
    [InlineData((Type)null)]
    [InlineData(typeof(QueryStringAuthorizationParametersMessageStore))]
    [InlineData(typeof(DistributedCacheAuthorizationParametersMessageStore))]
    [Trait("Category", Category)]
    public async Task consent_response_should_allow_successful_authorization_response(Type storeType)
    {
        if (storeType != null)
        {
            _mockPipeline.OnPostConfigureServices += services =>
            {
                services.AddTransient(typeof(IAuthorizationParametersMessageStore), storeType);
            };
            _mockPipeline.Initialize();
        }

        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.ConsentResponse = new ConsentResponse()
        {
            ScopesValuesConsented = new string[] { "openid", "api2" }
        };
        _mockPipeline.BrowserClient.StopRedirectingAfter = 2;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token token",
            scope: "openid profile api1 api2",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client2/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.IdentityToken.Should().NotBeNull();
        authorization.State.Should().Be("123_state");
        var scopes = authorization.Scope.Split(' ');
        scopes.Should().BeEquivalentTo(new string[] { "api2", "openid" });
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task consent_response_should_reject_modified_request_params()
    {
        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.ConsentResponse = new ConsentResponse()
        {
            ScopesValuesConsented = new string[] { "openid", "api2" }
        };
        _mockPipeline.BrowserClient.AllowAutoRedirect = false;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token token",
            scope: "openid profile api2",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://server/consent");

        response = await _mockPipeline.BrowserClient.GetAsync(response.Headers.Location.ToString());

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("/connect/authorize/callback");

        var modifiedAuthorizeCallback = "https://server" + response.Headers.Location.ToString();
        modifiedAuthorizeCallback = modifiedAuthorizeCallback.Replace("api2", "api1%20api2");

        response = await _mockPipeline.BrowserClient.GetAsync(modifiedAuthorizeCallback);
        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://server/consent");
    }

    [Fact()]
    [Trait("Category", Category)]
    public async Task consent_response_missing_required_scopes_should_error()
    {
        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.ConsentResponse = new ConsentResponse()
        {
            ScopesValuesConsented = new string[] { "api2" }
        };
        _mockPipeline.BrowserClient.StopRedirectingAfter = 2;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token token",
            scope: "openid profile api1 api2",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client2/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeTrue();
        authorization.Error.Should().Be("access_denied");
        authorization.State.Should().Be("123_state");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Authorize/JwtRequestAuthorizeTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Claims;
using System.Security.Cryptography.X509Certificates;
using System.Text.Json;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Microsoft.IdentityModel.Logging;
using Microsoft.IdentityModel.Tokens;
using Xunit;
using JsonWebKey = Microsoft.IdentityModel.Tokens.JsonWebKey;

namespace IdentityServer.IntegrationTests.Endpoints.Authorize;

public class JwtRequestAuthorizeTests
{
    private const string Category = "Authorize endpoint with JWT requests";

    private readonly IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();
    private readonly Client _client;

    private readonly string _symmetricJwk = @"{ ""kty"": ""oct"", ""use"": ""sig"", ""kid"": ""1"", ""k"": ""nYA-IFt8xTsdBHe9hunvizcp3Dt7f6qGqudq18kZHNtvqEGjJ9Ud-9x3kbQ-LYfLHS3xM2MpFQFg1JzT_0U_F8DI40oby4TvBDGszP664UgA8_5GjB7Flnrlsap1NlitvNpgQX3lpyTvC2zVuQ-UVsXbBDAaSBUSlnw7SE4LM8Ye2WYZrdCCXL8yAX9vIR7vf77yvNTEcBCI6y4JlvZaqMB4YKVSfygs8XqGGCHjLpE5bvI-A4ESbAUX26cVFvCeDg9pR6HK7BmwPMlO96krgtKZcXEJtUELYPys6-rbwAIdmxJxKxpgRpt0FRv_9fm6YPwG7QivYBX-vRwaodL1TA"", ""alg"": ""HS256""}";
    private readonly RsaSecurityKey _rsaKey;

    public JwtRequestAuthorizeTests()
    {
        IdentityModelEventSource.ShowPII = true;

        _rsaKey = CryptoHelper.CreateRsaSecurityKey();

        _mockPipeline.Clients.AddRange(new Client[]
        {
            _client = new Client
            {
                ClientName = "Client with keys",
                ClientId = "client",
                Enabled = true,
                RequireRequestObject = true,

                RedirectUris = { "https://client/callback" },

                ClientSecrets =
                {
                    new Secret
                    {
                        // x509 cert as base64 string
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value = Convert.ToBase64String(TestCert.Load().Export(X509ContentType.Cert))
                    },
                    new Secret
                    {
                        // symmetric key as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = _symmetricJwk
                    },
                    new Secret
                    {
                        // RSA key as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = JsonSerializer.Serialize(JsonWebKeyConverter.ConvertFromRSASecurityKey(_rsaKey))
                    },
                    new Secret
                    {
                        // x509 cert as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = JsonSerializer.Serialize(JsonWebKeyConverter.ConvertFromX509SecurityKey(new X509SecurityKey(TestCert.Load())))
                    }
                },

                AllowedGrantTypes = GrantTypes.Implicit,

                AllowedScopes = new List
                {
                    "openid", "profile", "api1", "api2"
                }
            },
            _client = new Client
            {
                ClientName = "Client with keys",
                ClientId = "client2",
                Enabled = true,
                RequireRequestObject = true,

                RedirectUris = { "https://client/callback" },

                ClientSecrets =
                {
                    new Secret
                    {
                        // x509 cert as base64 string
                        Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                        Value = Convert.ToBase64String(TestCert.Load().Export(X509ContentType.Cert))
                    },
                    new Secret
                    {
                        // symmetric key as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = _symmetricJwk
                    },
                    new Secret
                    {
                        // RSA key as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = JsonSerializer.Serialize(JsonWebKeyConverter.ConvertFromRSASecurityKey(_rsaKey))
                    },
                    new Secret
                    {
                        // x509 cert as JWK
                        Type = IdentityServerConstants.SecretTypes.JsonWebKey,
                        Value = JsonSerializer.Serialize(JsonWebKeyConverter.ConvertFromX509SecurityKey(new X509SecurityKey(TestCert.Load())))
                    }
                },

                AllowedGrantTypes = GrantTypes.Implicit,

                AllowedScopes = new List
                {
                    "openid", "profile", "api1", "api2"
                }
            },
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                Scopes = { "api1", "api2" }
            }
        });
        _mockPipeline.ApiScopes.AddRange(new ApiScope[] {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            }
        });

        _mockPipeline.Initialize();
    }

    string CreateRequestJwt(string issuer, string audience, SigningCredentials credential, Claim[] claims, bool setJwtTyp = false)
    {
        var handler = new JwtSecurityTokenHandler();
        handler.OutboundClaimTypeMap.Clear();

        var token = handler.CreateJwtSecurityToken(
            issuer: issuer,
            audience: audience,
            signingCredentials: credential,
            subject: Identity.Create("pwd", claims));

        if (setJwtTyp)
        {
            token.Header["typ"] = JwtClaimTypes.JwtTypes.AuthorizationRequest;
        }

        return handler.WriteToken(token);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_request_object_should_fail()
    {
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            scope: "openid profile",
            state: "123state",
            nonce: "123nonce",
            redirectUri: "https://client/callback");

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Client must use request object, but no request or request_uri parameter present");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_valid_JWT_request_object_parameters_using_X509_certificate()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });

        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.LoginRequest.RequestObjectValues.Count.Should().Be(11);
        _mockPipeline.LoginRequest.RequestObjectValues.Should().ContainKey("foo");
        _mockPipeline.LoginRequest.RequestObjectValues["foo"].Should().Be("123foo");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_valid_JWT_request_object_parameters_using_symmetric_jwk()
    {
        var jwk = new Microsoft.IdentityModel.Tokens.JsonWebKey(_symmetricJwk);
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new SigningCredentials(jwk, "HS256"),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });

        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.LoginRequest.RequestObjectValues.Count.Should().Be(11);
        _mockPipeline.LoginRequest.RequestObjectValues.Should().ContainKey("foo");
        _mockPipeline.LoginRequest.RequestObjectValues["foo"].Should().Be("123foo");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_valid_JWT_request_object_parameters_using_rsa_jwk()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new SigningCredentials(_rsaKey, "RS256"),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });

        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.LoginRequest.RequestObjectValues.Count.Should().Be(11);
        _mockPipeline.LoginRequest.RequestObjectValues.Should().ContainKey("foo");
        _mockPipeline.LoginRequest.RequestObjectValues["foo"].Should().Be("123foo");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task correct_jwt_typ_should_pass_strict_validation()
    {
        _mockPipeline.Options.StrictJarValidation = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new SigningCredentials(_rsaKey, "RS256"),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        }, setJwtTyp: true);

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });

        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.LoginRequest.RequestObjectValues.Count.Should().Be(11);
        _mockPipeline.LoginRequest.RequestObjectValues.Should().ContainKey("foo");
        _mockPipeline.LoginRequest.RequestObjectValues["foo"].Should().Be("123foo");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task missing_jwt_typ_should_error()
    {
        _mockPipeline.Options.StrictJarValidation = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new SigningCredentials(_rsaKey, "RS256"),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task mismatch_in_jwt_values_should_error()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new SigningCredentials(_rsaKey, "RS256"),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            scope: "bad",
            state: "bad",
            nonce: "bad",
            redirectUri: "bad",
            acrValues: "bad",
            loginHint: "bad",
            extra: new
            {
                display = "bad",
                ui_locales = "bad",
                foo = "bad",
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Parameter mismatch in JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_complex_objects_in_request_object()
    {
        var someObj = new { foo = new { bar = "bar" }, baz = "baz" };
        var someObjJson = JsonSerializer.Serialize(someObj);
        var someArr = new[] { "a", "b", "c" };
        var someArrJson = JsonSerializer.Serialize(someArr);


        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
                new Claim("someObj", someObjJson),
                new Claim("someArr", someArrJson),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();

        _mockPipeline.LoginRequest.Parameters["someObj"].Should().NotBeNull();
        var someObj2 = JsonSerializer.Deserialize(_mockPipeline.LoginRequest.Parameters["someObj"], someObj.GetType());
        someObj.Should().BeEquivalentTo(someObj2);
        _mockPipeline.LoginRequest.Parameters["someArr"].Should().NotBeNull();
        var someArr2 =JsonSerializer.Deserialize(_mockPipeline.LoginRequest.Parameters["someArr"]);
        someArr2.Should().Contain(new[] { "a", "c", "b" });
        someArr2.Length.Should().Be(3);

        _mockPipeline.LoginRequest.RequestObjectValues.Count.Should().Be(13);
        _mockPipeline.LoginRequest.RequestObjectValues["someObj"].Should().NotBeNull();
        someObj2 =JsonSerializer.Deserialize(_mockPipeline.LoginRequest.RequestObjectValues["someObj"], someObj.GetType());
        someObj.Should().BeEquivalentTo(someObj2);
        _mockPipeline.LoginRequest.RequestObjectValues["someArr"].Should().NotBeNull();
        someArr2 =JsonSerializer.Deserialize(_mockPipeline.LoginRequest.Parameters["someArr"]);
        someArr2.Should().Contain(new[] { "a", "c", "b" });
        someArr2.Length.Should().Be(3);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_without_client_id()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid client_id");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_without_client_id_in_jwt()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
            });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_if_audience_is_incorrect()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: "invalid",
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_if_issuer_does_not_match_client_id()
    {
        var requestJwt = CreateRequestJwt(
            issuer: "invalid",
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_that_includes_request_param()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
                new Claim("request", "request")
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_that_includes_request_uri_param()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
                new Claim("request_uri", "request_uri")
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_object");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_if_response_type_does_not_match()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo")
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_jwt_request_if_client_id_does_not_match()
    {
        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("response_type", "id_token"),
                new Claim("client_id", "client"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo")
        });

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token",
            extra: new
            {
                request = requestJwt
            });

        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request");
        _mockPipeline.ErrorMessage.ErrorDescription.Should().Be("Invalid JWT request");
        _mockPipeline.LoginRequest.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_ignore_request_uri_when_feature_is_disabled()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = false;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });
        _mockPipeline.JwtRequestMessageHandler.OnInvoke = req =>
        {
            req.RequestUri.Should().Be(new Uri("http://client_jwt"));
            return Task.CompletedTask;
        };
        _mockPipeline.JwtRequestMessageHandler.Response.Content = new StringContent(requestJwt);


        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.ErrorWasCalled.Should().BeTrue();

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_request_uri_with_valid_jwt()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });
        _mockPipeline.JwtRequestMessageHandler.OnInvoke = req =>
        {
            req.RequestUri.Should().Be(new Uri("http://client_jwt"));
            return Task.CompletedTask;
        };
        _mockPipeline.JwtRequestMessageHandler.Response.Content = new StringContent(requestJwt);


        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });
        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_accept_request_uri_with_valid_jwt_and_strict_validation()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;
        _mockPipeline.Options.StrictJarValidation = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        }, setJwtTyp: true);
        _mockPipeline.JwtRequestMessageHandler.OnInvoke = req =>
        {
            req.RequestUri.Should().Be(new Uri("http://client_jwt"));
            return Task.CompletedTask;
        };
        _mockPipeline.JwtRequestMessageHandler.Response.Content = new StringContent(requestJwt);
        _mockPipeline.JwtRequestMessageHandler.Response.Content.Headers.ContentType = new MediaTypeHeaderValue($"application/{JwtClaimTypes.JwtTypes.AuthorizationRequest}");


        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginRequest.Should().NotBeNull();
        _mockPipeline.LoginRequest.Client.ClientId.Should().Be(_client.ClientId);
        _mockPipeline.LoginRequest.DisplayMode.Should().Be("popup");
        _mockPipeline.LoginRequest.UiLocales.Should().Be("ui_locale_value");
        _mockPipeline.LoginRequest.IdP.Should().Be("idp_value");
        _mockPipeline.LoginRequest.Tenant.Should().Be("tenant_value");
        _mockPipeline.LoginRequest.LoginHint.Should().Be("login_hint_value");
        _mockPipeline.LoginRequest.AcrValues.Should().BeEquivalentTo(new string[] { "acr_2", "acr_1" });
        _mockPipeline.LoginRequest.Parameters.AllKeys.Should().Contain("foo");
        _mockPipeline.LoginRequest.Parameters["foo"].Should().Be("123foo");

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task authorize_should_reject_request_uri_with_valid_jwt_and_strict_validation_but_invalid_content_type()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;
        _mockPipeline.Options.StrictJarValidation = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        }, setJwtTyp: true);
        _mockPipeline.JwtRequestMessageHandler.OnInvoke = req =>
        {
            req.RequestUri.Should().Be(new Uri("http://client_jwt"));
            return Task.CompletedTask;
        };
        _mockPipeline.JwtRequestMessageHandler.Response.Content = new StringContent(requestJwt);


        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorMessage.Error.Should().Be("invalid_request_uri");
        _mockPipeline.LoginRequest.Should().BeNull();
        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task request_uri_response_returns_500_should_fail()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;

        _mockPipeline.JwtRequestMessageHandler.Response = new HttpResponseMessage(System.Net.HttpStatusCode.InternalServerError);

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.Should().BeNull();

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task request_uri_response_returns_404_should_fail()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;

        _mockPipeline.JwtRequestMessageHandler.Response = new HttpResponseMessage(System.Net.HttpStatusCode.NotFound);

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.Should().BeNull();

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task request_uri_length_too_long_should_fail()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request_uri = "http://" + new string('x', 512)
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.Should().BeNull();

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task both_request_and_request_uri_params_should_fail()
    {
        _mockPipeline.Options.Endpoints.EnableJwtRequestUri = true;

        var requestJwt = CreateRequestJwt(
            issuer: _client.ClientId,
            audience: IdentityServerPipeline.BaseUrl,
            credential: new X509SigningCredentials(TestCert.Load()),
            claims: new[] {
                new Claim("client_id", _client.ClientId),
                new Claim("response_type", "id_token"),
                new Claim("scope", "openid profile"),
                new Claim("state", "123state"),
                new Claim("nonce", "123nonce"),
                new Claim("redirect_uri", "https://client/callback"),
                new Claim("acr_values", "acr_1 acr_2 tenant:tenant_value idp:idp_value"),
                new Claim("login_hint", "login_hint_value"),
                new Claim("display", "popup"),
                new Claim("ui_locales", "ui_locale_value"),
                new Claim("foo", "123foo"),
        });
        _mockPipeline.JwtRequestMessageHandler.Response.Content = new StringContent(requestJwt);


        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: _client.ClientId,
            responseType: "id_token",
            extra: new
            {
                request = requestJwt,
                request_uri = "http://client_jwt"
            });
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.ErrorWasCalled.Should().BeTrue();
        _mockPipeline.LoginRequest.Should().BeNull();

        _mockPipeline.JwtRequestMessageHandler.InvokeWasCalled.Should().BeFalse();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Authorize/RestrictAccessTokenViaBrowserTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Net;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Authorize;

public class RestrictAccessTokenViaBrowserTests
{
    private const string Category = "RestrictAccessTokenViaBrowserTests";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    private ClaimsPrincipal _user = new IdentityServerUser("bob").CreatePrincipal();

    public RestrictAccessTokenViaBrowserTests()
    {
        _mockPipeline.Clients.AddRange(new Client[] {
            new Client
            {
                ClientId = "client1",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid" },
                RedirectUris = new List { "https://client1/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client2",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid" },
                RedirectUris = new List { "https://client2/callback" },
                AllowAccessTokensViaBrowser = false
            },
            new Client
            {
                ClientId = "client3",
                AllowedGrantTypes = GrantTypes.Hybrid,
                ClientSecrets = { new Secret("secret".Sha256()) },
                RequireConsent = false,
                RequirePkce = false,
                AllowedScopes = new List { "openid" },
                RedirectUris = new List { "https://client3/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client4",
                AllowedGrantTypes = GrantTypes.Hybrid,
                ClientSecrets = { new Secret("secret".Sha256()) },
                RequireConsent = false,
                RequirePkce = false,
                AllowedScopes = new List { "openid" },
                RedirectUris = new List { "https://client4/callback" },
                AllowAccessTokensViaBrowser = false
            }
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unrestricted_implicit_client_can_request_IdToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client1",
            "id_token", "openid", "https://client1/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client1/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unrestricted_implicit_client_can_request_IdTokenToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client1",
            "id_token token", "openid", "https://client1/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client1/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Restricted_implicit_client_can_request_IdToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client2",
            "id_token", "openid", "https://client2/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client2/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Restricted_implicit_client_cannot_request_IdTokenToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client2",
            "id_token token", "openid", "https://client2/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.ErrorWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unrestricted_hybrid_client_can_request_CodeIdToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client3",
            "code id_token", "openid", "https://client3/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client3/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().BeNull();
        authorization.Code.Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unrestricted_hybrid_client_can_request_CodeIdTokenToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client3",
            "code id_token token", "openid", "https://client3/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client3/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().NotBeNull();
        authorization.Code.Should().NotBeNull();
    }


    [Fact]
    [Trait("Category", Category)]
    public async Task Restricted_hybrid_client_can_request_CodeIdToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client4",
            "code id_token", "openid", "https://client4/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Found);
        response.Headers.Location.AbsoluteUri.Should().StartWith("https://client4/callback");
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IdentityToken.Should().NotBeNull();
        authorization.AccessToken.Should().BeNull();
        authorization.Code.Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Restricted_hybrid_client_cannot_request_CodeIdTokenToken()
    {
        await _mockPipeline.LoginAsync(_user);

        var url = _mockPipeline.CreateAuthorizeUrl("client4",
            "code id_token token", "openid", "https://client4/callback", "state", "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        _mockPipeline.ErrorWasCalled.Should().BeTrue();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Authorize/SessionIdTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Authorize;

public class SessionIdTests
{
    private const string Category = "SessionIdTests";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public SessionIdTests()
    {
        _mockPipeline.Clients.AddRange(new Client[] {
            new Client
            {
                ClientId = "client1",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid", "profile" },
                RedirectUris = new List { "https://client1/callback" },
                AllowAccessTokensViaBrowser = true
            },
            new Client
            {
                ClientId = "client2",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = true,
                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client2/callback" },
                AllowAccessTokensViaBrowser = true
            }
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
            }
        });
        _mockPipeline.ApiScopes.AddRange(new ApiScope[] {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            }
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    public async Task session_id_should_be_reissued_if_session_cookie_absent()
    {
        await _mockPipeline.LoginAsync("bob");
        var sid1 = _mockPipeline.GetSessionCookie().Value;
        sid1.Should().NotBeNull();

        _mockPipeline.RemoveSessionCookie();

        await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.DiscoveryEndpoint);

        var sid2 = _mockPipeline.GetSessionCookie().Value;
        sid2.Should().Be(sid1);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/CheckSession/CheckSessionTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Net;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.CheckSession;

public class CheckSessionTests
{
    private const string Category = "Check session endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public CheckSessionTests()
    {
        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_request_should_not_return_404()
    {
        var response = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.CheckSessionEndpoint);

        response.StatusCode.Should().NotBe(HttpStatusCode.NotFound);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/DeviceAuthorization/DeviceAuthorizationTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using Newtonsoft.Json;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.DeviceAuthorization;

public class DeviceAuthorizationTests
{
    private const string Category = "Device authorization endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public DeviceAuthorizationTests()
    {
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "client1",
            ClientSecrets = {new Secret("secret".Sha256())},
            AllowedGrantTypes = GrantTypes.DeviceFlow,
            AllowedScopes = {"openid"}
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_should_return_InvalidRequest()
    {
        var response = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.DeviceAuthorization);
        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var resultDto = ParseJsonBody(await response.Content.ReadAsStreamAsync());

        resultDto.Should().NotBeNull();
        resultDto.error.Should().Be(OidcConstants.TokenErrors.InvalidRequest);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task wrong_content_type_return_InvalidRequest()
    {
        var form = new Dictionary
        {
            {"client_id", Guid.NewGuid().ToString()}
        };
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.DeviceAuthorization,
            new StringContent(@"{""client_id"": ""client1""}", Encoding.UTF8, "application/json"));

        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var resultDto = ParseJsonBody(await response.Content.ReadAsStreamAsync());

        resultDto.Should().NotBeNull();
        resultDto.error.Should().Be(OidcConstants.TokenErrors.InvalidRequest);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task empty_request_should_return_InvalidClient()
    {
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.DeviceAuthorization,
            new FormUrlEncodedContent(new Dictionary()));

        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var resultDto = ParseJsonBody(await response.Content.ReadAsStreamAsync());

        resultDto.Should().NotBeNull();
        resultDto.error.Should().Be(OidcConstants.TokenErrors.InvalidClient);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task unknown_client_should_return_InvalidClient()
    {
        var form = new Dictionary
        {
            {"client_id", "client1"}
        };
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.DeviceAuthorization, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var resultDto = ParseJsonBody(await response.Content.ReadAsStreamAsync());

        resultDto.Should().NotBeNull();
        resultDto.error.Should().Be(OidcConstants.TokenErrors.InvalidClient);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task valid_should_return_json()
    {
        var form = new Dictionary
        {
            {"client_id", "client1"},
            {"client_secret", "secret" }
        };
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.DeviceAuthorization, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.MediaType.Should().Be("application/json");
        
        var resultDto = ParseJsonBody(await response.Content.ReadAsStreamAsync());

        resultDto.Should().NotBeNull();

        resultDto.Should().NotBeNull();
        resultDto.device_code.Should().NotBeNull();
        resultDto.user_code.Should().NotBeNull();
        resultDto.verification_uri.Should().NotBeNull();
        resultDto.verification_uri_complete.Should().NotBeNull();
        resultDto.expires_in.Should().BeGreaterThan(0);
        resultDto.interval.Should().BeGreaterThan(0);
    }

    private T ParseJsonBody(Stream streamBody)
    {
        streamBody.Position = 0;
        using (var reader = new StreamReader(streamBody))
        {
            var jsonString = reader.ReadToEnd();
            return JsonConvert.DeserializeObject(jsonString);
        }
    }

    internal class ResultDto
    {
        public string device_code { get; set; }
        public string user_code { get; set; }
        public string verification_uri { get; set; }
        public string verification_uri_complete { get; set; }
        public int expires_in { get; set; }
        public int interval { get; set; }
    }

    internal class ErrorResultDto
    {
        public string error { get; set; }
        public string error_description { get; set; }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Discovery/DiscoveryEndpointTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using Newtonsoft.Json.Linq;
using System.Linq;
using System.Threading.Tasks;
using Xunit;
using JsonWebKey = Microsoft.IdentityModel.Tokens.JsonWebKey;

namespace IdentityServer.IntegrationTests.Endpoints.Discovery;

public class DiscoveryEndpointTests
{
    private const string Category = "Discovery endpoint";

    [Fact]
    [Trait("Category", Category)]
    public async Task Issuer_uri_should_be_lowercase()
    {
        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("HTTPS://SERVER/ROOT/.WELL-KNOWN/OPENID-CONFIGURATION");

        var json = await result.Content.ReadAsStringAsync();
        var data = JObject.Parse(json);
        var issuer = data["issuer"].ToString();

        issuer.Should().Be("https://server/root");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task when_lower_case_issuer_option_disabled_issuer_uri_should_be_preserved()
    {
        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.Initialize("/ROOT");

        pipeline.Options.LowerCaseIssuerUri = false;

        var result = await pipeline.BackChannelClient.GetAsync("HTTPS://SERVER/ROOT/.WELL-KNOWN/OPENID-CONFIGURATION");

        var json = await result.Content.ReadAsStringAsync();
        var data = JObject.Parse(json);
        var issuer = data["issuer"].ToString();

        issuer.Should().Be("https://server/ROOT");
    }

    private void Pipeline_OnPostConfigureServices(IServiceCollection obj)
    {
        throw new System.NotImplementedException();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Algorithms_supported_should_match_signing_key()
    {
        var key = CryptoHelper.CreateECDsaSecurityKey(JsonWebKeyECTypes.P256);
        var expectedAlgorithm = SecurityAlgorithms.EcdsaSha256;

        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.OnPostConfigureServices += services =>
        {
            // add key to standard RSA key
            services.AddIdentityServerBuilder()
                .AddSigningCredential(key, expectedAlgorithm);
        };
        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("https://server/root/.well-known/openid-configuration");

        var json = await result.Content.ReadAsStringAsync();
        var data = JObject.Parse(json);
        var algorithmsSupported = data["id_token_signing_alg_values_supported"];

        algorithmsSupported.Count().Should().Be(2);

        algorithmsSupported.Values().Should().Contain(SecurityAlgorithms.RsaSha256);
        algorithmsSupported.Values().Should().Contain(SecurityAlgorithms.EcdsaSha256);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Jwks_entries_should_countain_crv()
    {
        var ecdsaKey = CryptoHelper.CreateECDsaSecurityKey(JsonWebKeyECTypes.P256);
        var parameters = ecdsaKey.ECDsa.ExportParameters(true);

        IdentityServerPipeline pipeline = new IdentityServerPipeline();

        var jsonWebKeyFromECDsa = new JsonWebKey()
        {
            Kty = JsonWebAlgorithmsKeyTypes.EllipticCurve,
            Use = "sig",
            Kid = ecdsaKey.KeyId,
            KeyId = ecdsaKey.KeyId,
            X = Base64UrlEncoder.Encode(parameters.Q.X),
            Y = Base64UrlEncoder.Encode(parameters.Q.Y),
            D = Base64UrlEncoder.Encode(parameters.D),
            Crv = JsonWebKeyECTypes.P256,
            Alg = SecurityAlgorithms.EcdsaSha256
        };
        pipeline.OnPostConfigureServices += services =>
        {
            // add ECDsa as JsonWebKey
            services.AddIdentityServerBuilder()
                .AddSigningCredential(jsonWebKeyFromECDsa, SecurityAlgorithms.EcdsaSha256);
        };

        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("https://server/root/.well-known/openid-configuration/jwks");

        var json = await result.Content.ReadAsStringAsync();
        var data = JObject.Parse(json);

        var keys = data["keys"];
        keys.Should().NotBeNull();

        var key = keys[1];
        key.Should().NotBeNull();

        var crv = key["crv"];
        crv.Should().NotBeNull();

        crv.Value().Should().Be(JsonWebKeyECTypes.P256);

    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Jwks_entries_should_contain_alg()
    {
        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("https://server/root/.well-known/openid-configuration/jwks");

        var json = await result.Content.ReadAsStringAsync();
        var data = JObject.Parse(json);

        var keys = data["keys"];
        keys.Should().NotBeNull();

        var key = keys[0];
        key.Should().NotBeNull();

        var alg = key["alg"];
        alg.Should().NotBeNull();

        alg.Value().Should().Be(Constants.SigningAlgorithms.RSA_SHA_256);
    }

    [Theory]
    [InlineData(JsonWebKeyECTypes.P256, SecurityAlgorithms.EcdsaSha256)]
    [InlineData(JsonWebKeyECTypes.P384, SecurityAlgorithms.EcdsaSha384)]
    [InlineData(JsonWebKeyECTypes.P521, SecurityAlgorithms.EcdsaSha512)]
    [Trait("Category", Category)]
    public async Task Jwks_with_ecdsa_should_have_parsable_key(string crv, string alg)
    {
        var key = CryptoHelper.CreateECDsaSecurityKey(crv);

        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.OnPostConfigureServices += services =>
        {
            services.AddIdentityServerBuilder()
                .AddSigningCredential(key, alg);
        };
        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("https://server/root/.well-known/openid-configuration/jwks");

        var json = await result.Content.ReadAsStringAsync();
        var jwks = new JsonWebKeySet(json);
        var parsedKeys = jwks.GetSigningKeys();

        var matchingKey = parsedKeys.FirstOrDefault(x => x.KeyId == key.KeyId);
        matchingKey.Should().NotBeNull();
        matchingKey.Should().BeOfType();
    }

    [Fact]
    public async Task Jwks_with_two_key_using_different_algs_expect_different_alg_values()
    {
        var ecdsaKey = CryptoHelper.CreateECDsaSecurityKey();
        var rsaKey = CryptoHelper.CreateRsaSecurityKey();

        IdentityServerPipeline pipeline = new IdentityServerPipeline();
        pipeline.OnPostConfigureServices += services =>
        {
            services.AddIdentityServerBuilder()
                .AddSigningCredential(ecdsaKey, "ES256")
                .AddValidationKey(new SecurityKeyInfo { Key = rsaKey, SigningAlgorithm = "RS256" });
        };
        pipeline.Initialize("/ROOT");

        var result = await pipeline.BackChannelClient.GetAsync("https://server/root/.well-known/openid-configuration/jwks");

        var json = await result.Content.ReadAsStringAsync();
        var jwks = new JsonWebKeySet(json);

        jwks.Keys.Should().Contain(x => x.KeyId == ecdsaKey.KeyId && x.Alg == "ES256");
        jwks.Keys.Should().Contain(x => x.KeyId == rsaKey.KeyId && x.Alg == "RS256");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unicode_values_in_url_should_be_processed_correctly()
    {
        var pipeline = new IdentityServerPipeline();
        pipeline.Initialize();

        var result = await pipeline.BackChannelClient.GetDiscoveryDocumentAsync(new DiscoveryDocumentRequest
        {
            Address = "https://грант.рф",
            Policy =
            {
                ValidateIssuerName = false,
                ValidateEndpoints = false,
                RequireHttps = false,
                RequireKeySet = false
            }
        });

        result.Issuer.Should().Be("https://грант.рф");
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/EndSession/EndSessionTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Text;
using System.Text.Encodings.Web;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Microsoft.AspNetCore.WebUtilities;
using Newtonsoft.Json.Linq;
using Xunit;
using static IdentityServer8.IdentityServerConstants;

namespace IdentityServer.IntegrationTests.Endpoints.EndSession;

public class EndSessionTests
{
    private const string Category = "End session endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();
    private Client _wsfedClient;

    public EndSessionTests()
    {
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "client1",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "openid" },
            RedirectUris = new List { "https://client1/callback" },
            FrontChannelLogoutUri = "https://client1/signout",
            PostLogoutRedirectUris = new List { "https://client1/signout-callback" },
            AllowAccessTokensViaBrowser = true
        });

        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "client2",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "openid" },
            RedirectUris = new List { "https://client2/callback" },
            FrontChannelLogoutUri = "https://client2/signout",
            PostLogoutRedirectUris = new List {
                "https://client2/signout-callback",
                "https://client2/signout-callback2"
            },
            AllowAccessTokensViaBrowser = true
        });

        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "client3",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "openid" },
            RedirectUris = new List { "https://client3/callback" },
            BackChannelLogoutUri = "https://client3/signout",
            AllowAccessTokensViaBrowser = true
        });

        _mockPipeline.Clients.Add(_wsfedClient = new Client
        {
            ClientId = "client4",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "openid" },
            RedirectUris = new List { "https://client4/callback" },
            FrontChannelLogoutUri = "https://client4/signout",
            AllowAccessTokensViaBrowser = true
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_request_should_not_return_404()
    {
        var response = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        response.StatusCode.Should().NotBe(HttpStatusCode.NotFound);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_request_should_redirect_to_logout_page()
    {
        var response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task get_request_should_redirect_to_configured_logout_path()
    {
        _mockPipeline.Options.UserInteraction.LogoutUrl = "/logout";
        _mockPipeline.Options.UserInteraction.LogoutIdParameter = "id";

        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token +
            "&post_logout_redirect_uri=https://client1/signout-callback");

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://server/logout?id=");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task logout_request_with_params_should_pass_values_in_logout_context()
    {
        await _mockPipeline.LoginAsync("bob");

        var authorization = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");

        var id_token = authorization.IdentityToken;

        var response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token +
            "&post_logout_redirect_uri=https://client2/signout-callback2");

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
        _mockPipeline.LogoutRequest.Should().NotBeNull();
        _mockPipeline.LogoutRequest.ClientId.Should().Be("client2");
        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().Be("https://client2/signout-callback2");

        var parts = _mockPipeline.LogoutRequest.SignOutIFrameUrl.Split('?');
        parts[0].Should().Be(IdentityServerPipeline.EndSessionCallbackEndpoint);
        var iframeUrl = QueryHelpers.ParseNullableQuery(parts[1]);
        iframeUrl["endSessionId"].FirstOrDefault().Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task logout_request_with_params_but_user_no_longer_authenticated_should_pass_redirect_info_to_logout()
    {
        await _mockPipeline.LoginAsync("bob");

        var authorization = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");

        var id_token = authorization.IdentityToken;

        _mockPipeline.RemoveLoginCookie();

        var response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token +
            "&post_logout_redirect_uri=https://client2/signout-callback2");

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
        _mockPipeline.LogoutRequest.Should().NotBeNull();
        _mockPipeline.LogoutRequest.ClientId.Should().Be("client2");
        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().Be("https://client2/signout-callback2");
        _mockPipeline.LogoutRequest.SignOutIFrameUrl.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_should_support_POST()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;

        var values = new List>();
        values.Add(new KeyValuePair("id_token_hint", id_token));
        values.Add(new KeyValuePair("post_logout_redirect_uri", "https://client1/signout-callback"));
        var content = new FormUrlEncodedContent(values);
        response = await _mockPipeline.BrowserClient.PostAsync(IdentityServerPipeline.EndSessionEndpoint, content);

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
        _mockPipeline.LogoutRequest.Should().NotBeNull();
        _mockPipeline.LogoutRequest.ClientId.Should().Be("client1");
        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().Be("https://client1/signout-callback");

        var parts = _mockPipeline.LogoutRequest.SignOutIFrameUrl.Split('?');
        parts[0].Should().Be(IdentityServerPipeline.EndSessionCallbackEndpoint);
        var iframeUrl = QueryHelpers.ParseNullableQuery(parts[1]);
        iframeUrl["endSessionId"].FirstOrDefault().Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_callback_without_params_should_return_400()
    {
        var response = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.EndSessionCallbackEndpoint);

        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_callback_with_mismatched_post_logout_redirect_uri_should_not_pass_along_logout_uri()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token +
            "&post_logout_redirect_uri=https://client1/signout-callback-not-valid");

        var signoutFrameUrl = _mockPipeline.LogoutRequest.SignOutIFrameUrl;

        response = await _mockPipeline.BrowserClient.GetAsync(signoutFrameUrl);

        _mockPipeline.LogoutRequest.ClientId.Should().NotBeNull();
        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_callback_with_mismatched_id_token_hint_should_not_pass_along_logout_message()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        await _mockPipeline.LoginAsync("alice");

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token +
            "&post_logout_redirect_uri=https://client1/signout-callback");

        _mockPipeline.LogoutRequest.ClientId.Should().BeNull();
        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task valid_signout_callback_should_return_200_html()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        var signoutFrameUrl = _mockPipeline.LogoutRequest.SignOutIFrameUrl;

        response = await _mockPipeline.BrowserClient.GetAsync(signoutFrameUrl);
        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.MediaType.Should().Be("text/html");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task valid_signout_callback_should_render_iframes_for_all_clients()
    {
        await _mockPipeline.LoginAsync("bob");
        var sid = _mockPipeline.GetSessionCookie().Value;

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        var url2 = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response2 = await _mockPipeline.BrowserClient.GetAsync(url2);

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        var signoutFrameUrl = _mockPipeline.LogoutRequest.SignOutIFrameUrl;

        response = await _mockPipeline.BrowserClient.GetAsync(signoutFrameUrl);
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Contain(HtmlEncoder.Default.Encode("https://client1/signout?sid=" + sid + "&iss=" + UrlEncoder.Default.Encode("https://server")));
        html.Should().Contain(HtmlEncoder.Default.Encode("https://client2/signout?sid=" + sid + "&iss=" + UrlEncoder.Default.Encode("https://server")));
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task signout_callback_should_use_signoutcleanup_for_wsfed_client()
    {
        await _mockPipeline.LoginAsync("bob");
        var sid = _mockPipeline.GetSessionCookie().Value;

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client4",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client4/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        var signoutFrameUrl = _mockPipeline.LogoutRequest.SignOutIFrameUrl;

        // since we don't have real ws-fed, we used OIDC to signin, but fooling this
        // at signout to use ws-fed so we can test the iframe params
        _wsfedClient.ProtocolType = ProtocolTypes.WsFederation;

        response = await _mockPipeline.BrowserClient.GetAsync(signoutFrameUrl);
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Contain("https://client4/signout?wa=wsignoutcleanup1.0");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task valid_id_token_hint_but_no_post_logout_redirect_uri_should_not_use_single_registered_post_logout_redirect_uri()
    {
        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint + 
            "?id_token_hint=" + id_token);

        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task valid_id_token_hint_but_no_post_logout_redirect_uri_should_not_use_any_of_multiple_registered_post_logout_redirect_uri()
    {
        await _mockPipeline.LoginAsync("bob");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);
        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        var id_token = authorization.IdentityToken;

        _mockPipeline.BrowserClient.AllowAutoRedirect = true;
        response = await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint +
            "?id_token_hint=" + id_token);

        _mockPipeline.LogoutRequest.PostLogoutRedirectUri.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task logout_with_clients_should_render_signout_callback_iframe()
    {
        await _mockPipeline.LoginAsync("bob");

        var response = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId: "client2",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client2/callback",
            state: "123_state",
            nonce: "123_nonce");
        response.Should().NotBeNull();

        await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
        _mockPipeline.LogoutRequest.SignOutIFrameUrl.Should().NotBeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task logout_without_clients_should_not_render_signout_callback_iframe()
    {
        await _mockPipeline.LoginAsync("bob");

        await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        _mockPipeline.LogoutWasCalled.Should().BeTrue();
        _mockPipeline.LogoutRequest.SignOutIFrameUrl.Should().BeNull();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task logout_should_invoke_back_channel_logout()
    {
        _mockPipeline.BackChannelMessageHandler.OnInvoke = async req =>
        {
            req.RequestUri.ToString().Should().StartWith("https://client3/signout");

            var form = await req.Content.ReadAsStringAsync();
            form.Should().Contain(OidcConstants.BackChannelLogoutRequest.LogoutToken);

            var token = form.Split('=')[1];
            var parts = token.Split('.');
            parts.Length.Should().Be(3);

            var bytes = Base64Url.Decode(parts[1]);
            var json = Encoding.UTF8.GetString(bytes);
            var payload = JObject.Parse(json);
            payload["iss"].ToString().Should().Be("https://server");
            payload["sub"].ToString().Should().Be("bob");
            payload["aud"].ToString().Should().Be("client3");
            payload["iat"].Should().NotBeNull();
            payload["jti"].Should().NotBeNull();
            payload["sid"].Should().NotBeNull();
            payload["events"].Type.Should().Be(JTokenType.Object);

            var events = (JObject)payload["events"];
            events.Count.Should().Be(1);
            events["http://schemas.openid.net/event/backchannel-logout"].Should().NotBeNull();
            events["http://schemas.openid.net/event/backchannel-logout"].Type.Should().Be(JTokenType.Object);

            var evt = (JObject)events["http://schemas.openid.net/event/backchannel-logout"];
            evt.Count.Should().Be(0);
        };

        await _mockPipeline.LoginAsync("bob");

        var response = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce");
        response.Should().NotBeNull();

        await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        _mockPipeline.BackChannelMessageHandler.InvokeWasCalled.Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task back_channel_logout_should_not_affect_end_session_callback()
    {
        _mockPipeline.BackChannelMessageHandler.OnInvoke = req => throw new Exception("boom!");

        await _mockPipeline.LoginAsync("bob");

        var response = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId: "client3",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client3/callback",
            state: "123_state",
            nonce: "123_nonce");
        response.Should().NotBeNull();

        await _mockPipeline.BrowserClient.GetAsync(IdentityServerPipeline.EndSessionEndpoint);

        _mockPipeline.BackChannelMessageHandler.InvokeWasCalled.Should().BeTrue();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Introspection/IntrospectionTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Text.Json;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Endpoints.Introspection.Setup;
using IdentityServer8.Extensions;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.TestHost;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Introspection;

public class IntrospectionTests
{
    private const string Category = "Introspection endpoint";
    private const string IntrospectionEndpoint = "https://server/connect/introspect";
    private const string TokenEndpoint = "https://server/connect/token";

    private readonly HttpClient _client;
    private readonly HttpMessageHandler _handler;

    public IntrospectionTests()
    {
        var builder = new WebHostBuilder()
            .UseStartup();
        var server = new TestServer(builder);

        _handler = server.CreateHandler();
        _client = server.CreateClient();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Empty_request_should_fail()
    {
        var form = new Dictionary();

        var response = await _client.PostAsync(IntrospectionEndpoint, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Unknown_scope_should_fail()
    {
        var form = new Dictionary();

        _client.SetBasicAuthentication("unknown", "invalid");
        var response = await _client.PostAsync(IntrospectionEndpoint, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_scope_secret_should_fail()
    {
        var form = new Dictionary();

        _client.SetBasicAuthentication("api1", "invalid");
        var response = await _client.PostAsync(IntrospectionEndpoint, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.Unauthorized);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Missing_token_should_fail()
    {
        var form = new Dictionary();

        _client.SetBasicAuthentication("api1", "secret");
        var response = await _client.PostAsync(IntrospectionEndpoint, new FormUrlEncodedContent(form));

        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_token_should_fail()
    {
        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api1",
            ClientSecret = "secret",

            Token = "invalid"
        });

        introspectionResponse.IsActive.Should().Be(false);
        introspectionResponse.IsError.Should().Be(false);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_Content_type_should_fail()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",
            Scope = "api1"
        });

        var data = new
        {
            client_id = "api1",
            client_secret = "secret",
            token = tokenResponse.AccessToken
        };
        var json = JsonSerializer.Serialize(data);

        var client = new HttpClient(_handler);
        var response = await client.PostAsync(IntrospectionEndpoint, new StringContent(json, Encoding.UTF8, "application/json"));
        response.StatusCode.Should().Be(HttpStatusCode.UnsupportedMediaType);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Valid_token_and_valid_scope_should_succeed()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",
            Scope = "api1"
        });

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api1",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        introspectionResponse.IsActive.Should().Be(true);
        introspectionResponse.IsError.Should().Be(false);

        var scopes = from c in introspectionResponse.Claims
                     where c.Type == "scope"
                     select c;

        scopes.Count().Should().Be(1);
        scopes.First().Value.Should().Be("api1");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Response_data_should_be_valid_using_single_scope()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",
            Scope = "api1"
        });

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api1",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        var values = introspectionResponse.Json.ToObject>();

        values["aud"].ValueKind.Should().Be(JsonValueKind.String);
        values["iss"].ValueKind.Should().Be(JsonValueKind.String);
        values["nbf"].ValueKind.Should().Be(JsonValueKind.Number); 
        values["exp"].ValueKind.Should().Be(JsonValueKind.Number); 
        values["client_id"].ValueKind.Should().Be(JsonValueKind.String);
        values["active"].ValueKind.Should().Be(JsonValueKind.True); 
        values["scope"].ValueKind.Should().Be(JsonValueKind.String);

        values["scope"].ToString().Should().Be("api1");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Response_data_with_user_authentication_should_be_valid_using_single_scope()
    {
        var tokenResponse = await _client.RequestPasswordTokenAsync(new PasswordTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "ro.client",
            ClientSecret = "secret",
            UserName = "bob",
            Password = "bob",

            Scope = "api1",
        });

        tokenResponse.IsError.Should().BeFalse();

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api1",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        var values = introspectionResponse.Json.ToObject>();

        values["aud"].ValueKind.Should().Be(JsonValueKind.String);
        values["iss"].ValueKind.Should().Be(JsonValueKind.String);
        values["nbf"].ValueKind.Should().Be(JsonValueKind.Number); 
        values["exp"].ValueKind.Should().Be(JsonValueKind.Number); 
        values["auth_time"].ValueKind.Should().Be(JsonValueKind.Number); 
        values["client_id"].ValueKind.Should().Be(JsonValueKind.String);
        values["sub"].ValueKind.Should().Be(JsonValueKind.String);
        values["active"].ValueKind.Should().Be(JsonValueKind.True); 
        values["scope"].ValueKind.Should().Be(JsonValueKind.String);

        values["scope"].ToString().Should().Be("api1");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Response_data_should_be_valid_using_multiple_scopes_multiple_audiences()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",

            Scope = "api2 api3-a api3-b",
        });

        tokenResponse.IsError.Should().BeFalse();

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api3",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        var values = introspectionResponse.Json.ToObject>();


        values["aud"].GetType().Name.Should().Be("JsonElement");
        values["aud"].ValueKind.Should().Be(JsonValueKind.Array);

        // Access the 'aud' array
        var audiences = values["aud"].EnumerateArray();
        foreach (var aud in audiences)
        {
            // Check each audience value to ensure it's a string
            aud.ValueKind.Should().Be(JsonValueKind.String);
        }

        values["iss"].ValueKind.Should().Be(JsonValueKind.String);
        values["iss"].ValueKind.Should().Be(JsonValueKind.String);
        values["nbf"].ValueKind.Should().Be(JsonValueKind.Number);
        values["exp"].ValueKind.Should().Be(JsonValueKind.Number);
        values["client_id"].ValueKind.Should().Be(JsonValueKind.String);
        var activeKind= values["active"].ValueKind;
        values["active"].ValueKind.Should().Be(JsonValueKind.True);
        values["scope"].ValueKind.Should().Be(JsonValueKind.String);

        var scopes = values["scope"].ToString();
        scopes.Should().Be("api3-a api3-b");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Response_data_should_be_valid_using_multiple_scopes_single_audience()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",

            Scope = "api3-a api3-b",
        });

        tokenResponse.IsError.Should().BeFalse();

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api3",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        var values = introspectionResponse.Json.ToObject>();
        values["aud"].ValueKind.Should().Be(JsonValueKind.String);
        values["aud"].ValueKind.Should().Be(JsonValueKind.String);
        values["iss"].ValueKind.Should().Be(JsonValueKind.String); 
        values["nbf"].ValueKind.Should().Be(JsonValueKind.Number);  
        values["exp"].ValueKind.Should().Be(JsonValueKind.Number);  
        values["client_id"].ValueKind.Should().Be(JsonValueKind.String); 
        values["active"].ValueKind.Should().Be(JsonValueKind.True); 
        values["scope"].ValueKind.Should().Be(JsonValueKind.String);

        var scopes = values["scope"].ToString();
        scopes.Should().Be("api3-a api3-b");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Token_with_many_scopes_but_api_should_only_see_its_own_scopes()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client3",
            ClientSecret = "secret",

            Scope = "api1 api2 api3-a",
        });

        tokenResponse.IsError.Should().BeFalse();

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api3",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        introspectionResponse.IsActive.Should().BeTrue();
        introspectionResponse.IsError.Should().BeFalse();

        var scopes = from c in introspectionResponse.Claims
                     where c.Type == "scope"
                     select c.Value;

        scopes.Count().Should().Be(1);
        scopes.First().Should().Be("api3-a");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Valid_token_with_valid_multiple_scopes()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",

            Scope = "api1 api2",
        });

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api1",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        introspectionResponse.IsActive.Should().Be(true);
        introspectionResponse.IsError.Should().Be(false);

        var scopes = from c in introspectionResponse.Claims
                     where c.Type == "scope"
                     select c;

        scopes.Count().Should().Be(1);
        scopes.First().Value.Should().Be("api1");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Valid_token_with_invalid_scopes_should_fail()
    {
        var tokenResponse = await _client.RequestClientCredentialsTokenAsync(new ClientCredentialsTokenRequest
        {
            Address = TokenEndpoint,
            ClientId = "client1",
            ClientSecret = "secret",

            Scope = "api1",
        });

        var introspectionResponse = await _client.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IntrospectionEndpoint,
            ClientId = "api2",
            ClientSecret = "secret",

            Token = tokenResponse.AccessToken
        });

        introspectionResponse.IsActive.Should().Be(false);
        introspectionResponse.IsError.Should().Be(false);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Introspection/Setup/Clients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8.Models;

namespace IdentityServer.IntegrationTests.Endpoints.Introspection.Setup;

internal class Clients
{
    public static IEnumerable Get()
    {
        return new List
        {
            new Client
            {
                ClientId = "client1",
                ClientSecrets = new List
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "api1", "api2", "api3-a", "api3-b" },
                AccessTokenType = AccessTokenType.Reference
            },
            new Client
            {
                ClientId = "client2",
                ClientSecrets = new List
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "api1", "api2", "api3-a", "api3-b" },
                AccessTokenType = AccessTokenType.Reference
            },
            new Client
            {
                ClientId = "client3",
                ClientSecrets = new List
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "api1", "api2", "api3-a", "api3-b" },
                AccessTokenType = AccessTokenType.Reference
            },
            new Client
            {
                ClientId = "ro.client",
                ClientSecrets = new List
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                AllowedScopes = { "api1", "api2", "api3-a", "api3-b" },
                AccessTokenType = AccessTokenType.Reference
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Introspection/Setup/Scopes.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8.Models;

namespace IdentityServer.IntegrationTests.Endpoints.Introspection.Setup;

internal class Scopes
{
    public static IEnumerable GetApis()
    {
        return new ApiResource[]
        {
            new ApiResource
            {
                Name = "api1",
                ApiSecrets = new List
                {
                    new Secret("secret".Sha256())
                },
                Scopes = { "api1" }
            },
            new ApiResource
            {
                Name = "api2",
                ApiSecrets = new List
                {
                    new Secret("secret".Sha256())
                },
                Scopes = { "api2" }
            },
             new ApiResource
            {
                Name = "api3",
                ApiSecrets = new List
                {
                    new Secret("secret".Sha256())
                },
                Scopes = { "api3-a", "api3-b" }
            }
        };
    }
    public static IEnumerable GetScopes()
    {
        return new ApiScope[]
        {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            },
            new ApiScope
            {
                Name = "api3-a"
            },
            new ApiScope
            {
                Name = "api3-b"
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Introspection/Setup/Startup.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

namespace IdentityServer.IntegrationTests.Endpoints.Introspection.Setup;

public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        var builder = services.AddIdentityServer(options =>
        {
            options.IssuerUri = "https://idsvr8";
            options.Endpoints.EnableAuthorizeEndpoint = false;
        });

        builder.AddInMemoryClients(Clients.Get());
        builder.AddInMemoryApiResources(Scopes.GetApis());
        builder.AddInMemoryApiScopes(Scopes.GetScopes());
        builder.AddTestUsers(Users.Get());
        builder.AddDeveloperSigningCredential(persistKey: false);
    }

    public void Configure(IApplicationBuilder app, ILoggerFactory loggerFactory)
    {
        app.UseIdentityServer();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Introspection/Setup/Users.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8.Test;

namespace IdentityServer.IntegrationTests.Endpoints.Introspection.Setup;

public static class Users
{
    public static List Get()
    {
        return new List
        {
            new TestUser
            {
                SubjectId = "1",
                Username = "bob",
                Password = "bob"
            }
        };
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Revocation/RevocationTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Revocation;

public class RevocationTests
{
    private const string Category = "RevocationTests endpoint";

    private string client_id = "client";
    private string client_secret = "secret";
    private string redirect_uri = "https://client/callback";

    private string scope_name = "api";
    private string scope_secret = "api_secret";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public RevocationTests()
    {
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = client_id,
            ClientSecrets = new List { new Secret(client_secret.Sha256()) },
            AllowedGrantTypes = GrantTypes.Code,
            RequireConsent = false,
            RequirePkce = false,
            AllowOfflineAccess = true,
            AllowedScopes = new List { "api" },
            RedirectUris = new List { redirect_uri },
            AllowAccessTokensViaBrowser = true,
            AccessTokenType = AccessTokenType.Reference,
            RefreshTokenUsage = TokenUsage.ReUse
        });
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "implicit",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "api" },
            RedirectUris = new List { redirect_uri },
            AllowAccessTokensViaBrowser = true,
            AccessTokenType = AccessTokenType.Reference
        });
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "implicit_and_client_creds",
            AllowedGrantTypes = GrantTypes.ImplicitAndClientCredentials,
            ClientSecrets = { new Secret("secret".Sha256()) },
            RequireConsent = false,
            AllowedScopes = new List { "api" },
            RedirectUris = new List { redirect_uri },
            AllowAccessTokensViaBrowser = true,
            AccessTokenType = AccessTokenType.Reference
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                ApiSecrets = new List { new Secret(scope_secret.Sha256()) },
                Scopes = { scope_name }
            }
        });

        _mockPipeline.ApiScopes.AddRange(new ApiScope[]
        {
            new ApiScope
            {
                Name = scope_name
            }
        });

        _mockPipeline.Initialize();
    }

    private class Tokens
    {
        public Tokens(TokenResponse response)
        {
            AccessToken = response.AccessToken;
            RefreshToken = response.RefreshToken;
        }

        public string AccessToken { get; set; }
        public string RefreshToken { get; set; }
    }

    private async Task GetTokensAsync()
    {
        await _mockPipeline.LoginAsync("bob");

        var authorizationResponse = await _mockPipeline.RequestAuthorizationEndpointAsync(
            client_id,
            "code",
            "api offline_access",
            "https://client/callback");

        authorizationResponse.IsError.Should().BeFalse();
        authorizationResponse.Code.Should().NotBeNull();

        var tokenResponse = await _mockPipeline.BackChannelClient.RequestAuthorizationCodeTokenAsync(new AuthorizationCodeTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Code = authorizationResponse.Code,
            RedirectUri = redirect_uri
        });

        tokenResponse.IsError.Should().BeFalse();
        tokenResponse.AccessToken.Should().NotBeNull();
        tokenResponse.RefreshToken.Should().NotBeNull();

        return new Tokens(tokenResponse);
    }

    private async Task GetAccessTokenForImplicitClientAsync(string clientId)
    {
        await _mockPipeline.LoginAsync("bob");

        var authorizationResponse = await _mockPipeline.RequestAuthorizationEndpointAsync(
            clientId,
            "token",
            "api",
            "https://client/callback");

        authorizationResponse.IsError.Should().BeFalse();
        authorizationResponse.AccessToken.Should().NotBeNull();

        return authorizationResponse.AccessToken;
    }

    private Task IsAccessTokenValidAsync(Tokens tokens)
    {
        return IsAccessTokenValidAsync(tokens.AccessToken);
    }

    private async Task IsAccessTokenValidAsync(string token)
    {
        var response = await _mockPipeline.BackChannelClient.IntrospectTokenAsync(new TokenIntrospectionRequest
        {
            Address = IdentityServerPipeline.IntrospectionEndpoint,
            ClientId = scope_name,
            ClientSecret = scope_secret,

            Token = token,
            TokenTypeHint = IdentityModel.OidcConstants.TokenTypes.AccessToken
        });

        return response.IsError == false && response.IsActive;
    }

    private async Task UseRefreshTokenAsync(Tokens tokens)
    {
        var response = await _mockPipeline.BackChannelClient.RequestRefreshTokenAsync(new RefreshTokenRequest
        {
            Address = IdentityServerPipeline.TokenEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            RefreshToken = tokens.RefreshToken
        });

        if (response.IsError)
        {
            return false;
        }

        tokens.AccessToken = response.AccessToken;
        return true;
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Get_request_should_return_405()
    {
        var response = await _mockPipeline.BackChannelClient.GetAsync(IdentityServerPipeline.RevocationEndpoint);

        response.StatusCode.Should().Be(HttpStatusCode.MethodNotAllowed);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Post_without_form_urlencoded_should_return_415()
    {
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, null);

        response.StatusCode.Should().Be(HttpStatusCode.UnsupportedMediaType);
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_valid_access_token_should_return_success()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeFalse();
        (await IsAccessTokenValidAsync(tokens)).Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_valid_access_token_belonging_to_another_client_should_return_success_but_not_revoke_token()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = "implicit",
            ClientSecret = client_secret,

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeFalse();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_valid_refresh_token_should_return_success()
    {
        var tokens = await GetTokensAsync();
        (await UseRefreshTokenAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.RefreshToken
        });

        result.IsError.Should().BeFalse();

        (await UseRefreshTokenAsync(tokens)).Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_valid_refresh_token_belonging_to_another_client_should_return_success_but_not_revoke_token()
    {
        var tokens = await GetTokensAsync();
        (await UseRefreshTokenAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = "implicit",
            ClientSecret = client_secret,

            Token = tokens.RefreshToken
        });

        result.IsError.Should().BeFalse();

        (await UseRefreshTokenAsync(tokens)).Should().BeTrue();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_invalid_access_token_should_return_success()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeFalse();

        (await IsAccessTokenValidAsync(tokens)).Should().BeFalse();

        result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Revoke_invalid_refresh_token_should_return_success()
    {
        var tokens = await GetTokensAsync();
        (await UseRefreshTokenAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.RefreshToken
        });

        result.IsError.Should().BeFalse();

        (await UseRefreshTokenAsync(tokens)).Should().BeFalse();

        result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = client_secret,

            Token = tokens.RefreshToken
        });

        result.IsError.Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_client_id_should_return_error()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = "not_valid",
            ClientSecret = client_secret,

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeTrue();
        result.Error.Should().Be("invalid_client");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_credentials_should_return_error()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var result = await _mockPipeline.BackChannelClient.RevokeTokenAsync(new TokenRevocationRequest
        {
            Address = IdentityServerPipeline.RevocationEndpoint,
            ClientId = client_id,
            ClientSecret = "not_valid",

            Token = tokens.AccessToken
        });

        result.IsError.Should().BeTrue();
        result.Error.Should().Be("invalid_client");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Missing_token_should_return_error()
    {
        var data = new Dictionary
        {
            { "client_id", client_id },
            { "client_secret", client_secret }
        };

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var result = await ProtocolResponse.FromHttpResponseAsync(response);
        result.IsError.Should().BeTrue();
        result.Error.Should().Be("invalid_request");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Invalid_token_type_hint_should_return_error()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var data = new Dictionary
        {
            { "client_id", client_id },
            { "client_secret", client_secret },
            { "token", tokens.AccessToken },
            { "token_type_hint", "not_valid" }
        };

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);

        var result = await ProtocolResponse.FromHttpResponseAsync(response);
        result.IsError.Should().BeTrue();
        result.Error.Should().Be("unsupported_token_type");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Valid_access_token_but_missing_token_type_hint_should_succeed()
    {
        var tokens = await GetTokensAsync();
        (await IsAccessTokenValidAsync(tokens)).Should().BeTrue();

        var data = new Dictionary
        {
            { "client_id", client_id },
            { "client_secret", client_secret },
            { "token", tokens.AccessToken }
        };

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.OK);

        (await IsAccessTokenValidAsync(tokens)).Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Valid_refresh_token_but_missing_token_type_hint_should_succeed()
    {
        var tokens = await GetTokensAsync();
        (await UseRefreshTokenAsync(tokens)).Should().BeTrue();

        var data = new Dictionary
        {
            { "client_id", client_id },
            { "client_secret", client_secret },
            { "token", tokens.RefreshToken }
        };

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.OK);

        (await UseRefreshTokenAsync(tokens)).Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Implicit_client_without_secret_revoking_token_should_succeed()
    {
        var token = await GetAccessTokenForImplicitClientAsync("implicit");

        var data = new Dictionary
        {
            { "client_id", "implicit" },
            { "token", token }
        };

        (await IsAccessTokenValidAsync(token)).Should().BeTrue();

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.OK);
        (await IsAccessTokenValidAsync(token)).Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task Implicit_and_client_creds_client_without_secret_revoking_token_should_fail()
    {
        var token = await GetAccessTokenForImplicitClientAsync("implicit_and_client_creds");

        var data = new Dictionary
        {
            { "client_id", "implicit_and_client_creds" },
            { "token", token }
        };

        (await IsAccessTokenValidAsync(token)).Should().BeTrue();

        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.RevocationEndpoint, new FormUrlEncodedContent(data));
        response.StatusCode.Should().Be(HttpStatusCode.BadRequest);
        (await IsAccessTokenValidAsync(token)).Should().BeTrue();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Endpoints/Token/TokenEndpointTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Newtonsoft.Json.Linq;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer.IntegrationTests.Common;
using Xunit;

namespace IdentityServer.IntegrationTests.Endpoints.Token;

public class TokenEndpointTests
{
    private const string Category = "Token endpoint";

    private string client_id = "client";
    private string client_secret = "secret";

    private string scope_name = "api";
    private string scope_secret = "api_secret";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public TokenEndpointTests()
    {
        _mockPipeline.Clients.Add(new Client
        {
            ClientId = client_id,
            ClientSecrets = new List { new Secret(client_secret.Sha256()) },
            AllowedGrantTypes = { GrantType.ClientCredentials, GrantType.ResourceOwnerPassword },
            AllowedScopes = new List { "api" },
        });


        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Password = "password",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _mockPipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                ApiSecrets = new List { new Secret(scope_secret.Sha256()) },
                Scopes = {scope_name}
            }
        });

        _mockPipeline.ApiScopes.AddRange(new[] {
            new ApiScope
            {
                Name = scope_name
            }
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task client_credentials_request_with_funny_headers_should_not_hang()
    {
        var data = new Dictionary
        {
            { "grant_type", "client_credentials" },
            { "client_id", client_id },
            { "client_secret", client_secret },
            { "scope", scope_name },
        };
        var form = new FormUrlEncodedContent(data);
        _mockPipeline.BackChannelClient.DefaultRequestHeaders.Add("Referer", "http://127.0.0.1:33086/appservice/appservice?t=1564165664142?load");
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.TokenEndpoint, form);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        var json = await response.Content.ReadAsStringAsync();
        var result = JObject.Parse(json);
        result.ContainsKey("error").Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task resource_owner_request_with_funny_headers_should_not_hang()
    {
        var data = new Dictionary
        {
            { "grant_type", "password" },
            { "username", "bob" },
            { "password", "password" },
            { "client_id", client_id },
            { "client_secret", client_secret },
            { "scope", scope_name },
        };
        var form = new FormUrlEncodedContent(data);
        _mockPipeline.BackChannelClient.DefaultRequestHeaders.Add("Referer", "http://127.0.0.1:33086/appservice/appservice?t=1564165664142?load");
        var response = await _mockPipeline.BackChannelClient.PostAsync(IdentityServerPipeline.TokenEndpoint, form);

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        var json = await response.Content.ReadAsStringAsync();
        var result = JObject.Parse(json);
        result.ContainsKey("error").Should().BeFalse();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Extensibility/CustomProfileServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Net;
using System.Security.Claims;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Services;
using Microsoft.Extensions.DependencyInjection;
using Newtonsoft.Json.Linq;
using Xunit;

namespace IdentityServer.IntegrationTests.Extensibility;

public class CustomProfileServiceTests
{
    private const string Category = "Authorize endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    public CustomProfileServiceTests()
    {
        _mockPipeline.OnPostConfigureServices += svcs =>
        {
            svcs.AddTransient();
        };

        _mockPipeline.Clients.Add(new Client
        {
            ClientId = "implicit",
            AllowedGrantTypes = GrantTypes.Implicit,
            RedirectUris = { "https://client/callback" },
            RequireConsent = false,
            AllowedScopes = { "openid", "custom_identity" }
        });

        _mockPipeline.IdentityScopes.Add(new IdentityResources.OpenId());
        _mockPipeline.IdentityScopes.Add(new IdentityResource("custom_identity", new string[] { "foo" }));

        _mockPipeline.Users.Add(new IdentityServer8.Test.TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Password = "password",
        });

        _mockPipeline.Initialize();
    }

    [Fact]
    public async Task custom_profile_should_return_claims_for_implicit_client()
    {
        await _mockPipeline.LoginAsync("bob");

        var url = _mockPipeline.CreateAuthorizeUrl(
            clientId: "implicit",
            responseType: "id_token",
            scope: "openid custom_identity",
            redirectUri: "https://client/callback",
            state: "state",
            nonce: "nonce");

        _mockPipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Headers.Location.ToString().Should().StartWith("https://client/callback");

        var authorization = new IdentityModel.Client.AuthorizeResponse(response.Headers.Location.ToString());
        authorization.IsError.Should().BeFalse();
        authorization.IdentityToken.Should().NotBeNull();

        var payload = authorization.IdentityToken.Split('.')[1];
        var json = Encoding.UTF8.GetString(Base64Url.Decode(payload));
        var obj = JObject.Parse(json);

        obj.GetValue("foo").Should().NotBeNull();
        obj["foo"].ToString().Should().Be("bar");
    }
}

public class CustomProfileService : IProfileService
{
    public Task GetProfileDataAsync(ProfileDataRequestContext context)
    {
        var claims = new Claim[]
        {
            new Claim("foo", "bar")
        };
        context.AddRequestedClaims(claims);
        return Task.CompletedTask;
    }

    public Task IsActiveAsync(IsActiveContext context)
    {
        context.IsActive = true;
        return Task.CompletedTask;
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/IdentityServer.IntegrationTests.csproj
================================================


  
    ../../../../key.snk
    true
    true
  

  
    
    
    
    
    
    
    
    
        runtime; build; native; contentfiles; analyzers; buildtransitive
        all
         
  

  
    
      Always
    
    
      Always
    
    
      PreserveNewest
    
  

  
    
  



================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Pipeline/CorsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Test;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.IntegrationTests.Pipeline;

public class CorsTests
{
    private const string Category = "CORS Integration";

    private IdentityServerPipeline _pipeline = new IdentityServerPipeline();

    public CorsTests()
    {
        _pipeline.Clients.AddRange(new Client[] {
            new Client
            {
                ClientId = "client",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = true,
                AllowedScopes = new List { "openid", "profile", "api1", "api2" },
                RedirectUris = new List { "https://client/callback" },
                AllowedCorsOrigins = new List { "https://client" }
            }
        });

        _pipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _pipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        _pipeline.ApiResources.AddRange(new ApiResource[] {
            new ApiResource
            {
                Name = "api",
                Scopes = { "api1", "api2" }
            }
        });
        _pipeline.ApiScopes.AddRange(new[] {
            new ApiScope
            {
                Name = "api1"
            },
            new ApiScope
            {
                Name = "api2"
            }
        });

        _pipeline.Initialize();
    }

    [Theory]
    [InlineData(IdentityServerPipeline.DiscoveryEndpoint)]
    [InlineData(IdentityServerPipeline.DiscoveryKeysEndpoint)]
    [InlineData(IdentityServerPipeline.TokenEndpoint)]
    [InlineData(IdentityServerPipeline.UserInfoEndpoint)]
    [InlineData(IdentityServerPipeline.RevocationEndpoint)]
    [Trait("Category", Category)]
    public async Task cors_request_to_allowed_endpoints_should_succeed(string url)
    {
        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Origin", "https://client");
        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Access-Control-Request-Method", "GET");
        
        var message = new HttpRequestMessage(HttpMethod.Options, url);
        var response = await _pipeline.BackChannelClient.SendAsync(message);

        response.StatusCode.Should().Be(HttpStatusCode.NoContent);
        response.Headers.Contains("Access-Control-Allow-Origin").Should().BeTrue();
    }

    [Theory]
    [InlineData(IdentityServerPipeline.AuthorizeEndpoint)]
    [InlineData(IdentityServerPipeline.EndSessionEndpoint)]
    [InlineData(IdentityServerPipeline.CheckSessionEndpoint)]
    [InlineData(IdentityServerPipeline.LoginPage)]
    [InlineData(IdentityServerPipeline.ConsentPage)]
    [InlineData(IdentityServerPipeline.ErrorPage)]
    [Trait("Category", Category)]
    public async Task cors_request_to_restricted_endpoints_should_not_succeed(string url)
    {
        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Origin", "https://client");
        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Access-Control-Request-Method", "GET");

        var message = new HttpRequestMessage(HttpMethod.Options, url);
        var response = await _pipeline.BackChannelClient.SendAsync(message);

        response.Headers.Contains("Access-Control-Allow-Origin").Should().BeFalse();
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task custom_cors_policy_provider_should_be_used()
    {
        var policy = new StubCorePolicyProvider();
        _pipeline.OnPreConfigureServices += services =>
        {
            services.AddSingleton(policy);
        };
        _pipeline.Initialize();

        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Origin", "https://client");
        _pipeline.BackChannelClient.DefaultRequestHeaders.Add("Access-Control-Request-Method", "GET");

        var message = new HttpRequestMessage(HttpMethod.Options, IdentityServerPipeline.DiscoveryEndpoint);
        var response = await _pipeline.BackChannelClient.SendAsync(message);

        policy.WasCalled.Should().BeTrue();
    }
}

public class StubCorePolicyProvider : ICorsPolicyService
{
    public bool Result;
    public bool WasCalled;

    public Task IsOriginAllowedAsync(string origin)
    {
        WasCalled = true;
        return Task.FromResult(Result);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Pipeline/FederatedSignoutTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Microsoft.AspNetCore.Authentication;
using Xunit;

namespace IdentityServer.IntegrationTests.Pipeline;

public class FederatedSignoutTests
{
    private const string Category = "Federated Signout";

    private IdentityServerPipeline _pipeline = new IdentityServerPipeline();
    private ClaimsPrincipal _user;

    public FederatedSignoutTests()
    {
        _user = new IdentityServerUser("bob")
        {
            AdditionalClaims = { new Claim(JwtClaimTypes.SessionId, "123") }
        }.CreatePrincipal();

        _pipeline = new IdentityServerPipeline();

        _pipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId()
        });

        _pipeline.Clients.Add(new Client
        {
            ClientId = "client1",
            AllowedGrantTypes = GrantTypes.Implicit,
            RequireConsent = false,
            AllowedScopes = new List { "openid" },
            RedirectUris = new List { "https://client1/callback" },
            FrontChannelLogoutUri = "https://client1/signout",
            PostLogoutRedirectUris = new List { "https://client1/signout-callback" },
            AllowAccessTokensViaBrowser = true
        });

        _pipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
           {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
           }
        });

        _pipeline.Initialize();
    }

    [Fact]
    public async Task valid_request_to_federated_signout_endpoint_should_render_page_with_iframe()
    {
        await _pipeline.LoginAsync(_user);

        await _pipeline.RequestAuthorizationEndpointAsync(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        var response = await _pipeline.BrowserClient.GetAsync(IdentityServerPipeline.FederatedSignOutUrl + "?sid=123");

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.MediaType.Should().Be("text/html");
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Contain("https://server/connect/endsession/callback?endSessionId=");
    }

    [Fact]
    public async Task valid_POST_request_to_federated_signout_endpoint_should_render_page_with_iframe()
    {
        await _pipeline.LoginAsync(_user);

        await _pipeline.RequestAuthorizationEndpointAsync(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        var response = await _pipeline.BrowserClient.PostAsync(IdentityServerPipeline.FederatedSignOutUrl, new FormUrlEncodedContent(new Dictionary { { "sid", "123" } }));

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.MediaType.Should().Be("text/html");
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Contain("https://server/connect/endsession/callback?endSessionId=");
    }

    [Fact]
    public async Task no_clients_signed_into_should_not_render_page_with_iframe()
    {
        await _pipeline.LoginAsync(_user);

        var response = await _pipeline.BrowserClient.GetAsync(IdentityServerPipeline.FederatedSignOutUrl + "?sid=123");

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.Should().BeNull();
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Be(String.Empty);
    }

    [Fact]
    public async Task no_authenticated_user_should_not_render_page_with_iframe()
    {
        var response = await _pipeline.BrowserClient.GetAsync(IdentityServerPipeline.FederatedSignOutUrl + "?sid=123");

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.Should().BeNull();
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Be(String.Empty);
    }

    [Fact]
    public async Task user_not_signed_out_should_not_render_page_with_iframe()
    {
        _pipeline.OnFederatedSignout = ctx =>
        {
            return Task.FromResult(true);
        };

        await _pipeline.LoginAsync(_user);

        await _pipeline.RequestAuthorizationEndpointAsync(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        var response = await _pipeline.BrowserClient.GetAsync(IdentityServerPipeline.FederatedSignOutUrl + "?sid=123");

        response.StatusCode.Should().Be(HttpStatusCode.OK);
        response.Content.Headers.ContentType.Should().BeNull();
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Be(String.Empty);
    }

    [Fact]
    public async Task non_200_should_not_render_page_with_iframe()
    {
        _pipeline.OnFederatedSignout = async ctx =>
        {
            await ctx.SignOutAsync(); // even if we signout, we should not see iframes
            ctx.Response.Redirect("http://foo");
            return true;
        };

        await _pipeline.LoginAsync(_user);

        await _pipeline.RequestAuthorizationEndpointAsync(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");

        _pipeline.BrowserClient.AllowAutoRedirect = false;
        var response = await _pipeline.BrowserClient.GetAsync(IdentityServerPipeline.FederatedSignOutUrl + "?sid=123");

        response.StatusCode.Should().Be(HttpStatusCode.Redirect);
        response.Content.Headers.ContentType.Should().BeNull();
        var html = await response.Content.ReadAsStringAsync();
        html.Should().Be(String.Empty);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/Pipeline/SubpathHosting.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel.Client;
using IdentityServer.IntegrationTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Test;
using Xunit;

namespace IdentityServer.IntegrationTests.Pipeline;

public class SubpathHosting
{
    private const string Category = "Subpath endpoint";

    private IdentityServerPipeline _mockPipeline = new IdentityServerPipeline();

    private Client _client1;

    public SubpathHosting()
    {
        _mockPipeline.Clients.AddRange(new Client[] {
            _client1 = new Client
            {
                ClientId = "client1",
                AllowedGrantTypes = GrantTypes.Implicit,
                RequireConsent = false,
                AllowedScopes = new List { "openid", "profile" },
                RedirectUris = new List { "https://client1/callback" },
                AllowAccessTokensViaBrowser = true
            }
        });

        _mockPipeline.Users.Add(new TestUser
        {
            SubjectId = "bob",
            Username = "bob",
            Claims = new Claim[]
            {
                new Claim("name", "Bob Loblaw"),
                new Claim("email", "bob@loblaw.com"),
                new Claim("role", "Attorney")
            }
        });

        _mockPipeline.IdentityScopes.AddRange(new IdentityResource[] {
            new IdentityResources.OpenId(),
            new IdentityResources.Profile(),
            new IdentityResources.Email()
        });
        
        _mockPipeline.Initialize("/subpath");
    }

    [Fact]
    [Trait("Category", Category)]
    public async Task anonymous_user_should_be_redirected_to_login_page()
    {
        var url = new RequestUrl("https://server/subpath/connect/authorize").CreateAuthorizeUrl(
            clientId: "client1",
            responseType: "id_token",
            scope: "openid",
            redirectUri: "https://client1/callback",
            state: "123_state",
            nonce: "123_nonce");
        var response = await _mockPipeline.BrowserClient.GetAsync(url);

        _mockPipeline.LoginWasCalled.Should().BeTrue();
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/identityserver_testing.cer
================================================
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgAwIBAgIQO+9qzaJY9I5Ewq81kNEKWTANBgkqhkiG9w0BAQsFADAh
MR8wHQYDVQQDDBZpZGVudGl0eXNlcnZlcl90ZXN0aW5nMCAXDTIwMDEyMjIzMTYz
OFoYDzIxMDMwNTIyMjMyNjM5WjAhMR8wHQYDVQQDDBZpZGVudGl0eXNlcnZlcl90
ZXN0aW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuyZQvE+6gEoB
a+LV3dxjk/Xj4DRJ/tefQKR2AZoYAAfKN4ditFmEfRC1A6rckBpMVihTeb1kwwQT
7H4HTS6O/ERHVjOdghoOjEsVakWhAkvh8gphC4IU0upXlYqMh2WzgXEXwYRFB9Tk
7zoHb1/zjEEAhCf2Xbi6YslBoU71bFWyAaeOTl859wV6WaiBIK5L8nJUaIaq4zmC
k8caPZq5E867mZiMdL4TcW9/YoAAO96Wa/W9o6OiuZrP414TlEjVuccpLXvjk0hB
U5OZD2bTvD3MQZu1n1QMLwXfaOBrcv1/RqYJkK7vpP6Pp1YYlo7b2PBDVAIrRSVT
laViBP0owQIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYB
BQUHAwIGCCsGAQUFBwMBMCEGA1UdEQQaMBiCFmlkZW50aXR5c2VydmVyX3Rlc3Rp
bmcwHQYDVR0OBBYEFCVXNpKp8QlHywXEBFfpXxWcOMcsMA0GCSqGSIb3DQEBCwUA
A4IBAQBsEAzwyN6V6N5ggN9G1O0ZpviSjixGkWtySNCBjbGXAhOvfW4M3ysNkDwZ
ltk/Q17ihZzw135MrDCmnr5pRiN4CbEGbe1qsb+Z0uCCn8/WcIVYYooW66H/Jez+
dg5RxUukA67ZDnjzRskIer7L2t1C4pDqpvPVcneUxkiYDSgcKpTuCVjkPNQKQTIw
Sm98NkQG8G8V8+ENIU837ytkiC5nqQa4zDRHexzWrYhiuayWWxJKcNRVF9YaE8ts
vp5N1ewmWbSgF8caJuKraVOISj9R4iqf0XuhfSpW/7eIWYmXfqy/UloeqlALfP5C
2d2FdDSfsQ4Jgc3ebrECAQaCC3Gq
-----END CERTIFICATE-----


================================================
FILE: src/IdentityServer8/test/IdentityServer.IntegrationTests/xunit.runner.json
================================================
{
  "methodDisplay":"classAndMethod"
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/IAuthenticationSchemeHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer.UnitTests.Common
{
    internal interface IAuthenticationSchemeHandler
    {
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockAuthenticationHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;

namespace IdentityServer.UnitTests.Common
{
    internal class MockAuthenticationHandler : IAuthenticationHandler
    {
        public AuthenticateResult Result { get; set; } = AuthenticateResult.NoResult();

        public Task AuthenticateAsync()
        {
            return Task.FromResult(Result);
        }

        public Task ChallengeAsync(AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }

        public Task ForbidAsync(AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }

        public Task InitializeAsync(AuthenticationScheme scheme, HttpContext context)
        {
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockAuthenticationHandlerProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;

namespace IdentityServer.UnitTests.Common
{
    internal class MockAuthenticationHandlerProvider : IAuthenticationHandlerProvider
    {
        public IAuthenticationHandler Handler { get; set; }

        public Task GetHandlerAsync(HttpContext context, string authenticationScheme)
        {
            return Task.FromResult(Handler);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockAuthenticationSchemeProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;

namespace IdentityServer.UnitTests.Common
{
    internal class MockAuthenticationSchemeProvider : IAuthenticationSchemeProvider
    {
        public string Default { get; set; } = "scheme";
        public List Schemes { get; set; } = new List()
        {
            new AuthenticationScheme("scheme", null, typeof(MockAuthenticationHandler))
        };

        public void AddScheme(AuthenticationScheme scheme)
        {
            Schemes.Add(scheme);
        }

        public Task> GetAllSchemesAsync()
        {
            return Task.FromResult(Schemes.AsEnumerable());
        }

        public Task GetDefaultAuthenticateSchemeAsync()
        {
            var scheme = Schemes.Where(x => x.Name == Default).FirstOrDefault();
            return Task.FromResult(scheme);
        }

        public Task GetDefaultChallengeSchemeAsync()
        {
            return GetDefaultAuthenticateSchemeAsync();
        }

        public Task GetDefaultForbidSchemeAsync()
        {
            return GetDefaultAuthenticateSchemeAsync();
        }

        public Task GetDefaultSignInSchemeAsync()
        {
            return GetDefaultAuthenticateSchemeAsync();
        }

        public Task GetDefaultSignOutSchemeAsync()
        {
            return GetDefaultAuthenticateSchemeAsync();
        }

        public Task> GetRequestHandlerSchemesAsync()
        {
            return Task.FromResult(Schemes.AsEnumerable());
        }

        public Task GetSchemeAsync(string name)
        {
            return Task.FromResult(Schemes.Where(x => x.Name == name).FirstOrDefault());
        }

        public void RemoveScheme(string name)
        {
            var scheme = Schemes.Where(x => x.Name == name).FirstOrDefault();
            if (scheme != null)
            {
                Schemes.Remove(scheme);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockAuthenticationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;

namespace IdentityServer.UnitTests.Common
{
    internal class MockAuthenticationService : IAuthenticationService
    {
        public AuthenticateResult Result { get; set; }

        public Task AuthenticateAsync(HttpContext context, string scheme)
        {
            return Task.FromResult(Result);
        }

        public Task ChallengeAsync(HttpContext context, string scheme, AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }

        public Task ForbidAsync(HttpContext context, string scheme, AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }

        public Task SignInAsync(HttpContext context, string scheme, ClaimsPrincipal principal, AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }

        public Task SignOutAsync(HttpContext context, string scheme, AuthenticationProperties properties)
        {
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockClaimsService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Services;
using IdentityServer8.Validation;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    class MockClaimsService : IClaimsService
    {
        public List IdentityTokenClaims { get; set; } = new List();
        public List AccessTokenClaims { get; set; } = new List();

        public Task> GetIdentityTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resources, bool includeAllIdentityClaims, ValidatedRequest request)
        {
            return Task.FromResult(IdentityTokenClaims.AsEnumerable());
        }

        public Task> GetAccessTokenClaimsAsync(ClaimsPrincipal subject, ResourceValidationResult resources, ValidatedRequest request)
        {
            return Task.FromResult(AccessTokenClaims.AsEnumerable());
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockClientSessionService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer.UnitTests.Common
{
    //class MockClientSessionService : IClientSessionService
    //{
    //    public List Clients = new List();

    //    public bool RemoveCookieWasCalled { get; private set; }

    //    public Task AddClientIdAsync(string clientId)
    //    {
    //        Clients.Add(clientId);
    //        return Task.CompletedTask;
    //    }

    //    public Task EnsureClientListCookieAsync(string sid)
    //    {
    //        return Task.CompletedTask;
    //    }

    //    public Task> GetClientListAsync()
    //    {
    //        return Task.FromResult>(Clients);
    //    }

    //    public IEnumerable GetClientListFromCookie(string sid)
    //    {
    //        return Clients;
    //    }

    //    public void RemoveCookie(string sid)
    //    {
    //        RemoveCookieWasCalled = true;
    //        Clients.Clear();
    //    }
    //}
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockConsentMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Stores;

namespace IdentityServer.UnitTests.Common
{
    public class MockConsentMessageStore : IConsentMessageStore
    {
        public Dictionary> Messages { get; set; } = new Dictionary>();

        public Task DeleteAsync(string id)
        {
            if (id != null && Messages.ContainsKey(id))
            {
                Messages.Remove(id);
            }
            return Task.CompletedTask;
        }

        public Task> ReadAsync(string id)
        {
            Message val = null;
            if (id != null)
            {
                Messages.TryGetValue(id, out val);
            }
            return Task.FromResult(val);
        }

        public Task WriteAsync(string id, Message message)
        {
            Messages[id] = message;
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockConsentService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Common
{
    public class MockConsentService : IConsentService
    {
        public bool RequiresConsentResult { get; set; }

        public Task RequiresConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes)
        {
            return Task.FromResult(RequiresConsentResult);
        }

        public ClaimsPrincipal ConsentSubject { get; set; }
        public Client ConsentClient { get; set; }
        public IEnumerable ConsentScopes { get; set; }

        public Task UpdateConsentAsync(ClaimsPrincipal subject, Client client, IEnumerable parsedScopes)
        {
            ConsentSubject = subject;
            ConsentClient = client;
            ConsentScopes = parsedScopes?.Select(x => x.RawValue);

            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockHttpContextAccessor.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Stores;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;

namespace IdentityServer.UnitTests.Common
{
    internal class MockHttpContextAccessor : IHttpContextAccessor
    {
        private HttpContext _context = new DefaultHttpContext();
        public MockAuthenticationService AuthenticationService { get; set; } = new MockAuthenticationService();

        public MockAuthenticationSchemeProvider Schemes { get; set; } = new MockAuthenticationSchemeProvider();

        public MockHttpContextAccessor(
            IdentityServerOptions options = null,
            IUserSession userSession = null,
            IMessageStore endSessionStore = null)
        {
            options = options ?? TestIdentityServerOptions.Create();

            var services = new ServiceCollection();
            services.AddSingleton(options);

            services.AddSingleton(Schemes);
            services.AddSingleton(AuthenticationService);

            services.AddAuthentication(auth =>
            {
                auth.DefaultAuthenticateScheme = Schemes.Default;
            });

            if (userSession == null)
            {
                services.AddScoped();
            }
            else
            {
                services.AddSingleton(userSession);
            }

            if (endSessionStore == null)
            {
                services.AddTransient, ProtectedDataMessageStore>();
            }
            else
            {
                services.AddSingleton(endSessionStore);
            }

            _context.RequestServices = services.BuildServiceProvider();
        }

        public HttpContext HttpContext
        {
            get
            {
                return _context;
            }

            set
            {
                _context = value;
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockKeyMaterialService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Services;
using Microsoft.IdentityModel.Tokens;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    class MockKeyMaterialService : IKeyMaterialService
    {
        public List SigningCredentials = new List();
        public List ValidationKeys = new List();

        public Task> GetAllSigningCredentialsAsync()
        {
            return Task.FromResult(SigningCredentials.AsEnumerable());
        }

        public Task GetSigningCredentialsAsync(IEnumerable allowedAlgorithms = null)
        {
            return Task.FromResult(SigningCredentials.FirstOrDefault());
        }

        public Task> GetValidationKeysAsync()
        {
            return Task.FromResult(ValidationKeys.AsEnumerable());
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockLogoutNotificationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Services;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    public class MockLogoutNotificationService : ILogoutNotificationService
    {
        public bool GetFrontChannelLogoutNotificationsUrlsCalled { get; set; }
        public List FrontChannelLogoutNotificationsUrls { get; set; } = new List();

        public bool SendBackChannelLogoutNotificationsCalled { get; set; }
        public List BackChannelLogoutRequests { get; set; } = new List();

        public Task> GetFrontChannelLogoutNotificationsUrlsAsync(LogoutNotificationContext context)
        {
            GetFrontChannelLogoutNotificationsUrlsCalled = true;
            return Task.FromResult(FrontChannelLogoutNotificationsUrls.AsEnumerable());
        }

        public Task> GetBackChannelLogoutNotificationsAsync(LogoutNotificationContext context)
        {
            SendBackChannelLogoutNotificationsCalled = true;
            return Task.FromResult(BackChannelLogoutRequests.AsEnumerable());
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockMessageStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Stores;

namespace IdentityServer.UnitTests.Common
{
    public class MockMessageStore : IMessageStore
    {
        public Dictionary> Messages { get; set; } = new Dictionary>();

        public Task> ReadAsync(string id)
        {
            Message val = null;
            if (id != null)
            {
                Messages.TryGetValue(id, out val);
            }
            return Task.FromResult(val);
        }

        public Task WriteAsync(Message message)
        {
            var id = Guid.NewGuid().ToString();
            Messages[id] = message;
            return Task.FromResult(id);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockPersistedGrantService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Common
{
    public class MockPersistedGrantService : IPersistedGrantService
    {
        public IEnumerable GetAllGrantsResult { get; set; }
        public bool RemoveAllGrantsWasCalled { get; set; }

        public Task> GetAllGrantsAsync(string subjectId)
        {
            return Task.FromResult(GetAllGrantsResult ?? Enumerable.Empty());
        }

        public Task RemoveAllGrantsAsync(string subjectId, string clientId, string sessionId = null)
        {
            RemoveAllGrantsWasCalled = true;
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Common
{
    public class MockProfileService : IProfileService
    {
        public ICollection ProfileClaims { get; set; } = new HashSet();
        public bool IsActive { get; set; } = true;

        public bool GetProfileWasCalled => ProfileContext != null;
        public ProfileDataRequestContext ProfileContext { get; set; }

        public bool IsActiveWasCalled => ActiveContext != null;
        public IsActiveContext ActiveContext { get; set; }

        public Task GetProfileDataAsync(ProfileDataRequestContext context)
        {
            ProfileContext = context;
            context.IssuedClaims = ProfileClaims.ToList();
            return Task.CompletedTask;
        }

        public Task IsActiveAsync(IsActiveContext context)
        {
            ActiveContext = context;
            context.IsActive = IsActive;
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockReferenceTokenStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Stores;
using System;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    class MockReferenceTokenStore : IReferenceTokenStore
    {
        public Task GetReferenceTokenAsync(string handle)
        {
            throw new NotImplementedException();
        }

        public Task RemoveReferenceTokenAsync(string handle)
        {
            throw new NotImplementedException();
        }

        public Task RemoveReferenceTokensAsync(string subjectId, string clientId)
        {
            throw new NotImplementedException();
        }

        public Task StoreReferenceTokenAsync(Token token)
        {
            throw new NotImplementedException();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockResourceValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Validation;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    class MockResourceValidator : IResourceValidator
    {
        public ResourceValidationResult Result { get; set; } = new ResourceValidationResult();

        public Task> ParseRequestedScopesAsync(IEnumerable scopeValues)
        {
            return Task.FromResult(scopeValues.Select(x => new ParsedScopeValue(x)));
        }

        public Task ValidateRequestedResourcesAsync(ResourceValidationRequest request)
        {
            return Task.FromResult(Result);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockReturnUrlParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Common
{
    public class MockReturnUrlParser : ReturnUrlParser
    {
        public AuthorizationRequest AuthorizationRequestResult { get; set; }
        public bool IsValidReturnUrlResult { get; set; }

        public MockReturnUrlParser() : base(Enumerable.Empty())
        {
        }

        public override Task ParseAsync(string returnUrl)
        {
            return Task.FromResult(AuthorizationRequestResult);
        }

        public override bool IsValidReturnUrl(string returnUrl)
        {
            return IsValidReturnUrlResult;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockSessionIdService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer.UnitTests.Common
{
    //public class MockSessionIdService : ISessionIdService
    //{
    //    public bool RemoveCookieWasCalled { get; private set; }
    //    public string SessionId { get; set; } = "session_id";

    //    public void CreateSessionId(SignInContext context)
    //    {
    //    }

    //    public Task EnsureSessionCookieAsync()
    //    {
    //        return Task.CompletedTask;
    //    }

    //    public string GetCookieName()
    //    {
    //        return "sessionid";
    //    }

    //    public string GetCookieValue()
    //    {
    //        return SessionId;
    //    }

    //    public Task GetCurrentSessionIdAsync()
    //    {
    //        return Task.FromResult(SessionId);
    //    }

    //    public void RemoveCookie()
    //    {
    //        RemoveCookieWasCalled = true;
    //        SessionId = null;
    //    }
    //}
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockSystemClock.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.AspNetCore.Authentication;
using System;

namespace IdentityServer.UnitTests.Common
{
    class MockSystemClock : ISystemClock
    {
        public DateTimeOffset Now { get; set; }

        public DateTimeOffset UtcNow
        {
            get
            {
                return Now;
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockTokenCreationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Services;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    class MockTokenCreationService : ITokenCreationService
    {
        public string Token { get; set; }

        public Task CreateTokenAsync(Token token)
        {
            return Task.FromResult(Token);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/MockUserSession.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Services;
using Microsoft.AspNetCore.Authentication;

namespace IdentityServer.UnitTests.Common
{
    public class MockUserSession : IUserSession
    {
        public List Clients = new List();

        public bool EnsureSessionIdCookieWasCalled { get; set; }
        public bool RemoveSessionIdCookieWasCalled { get; set; }
        public bool CreateSessionIdWasCalled { get; set; }

        public ClaimsPrincipal User { get; set; }
        public string SessionId { get; set; }
        public AuthenticationProperties Properties { get; set; }


        public Task CreateSessionIdAsync(ClaimsPrincipal principal, AuthenticationProperties properties)
        {
            CreateSessionIdWasCalled = true;
            User = principal;
            SessionId = Guid.NewGuid().ToString();
            return Task.FromResult(SessionId);
        }

        public Task GetUserAsync()
        {
            return Task.FromResult(User);
        }

        Task IUserSession.GetSessionIdAsync()
        {
            return Task.FromResult(SessionId);
        }

        public Task EnsureSessionIdCookieAsync()
        {
            EnsureSessionIdCookieWasCalled = true;
            return Task.CompletedTask;
        }

        public Task RemoveSessionIdCookieAsync()
        {
            RemoveSessionIdCookieWasCalled = true;
            return Task.CompletedTask;
        }

        public Task> GetClientListAsync()
        {
            return Task.FromResult>(Clients);
        }

        public Task AddClientIdAsync(string clientId)
        {
            Clients.Add(clientId);
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/NetworkHandler.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Net;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Common
{
    public class NetworkHandler : HttpMessageHandler
    {
        enum Behavior
        {
            Throw,
            ReturnError,
            ReturnDocument
        }

        private readonly Exception _exception;
        private readonly Behavior _behavior;
        private readonly HttpStatusCode _statusCode;
        private readonly string _reason;
        private readonly string _document;
        private readonly Func _selector;
        private readonly Func _action;

        public HttpRequestMessage Request { get; set; }
        public string Body { get; set; }

        public NetworkHandler(Exception exception)
        {
            _exception = exception;
            _behavior = Behavior.Throw;
        }

        public NetworkHandler(HttpStatusCode statusCode, string reason)
        {
            _statusCode = statusCode;
            _reason = reason;

            _behavior = Behavior.ReturnError;
        }

        public NetworkHandler(string document, HttpStatusCode statusCode)
        {
            _statusCode = statusCode;
            _document = document;
            _behavior = Behavior.ReturnDocument;
        }

        public NetworkHandler(Func documentSelector, HttpStatusCode statusCode)
        {
            _statusCode = statusCode;
            _selector = documentSelector;
            _behavior = Behavior.ReturnDocument;
        }

        public NetworkHandler(Func action)
        {
            _action = action;
        }

        protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
        {
            Request = request;
            Body = await SafeReadContentFrom(request);

            if (_action != null)
            {
                return _action(request);
            }

            if (_behavior == Behavior.Throw) throw _exception;

            var response = new HttpResponseMessage(_statusCode);

            if (_behavior == Behavior.ReturnError)
            {
                response.ReasonPhrase = _reason;
            }

            if (_behavior == Behavior.ReturnDocument)
            {
                if (_selector != null)
                {
                    response.Content = new StringContent(_selector(request));
                }
                else
                {
                    response.Content = new StringContent(_document);
                }
            }

            return response;
        }

        private async Task SafeReadContentFrom(HttpRequestMessage request)
        {
            if (request.Content == null) return null;

            return await request.Content.ReadAsStringAsync();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/StubAuthorizeResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Common
{
    internal class StubAuthorizeResponseGenerator : IAuthorizeResponseGenerator
    {
        public AuthorizeResponse Response { get; set; } = new AuthorizeResponse();

        public Task CreateResponseAsync(ValidatedAuthorizeRequest request)
        {
            return Task.FromResult(Response);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/StubClock.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using Microsoft.AspNetCore.Authentication;

namespace IdentityServer.UnitTests.Common
{
    internal class StubClock : ISystemClock
    {
        public Func UtcNowFunc = () => DateTime.UtcNow;
        public DateTimeOffset UtcNow => new DateTimeOffset(UtcNowFunc());
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/StubHandleGenerationService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Common
{
    public class StubHandleGenerationService : DefaultHandleGenerationService, IHandleGenerationService
    {
        public string Handle { get; set; }

        public new Task GenerateAsync(int length)
        {
            if (Handle != null) return Task.FromResult(Handle);
            return base.GenerateAsync(length);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestCert.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Security.Cryptography.X509Certificates;
using Microsoft.IdentityModel.Tokens;

namespace IdentityServer.UnitTests.Common
{
    internal static class TestCert
    {
        public static X509Certificate2 Load()
        {
            var cert = Path.Combine(System.AppContext.BaseDirectory, "identityserver_testing.pfx");
            return new X509Certificate2(cert, "password");
        }

        public static SigningCredentials LoadSigningCredentials()
        {
            var cert = Load();
            return new SigningCredentials(new X509SecurityKey(cert), "RS256");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestEventService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Events;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Common
{
    public class TestEventService : IEventService
    {
        private Dictionary _events = new Dictionary();

        public Task RaiseAsync(Event evt)
        {
            _events.Add(evt.GetType(), evt);
            return Task.CompletedTask;
        }

        public T AssertEventWasRaised()
            where T : class
        {
            _events.ContainsKey(typeof(T)).Should().BeTrue();
            return (T)_events.Where(x => x.Key == typeof(T)).Select(x=>x.Value).First();
        }

        public bool CanRaiseEventType(EventTypes evtType)
        {
            return true;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;

namespace IdentityServer.UnitTests.Common
{
    internal static class TestExtensions
    {
        public static string Repeat(this string value, int count)
        {
            var parts = new string[count];
            return parts.Aggregate((x, y) => (x ?? value) + value);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestIdentityServerOptions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Configuration;

namespace IdentityServer.UnitTests.Common
{
    internal class TestIdentityServerOptions
    {
        public static IdentityServerOptions Create()
        {
            var options = new IdentityServerOptions
            {
                IssuerUri = "https://idsvr.com"
            };

            return options;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestLogger.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.Extensions.Logging;

namespace IdentityServer.UnitTests.Common
{
    public static class TestLogger
    {
        public static ILogger Create()
        {
            return new LoggerFactory().CreateLogger();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Common/TestUserConsentStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Serialization;

namespace IdentityServer.UnitTests.Common
{
    public class TestUserConsentStore : IUserConsentStore
    {
        private DefaultUserConsentStore _userConsentStore;
        private InMemoryPersistedGrantStore _grantStore = new InMemoryPersistedGrantStore();

        public TestUserConsentStore()
        {
            _userConsentStore = new DefaultUserConsentStore(
               _grantStore,
               new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
               TestLogger.Create());
        }

        public Task StoreUserConsentAsync(Consent consent)
        {
            return _userConsentStore.StoreUserConsentAsync(consent);
        }

        public Task GetUserConsentAsync(string subjectId, string clientId)
        {
            return _userConsentStore.GetUserConsentAsync(subjectId, clientId);
        }

        public Task RemoveUserConsentAsync(string subjectId, string clientId)
        {
            return _userConsentStore.RemoveUserConsentAsync(subjectId, clientId);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Cors/MockCorsPolicyProvider.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using Microsoft.AspNetCore.Cors.Infrastructure;
using Microsoft.AspNetCore.Http;

namespace IdentityServer.UnitTests.Cors
{
    public class MockCorsPolicyProvider : ICorsPolicyProvider
    {
        public bool WasCalled { get; set; }
        public CorsPolicy Response { get; set; }

        public Task GetPolicyAsync(HttpContext context, string policyName)
        {
            WasCalled = true;
            return Task.FromResult(Response);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Cors/MockCorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Cors
{
    public class MockCorsPolicyService : ICorsPolicyService
    {
        public bool WasCalled { get; set; }
        public bool Response { get; set; }

        public Task IsOriginAllowedAsync(string origin)
        {
            WasCalled = true;
            return Task.FromResult(Response);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Cors/PolicyProviderTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Configuration.DependencyInjection;
using IdentityServer8.Hosting;
using IdentityServer8.Services;
using Microsoft.AspNetCore.Cors.Infrastructure;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.UnitTests.Cors
{
    public class PolicyProviderTests
    {
        private const string Category = "PolicyProvider";

        private CorsPolicyProvider _subject;
        private List _allowedPaths = new List();

        private MockCorsPolicyProvider _mockInner = new MockCorsPolicyProvider();
        private MockCorsPolicyService _mockPolicy = new MockCorsPolicyService();
        private IdentityServerOptions _options;

        public PolicyProviderTests()
        {
            Init();
        }

        internal void Init()
        {
            _options = new IdentityServerOptions();
            _options.Cors.CorsPaths.Clear();
            foreach(var path in _allowedPaths)
            {
                _options.Cors.CorsPaths.Add(new PathString(path));
            }

            var ctx = new DefaultHttpContext();
            var svcs = new ServiceCollection();
            svcs.AddSingleton(_mockPolicy);
            ctx.RequestServices = svcs.BuildServiceProvider();
            var ctxAccessor = new HttpContextAccessor();
            ctxAccessor.HttpContext = ctx;

            _subject = new CorsPolicyProvider(
                TestLogger.Create(),
                new Decorator(_mockInner),
                _options,
                ctxAccessor);
        }

        [Theory]
        [InlineData("/foo")]
        [InlineData("/bar/")]
        [InlineData("/baz/quux")]
        [InlineData("/baz/quux/")]
        [Trait("Category", Category)]
        public async Task valid_paths_should_call_policy_service(string path)
        {
            _allowedPaths.AddRange(new string[] {
                "/foo",
                "/bar/",
                "/baz/quux",
                "/baz/quux/"
            });
            Init();

            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "https";
            ctx.Request.Host = new HostString("server");
            ctx.Request.Path = new PathString(path);
            ctx.Request.Headers.Append("Origin", "http://notserver");

            var response = await _subject.GetPolicyAsync(ctx, _options.Cors.CorsPolicyName);

            _mockPolicy.WasCalled.Should().BeTrue();
            _mockInner.WasCalled.Should().BeFalse();
        }

        [Theory]
        [InlineData("/foo/")]
        [InlineData("/xoxo")]
        [InlineData("/xoxo/")]
        [InlineData("/foo/xoxo")]
        [InlineData("/baz/quux/xoxo")]
        [Trait("Category", Category)]
        public async Task invalid_paths_should_not_call_policy_service(string path)
        {
            _allowedPaths.AddRange(new string[] {
                "/foo",
                "/bar",
                "/baz/quux"
            });
            Init();

            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "https";
            ctx.Request.Host = new HostString("server");
            ctx.Request.Path = new PathString(path);
            ctx.Request.Headers.Append("Origin", "http://notserver");

            var response = await _subject.GetPolicyAsync(ctx, _options.Cors.CorsPolicyName);

            _mockPolicy.WasCalled.Should().BeFalse();
            _mockInner.WasCalled.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task different_policy_name_should_call_inner_policy_service()
        {
            _allowedPaths.AddRange(new string[] {
                "/foo",
                "/bar",
                "/baz/quux"
            });
            Init();

            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "https";
            ctx.Request.Host = new HostString("server");
            ctx.Request.Path = new PathString("/foo");
            ctx.Request.Headers.Append("Origin", "http://notserver");

            var response = await _subject.GetPolicyAsync(ctx, "wrong_name");

            _mockPolicy.WasCalled.Should().BeFalse();
            _mockInner.WasCalled.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task origin_same_as_server_should_not_call_policy()
        {
            _allowedPaths.AddRange(new string[] {
                "/foo"
            });
            Init();

            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "https";
            ctx.Request.Host = new HostString("server");
            ctx.Request.Path = new PathString("/foo");
            ctx.Request.Headers.Append("Origin", "https://server");

            var response = await _subject.GetPolicyAsync(ctx, _options.Cors.CorsPolicyName);

            _mockPolicy.WasCalled.Should().BeFalse();
            _mockInner.WasCalled.Should().BeFalse();
        }

        [Theory]
        [InlineData("https://notserver")]
        [InlineData("http://server")]
        [Trait("Category", Category)]
        public async Task origin_not_same_as_server_should_call_policy(string origin)
        {
            _allowedPaths.AddRange(new string[] {
                "/foo"
            });
            Init();

            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "https";
            ctx.Request.Host = new HostString("server");
            ctx.Request.Path = new PathString("/foo");
            ctx.Request.Headers.Append("Origin", origin);

            var response = await _subject.GetPolicyAsync(ctx, _options.Cors.CorsPolicyName);

            _mockPolicy.WasCalled.Should().BeTrue();
            _mockInner.WasCalled.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Authorize/AuthorizeCallbackEndpointTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Authorize
{
    public class AuthorizeCallbackEndpointTests
    {
        private const string Category = "Authorize Endpoint";

        private HttpContext _context;

        private TestEventService _fakeEventService = new TestEventService();

        private ILogger _fakeLogger = TestLogger.Create();

        private IdentityServerOptions _options = new IdentityServerOptions();

        private MockConsentMessageStore _mockUserConsentResponseMessageStore = new MockConsentMessageStore();

        private MockUserSession _mockUserSession = new MockUserSession();

        private NameValueCollection _params = new NameValueCollection();

        private StubAuthorizeRequestValidator _stubAuthorizeRequestValidator = new StubAuthorizeRequestValidator();

        private StubAuthorizeResponseGenerator _stubAuthorizeResponseGenerator = new StubAuthorizeResponseGenerator();

        private StubAuthorizeInteractionResponseGenerator _stubInteractionGenerator = new StubAuthorizeInteractionResponseGenerator();

        private AuthorizeCallbackEndpoint _subject;

        private ClaimsPrincipal _user = new IdentityServerUser("bob").CreatePrincipal();

        private ValidatedAuthorizeRequest _validatedAuthorizeRequest;

        public AuthorizeCallbackEndpointTests()
        {
            Init();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_authorize_after_consent_path_should_return_authorization_result()
        {
            var parameters = new NameValueCollection()
            {
                { "client_id", "client" },
                { "nonce", "some_nonce" },
                { "scope", "api1 api2" }
            };
            var request = new ConsentRequest(parameters, _user.GetSubjectId());
            _mockUserConsentResponseMessageStore.Messages.Add(request.Id, new Message(new ConsentResponse()));

            _mockUserSession.User = _user;

            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _context.Request.QueryString = new QueryString("?" + parameters.ToQueryString());

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_authorize_after_login_path_should_return_authorization_result()
        {
            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _mockUserSession.User = _user;

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_consent_missing_consent_data_should_return_error_page()
        {
            var parameters = new NameValueCollection()
            {
                { "client_id", "client" },
                { "nonce", "some_nonce" },
                { "scope", "api1 api2" }
            };
            var request = new ConsentRequest(parameters, _user.GetSubjectId());
            _mockUserConsentResponseMessageStore.Messages.Add(request.Id, new Message(null));

            _mockUserSession.User = _user;

            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _context.Request.QueryString = new QueryString("?" + parameters.ToQueryString());

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
            ((AuthorizeResult)result).Response.IsError.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_no_consent_message_should_return_redirect_for_consent()
        {
            _stubInteractionGenerator.Response.IsConsent = true;

            var parameters = new NameValueCollection()
            {
                { "client_id", "client" },
                { "nonce", "some_nonce" },
                { "scope", "api1 api2" }
            };
            var request = new ConsentRequest(parameters, _user.GetSubjectId());
            _mockUserConsentResponseMessageStore.Messages.Add(request.Id, null);

            _mockUserSession.User = _user;

            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _context.Request.QueryString = new QueryString("?" + parameters.ToQueryString());

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_post_to_entry_point_should_return_405()
        {
            _context.Request.Method = "POST";

            var result = await _subject.ProcessAsync(_context);

            var statusCode = result as StatusCodeResult;
            statusCode.Should().NotBeNull();
            statusCode.StatusCode.Should().Be(405);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_valid_consent_message_should_cleanup_consent_cookie()
        {
            var parameters = new NameValueCollection()
            {
                { "client_id", "client" },
                { "nonce", "some_nonce" },
                { "scope", "api1 api2" }
            };
            var request = new ConsentRequest(parameters, _user.GetSubjectId());
            _mockUserConsentResponseMessageStore.Messages.Add(request.Id, new Message(new ConsentResponse() { ScopesValuesConsented = new string[] { "api1", "api2" } }));

            _mockUserSession.User = _user;

            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _context.Request.QueryString = new QueryString("?" + parameters.ToQueryString());

            var result = await _subject.ProcessAsync(_context);

            _mockUserConsentResponseMessageStore.Messages.Count.Should().Be(0);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_valid_consent_message_should_return_authorize_result()
        {
            var parameters = new NameValueCollection()
            {
                { "client_id", "client" },
                { "nonce", "some_nonce" },
                { "scope", "api1 api2" }
            };
            var request = new ConsentRequest(parameters, _user.GetSubjectId());
            _mockUserConsentResponseMessageStore.Messages.Add(request.Id, new Message(new ConsentResponse() { ScopesValuesConsented = new string[] { "api1", "api2" } }));

            _mockUserSession.User = _user;

            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize/callback");
            _context.Request.QueryString = new QueryString("?" + parameters.ToQueryString());

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
        }

        internal void Init()
        {
            _context = new MockHttpContextAccessor().HttpContext;

            _validatedAuthorizeRequest = new ValidatedAuthorizeRequest()
            {
                RedirectUri = "http://client/callback",
                State = "123",
                ResponseMode = "fragment",
                ClientId = "client",
                Client = new Client
                {
                    ClientId = "client",
                    ClientName = "Test Client"
                },
                Raw = _params,
                Subject = _user
            };
            _stubAuthorizeResponseGenerator.Response.Request = _validatedAuthorizeRequest;

            _stubAuthorizeRequestValidator.Result = new AuthorizeRequestValidationResult(_validatedAuthorizeRequest);

            _subject = new AuthorizeCallbackEndpoint(
                _fakeEventService,
                _fakeLogger,
                _options,
                _stubAuthorizeRequestValidator,
                _stubInteractionGenerator,
                _stubAuthorizeResponseGenerator,
                _mockUserSession,
                _mockUserConsentResponseMessageStore);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Authorize/AuthorizeEndpointBaseTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Hosting;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Authorize
{
    public class AuthorizeEndpointBaseTests
    {
        private const string Category = "Authorize Endpoint";

        private HttpContext _context;

        private TestEventService _fakeEventService = new TestEventService();

        private ILogger _fakeLogger = TestLogger.Create();

        private IdentityServerOptions _options = new IdentityServerOptions();

        private MockUserSession _mockUserSession = new MockUserSession();

        private NameValueCollection _params = new NameValueCollection();

        private StubAuthorizeRequestValidator _stubAuthorizeRequestValidator = new StubAuthorizeRequestValidator();

        private StubAuthorizeResponseGenerator _stubAuthorizeResponseGenerator = new StubAuthorizeResponseGenerator();

        private StubAuthorizeInteractionResponseGenerator _stubInteractionGenerator = new StubAuthorizeInteractionResponseGenerator();

        private TestAuthorizeEndpoint _subject;

        private ClaimsPrincipal _user = new IdentityServerUser("bob").CreatePrincipal();

        private ValidatedAuthorizeRequest _validatedAuthorizeRequest;

        public AuthorizeEndpointBaseTests()
        {
            Init();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task error_resurect_with_prompt_none_should_include_session_state_in_response()
        {
            _params.Add("prompt", "none");
            _stubAuthorizeRequestValidator.Result.ValidatedRequest.IsOpenIdRequest = true;
            _stubAuthorizeRequestValidator.Result.ValidatedRequest.ClientId = "client";
            _stubAuthorizeRequestValidator.Result.ValidatedRequest.SessionId = "some_session";
            _stubAuthorizeRequestValidator.Result.ValidatedRequest.RedirectUri = "http://redirect";
            _stubAuthorizeRequestValidator.Result.IsError = true;
            _stubAuthorizeRequestValidator.Result.Error = "login_required";

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
            ((AuthorizeResult)result).Response.IsError.Should().BeTrue();
            ((AuthorizeResult)result).Response.SessionState.Should().NotBeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task authorize_request_validation_produces_error_should_display_error_page()
        {
            _stubAuthorizeRequestValidator.Result.IsError = true;
            _stubAuthorizeRequestValidator.Result.Error = "some_error";

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
            ((AuthorizeResult)result).Response.IsError.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task interaction_generator_consent_produces_consent_should_show_consent_page()
        {
            _stubInteractionGenerator.Response.IsConsent = true;

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task interaction_produces_error_should_show_error_page()
        {
            _stubInteractionGenerator.Response.Error = "error";

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
            ((AuthorizeResult)result).Response.IsError.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task interaction_produces_error_should_show_error_page_with_error_description_if_present()
        {
            var errorDescription = "some error description";

             _stubInteractionGenerator.Response.Error = "error";
            _stubInteractionGenerator.Response.ErrorDescription = errorDescription;

             var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

             result.Should().BeOfType();
            var authorizeResult = ((AuthorizeResult)result);
            authorizeResult.Response.IsError.Should().BeTrue();
            authorizeResult.Response.ErrorDescription.Should().Be(errorDescription);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task interaction_produces_login_result_should_trigger_login()
        {
            _stubInteractionGenerator.Response.IsLogin = true;

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAuthorizeRequestAsync_custom_interaction_redirect_result_should_issue_redirect()
        {
            _mockUserSession.User = _user;
            _stubInteractionGenerator.Response.RedirectUrl = "http://foo.com";

            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task successful_authorization_request_should_generate_authorize_result()
        {
            var result = await _subject.ProcessAuthorizeRequestAsync(_params, _user, null);

            result.Should().BeOfType();
        }

        internal void Init()
        {
            _context = new MockHttpContextAccessor().HttpContext;

            _validatedAuthorizeRequest = new ValidatedAuthorizeRequest()
            {
                RedirectUri = "http://client/callback",
                State = "123",
                ResponseMode = "fragment",
                ClientId = "client",
                Client = new Client
                {
                    ClientId = "client",
                    ClientName = "Test Client"
                },
                Raw = _params,
                Subject = _user
            };
            _stubAuthorizeResponseGenerator.Response.Request = _validatedAuthorizeRequest;

            _stubAuthorizeRequestValidator.Result = new AuthorizeRequestValidationResult(_validatedAuthorizeRequest);

            _subject = new TestAuthorizeEndpoint(
                _fakeEventService,
                _fakeLogger,
                _options,
                _stubAuthorizeRequestValidator,
                _stubInteractionGenerator,
                _stubAuthorizeResponseGenerator,
                _mockUserSession);
        }

        internal class TestAuthorizeEndpoint : AuthorizeEndpointBase
        {
            public TestAuthorizeEndpoint(
              IEventService events,
              ILogger logger,
              IdentityServerOptions options,
              IAuthorizeRequestValidator validator,
              IAuthorizeInteractionResponseGenerator interactionGenerator,
              IAuthorizeResponseGenerator authorizeResponseGenerator,
              IUserSession userSession)
            : base(events, logger, options, validator, interactionGenerator, authorizeResponseGenerator, userSession)
            {
            }

            public override Task ProcessAsync(HttpContext context)
            {
                throw new System.NotImplementedException();
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Authorize/AuthorizeEndpointTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Authorize
{
    public class AuthorizeEndpointTests
    {
        private const string Category = "Authorize Endpoint";

        private HttpContext _context;

        private TestEventService _fakeEventService = new TestEventService();

        private ILogger _fakeLogger = TestLogger.Create();

        private IdentityServerOptions _options = new IdentityServerOptions();

        private MockUserSession _mockUserSession = new MockUserSession();

        private NameValueCollection _params = new NameValueCollection();

        private StubAuthorizeRequestValidator _stubAuthorizeRequestValidator = new StubAuthorizeRequestValidator();

        private StubAuthorizeResponseGenerator _stubAuthorizeResponseGenerator = new StubAuthorizeResponseGenerator();

        private StubAuthorizeInteractionResponseGenerator _stubInteractionGenerator = new StubAuthorizeInteractionResponseGenerator();

        private AuthorizeEndpoint _subject;

        private ClaimsPrincipal _user = new IdentityServerUser("bob").CreatePrincipal();

        private ValidatedAuthorizeRequest _validatedAuthorizeRequest;

        public AuthorizeEndpointTests()
        {
            Init();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_authorize_path_should_return_authorization_result()
        {
            _context.Request.Method = "GET";
            _context.Request.Path = new PathString("/connect/authorize");
            _mockUserSession.User = _user;

            var result = await _subject.ProcessAsync(_context);

            result.Should().BeOfType();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ProcessAsync_post_without_form_content_type_should_return_415()
        {
            _context.Request.Method = "POST";

            var result = await _subject.ProcessAsync(_context);

            var statusCode = result as StatusCodeResult;
            statusCode.Should().NotBeNull();
            statusCode.StatusCode.Should().Be(415);
        }

        internal void Init()
        {
            _context = new MockHttpContextAccessor().HttpContext;

            _validatedAuthorizeRequest = new ValidatedAuthorizeRequest()
            {
                RedirectUri = "http://client/callback",
                State = "123",
                ResponseMode = "fragment",
                ClientId = "client",
                Client = new Client
                {
                    ClientId = "client",
                    ClientName = "Test Client"
                },
                Raw = _params,
                Subject = _user
            };
            _stubAuthorizeResponseGenerator.Response.Request = _validatedAuthorizeRequest;

            _stubAuthorizeRequestValidator.Result = new AuthorizeRequestValidationResult(_validatedAuthorizeRequest);

            _subject = new AuthorizeEndpoint(
                _fakeEventService,
                _fakeLogger,
                _options,
                _stubAuthorizeRequestValidator,
                _stubInteractionGenerator,
                _stubAuthorizeResponseGenerator,
                _mockUserSession);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Authorize/StubAuthorizeInteractionResponseGenerator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Endpoints.Authorize
{
    internal class StubAuthorizeInteractionResponseGenerator : IAuthorizeInteractionResponseGenerator
    {
        internal InteractionResponse Response { get; set; } = new InteractionResponse();

        public Task ProcessInteractionAsync(ValidatedAuthorizeRequest request, ConsentResponse consent = null)
        {
            return Task.FromResult(Response);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Authorize/StubAuthorizeRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Endpoints.Authorize
{
    public class StubAuthorizeRequestValidator : IAuthorizeRequestValidator
    {
        public AuthorizeRequestValidationResult Result { get; set; }

        public Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject = null)
        {
            return Task.FromResult(Result);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/EndSession/EndSessionCallbackEndpointTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Endpoints;
using Microsoft.Extensions.Logging;

namespace IdentityServer.UnitTests.Endpoints.EndSession
{
    public class EndSessionCallbackEndpointTests
    {
        private const string Category = "End Session Callback Endpoint";

        StubEndSessionRequestValidator _stubEndSessionRequestValidator = new StubEndSessionRequestValidator();
        EndSessionCallbackEndpoint _subject;

        public EndSessionCallbackEndpointTests()
        {
            _subject = new EndSessionCallbackEndpoint(
                _stubEndSessionRequestValidator,
                new LoggerFactory().CreateLogger());
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/EndSession/EndSessionCallbackResultTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.EndSession
{
    public class EndSessionCallbackResultTests
    {
        private const string Category = "End Session Callback Result";

        private readonly EndSessionCallbackValidationResult _validationResult;
        private readonly IdentityServerOptions _options;
        private readonly EndSessionCallbackResult _subject;

        public EndSessionCallbackResultTests()
        {
            _validationResult = new EndSessionCallbackValidationResult()
            {
                IsError = false,
            };
            _options = new IdentityServerOptions();
            _subject = new EndSessionCallbackResult(_validationResult, _options);
        }

        [Fact]
        public async Task default_options_should_emit_frame_src_csp_headers()
        {
            _validationResult.FrontChannelLogoutUrls = new[] { "http://foo" };

            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";

            await _subject.ExecuteAsync(ctx);

            ctx.Response.Headers["Content-Security-Policy"].First().Should().Contain("frame-src http://foo");
        }

        [Fact]
        public async Task relax_csp_options_should_prevent_frame_src_csp_headers()
        {
            _options.Authentication.RequireCspFrameSrcForSignout = false;
            _validationResult.FrontChannelLogoutUrls = new[] { "http://foo" };

            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";

            await _subject.ExecuteAsync(ctx);

            ctx.Response.Headers["Content-Security-Policy"].FirstOrDefault().Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/EndSession/StubBackChannelLogoutClient.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Endpoints.EndSession
{
    internal class StubBackChannelLogoutClient : IBackChannelLogoutService
    {
        public bool SendLogoutsWasCalled { get; set; }

        public Task SendLogoutNotificationsAsync(LogoutNotificationContext context)
        {
            SendLogoutsWasCalled = true;
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/EndSession/StubEndSessionRequestValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Endpoints.EndSession
{
    class StubEndSessionRequestValidator : IEndSessionRequestValidator
    {
        public EndSessionValidationResult EndSessionValidationResult { get; set; } = new EndSessionValidationResult();
        public EndSessionCallbackValidationResult EndSessionCallbackValidationResult { get; set; } = new EndSessionCallbackValidationResult();

        public Task ValidateAsync(NameValueCollection parameters, ClaimsPrincipal subject)
        {
            return Task.FromResult(EndSessionValidationResult);
        }

        public Task ValidateCallbackAsync(NameValueCollection parameters)
        {
            return Task.FromResult(EndSessionCallbackValidationResult);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Results/AuthorizeResultTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.WebUtilities;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Results
{
    public class AuthorizeResultTests
    {
        private AuthorizeResult _subject;

        private AuthorizeResponse _response = new AuthorizeResponse();
        private IdentityServerOptions _options = new IdentityServerOptions();
        private MockUserSession _mockUserSession = new MockUserSession();
        private MockMessageStore _mockErrorMessageStore = new MockMessageStore();

        private DefaultHttpContext _context = new DefaultHttpContext();

        public AuthorizeResultTests()
        {
            _context.SetIdentityServerOrigin("https://server");
            _context.SetIdentityServerBasePath("/");
            _context.Response.Body = new MemoryStream();

            _options.UserInteraction.ErrorUrl = "~/error";
            _options.UserInteraction.ErrorIdParameter = "errorId";

            _subject = new AuthorizeResult(_response, _options, _mockUserSession, _mockErrorMessageStore, new StubClock());
        }

        [Fact]
        public async Task error_should_redirect_to_error_page_and_passs_info()
        {
            _response.Error = "some_error";

            await _subject.ExecuteAsync(_context);

            _mockErrorMessageStore.Messages.Count.Should().Be(1);
            _context.Response.StatusCode.Should().Be(302);
            var location = _context.Response.Headers["Location"].First();
            location.Should().StartWith("https://server/error");
            var query = QueryHelpers.ParseQuery(new Uri(location).Query);
            query["errorId"].First().Should().Be(_mockErrorMessageStore.Messages.First().Key);
        }

        [Theory]
        [InlineData(OidcConstants.AuthorizeErrors.AccountSelectionRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.LoginRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.ConsentRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.InteractionRequired)]
        public async Task prompt_none_errors_should_return_to_client(string error)
        {
            _response.Error = error;
            _response.Request = new ValidatedAuthorizeRequest
            {
                ResponseMode = OidcConstants.ResponseModes.Query,
                RedirectUri = "http://client/callback",
                PromptModes = new[] { "none" }
            };

            await _subject.ExecuteAsync(_context);

            _mockUserSession.Clients.Count.Should().Be(0);
            _context.Response.StatusCode.Should().Be(302);
            var location = _context.Response.Headers["Location"].First();
            location.Should().StartWith("http://client/callback");
        }

        [Theory]
        [InlineData(OidcConstants.AuthorizeErrors.AccountSelectionRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.LoginRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.ConsentRequired)]
        [InlineData(OidcConstants.AuthorizeErrors.InteractionRequired)]
        public async Task prompt_none_errors_for_anonymous_users_should_include_session_state(string error)
        {
            _response.Error = error;
            _response.Request = new ValidatedAuthorizeRequest
            {
                ResponseMode = OidcConstants.ResponseModes.Query,
                RedirectUri = "http://client/callback",
                PromptModes = new[] { "none" },
            };
            _response.SessionState = "some_session_state";

            await _subject.ExecuteAsync(_context);

            _mockUserSession.Clients.Count.Should().Be(0);
            _context.Response.StatusCode.Should().Be(302);
            var location = _context.Response.Headers["Location"].First();
            location.Should().Contain("session_state=some_session_state");
        }

        [Fact]
        public async Task access_denied_should_return_to_client()
        {
            const string errorDescription = "some error description";

            _response.Error = OidcConstants.AuthorizeErrors.AccessDenied;
            _response.ErrorDescription = errorDescription;
            _response.Request = new ValidatedAuthorizeRequest
            {
                ResponseMode = OidcConstants.ResponseModes.Query,
                RedirectUri = "http://client/callback"
            };

            await _subject.ExecuteAsync(_context);

            _mockUserSession.Clients.Count.Should().Be(0);
            _context.Response.StatusCode.Should().Be(302);
            var location = _context.Response.Headers["Location"].First();
            location.Should().StartWith("http://client/callback");

            var queryString = new Uri(location).Query;
            var queryParams = QueryHelpers.ParseQuery(queryString);

            queryParams["error"].Should().Equal(OidcConstants.AuthorizeErrors.AccessDenied);
            queryParams["error_description"].Should().Equal(errorDescription);
        }

        [Fact]
        public async Task success_should_add_client_to_client_list()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.Query,
                RedirectUri = "http://client/callback"
            };

            await _subject.ExecuteAsync(_context);

            _mockUserSession.Clients.Should().Contain("client");
        }

        [Fact]
        public async Task query_mode_should_pass_results_in_query()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.Query,
                RedirectUri = "http://client/callback",
                State = "state"
            };

            await _subject.ExecuteAsync(_context);

            _context.Response.StatusCode.Should().Be(302);
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-store");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-cache");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("max-age=0");
            var location = _context.Response.Headers["Location"].First();
            location.Should().StartWith("http://client/callback");
            location.Should().Contain("?state=state");
        }

        [Fact]
        public async Task fragment_mode_should_pass_results_in_fragment()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                RedirectUri = "http://client/callback",
                State = "state"
            };

            await _subject.ExecuteAsync(_context);

            _context.Response.StatusCode.Should().Be(302);
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-store");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-cache");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("max-age=0");
            var location = _context.Response.Headers["Location"].First();
            location.Should().StartWith("http://client/callback");
            location.Should().Contain("#state=state");
        }

        [Fact]
        public async Task form_post_mode_should_pass_results_in_body()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.FormPost,
                RedirectUri = "http://client/callback",
                State = "state"
            };

            await _subject.ExecuteAsync(_context);

            _context.Response.StatusCode.Should().Be(200);
            _context.Response.ContentType.Should().StartWith("text/html");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-store");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-cache");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("max-age=0");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8='");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("script-src 'sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8='");
            _context.Response.Body.Seek(0, SeekOrigin.Begin);
            using (var rdr = new StreamReader(_context.Response.Body))
            {
                var html = rdr.ReadToEnd();
                html.Should().Contain("");
                html.Should().Contain("
    ");
                html.Should().Contain("");
            }
        }

        [Fact]
        public async Task form_post_mode_should_add_unsafe_inline_for_csp_level_1()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.FormPost,
                RedirectUri = "http://client/callback",
                State = "state"
            };

            _options.Csp.Level = CspLevel.One;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'unsafe-inline' 'sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8='");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("script-src 'unsafe-inline' 'sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8='");
        }

        [Fact]
        public async Task form_post_mode_should_not_add_deprecated_header_when_it_is_disabled()
        {
            _response.Request = new ValidatedAuthorizeRequest
            {
                ClientId = "client",
                ResponseMode = OidcConstants.ResponseModes.FormPost,
                RedirectUri = "http://client/callback",
                State = "state"
            };

            _options.Csp.AddDeprecatedHeader = false;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'sha256-orD0/VhH8hLqrLxKHD/HUEMdwqX6/0ve7c5hspX5VJ8='");
            _context.Response.Headers["X-Content-Security-Policy"].Should().BeEmpty();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Results/CheckSessionResultTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Results
{
    public class CheckSessionResultTests
    {
        private CheckSessionResult _subject;

        private IdentityServerOptions _options = new IdentityServerOptions();

        private DefaultHttpContext _context = new DefaultHttpContext();

        public CheckSessionResultTests()
        {
            _context.SetIdentityServerOrigin("https://server");
            _context.SetIdentityServerBasePath("/");
            _context.Response.Body = new MemoryStream();

            _options.Authentication.CheckSessionCookieName = "foobar";

            _subject = new CheckSessionResult(_options);
        }

        [Fact]
        public async Task should_pass_results_in_body()
        {
            await _subject.ExecuteAsync(_context);

            _context.Response.StatusCode.Should().Be(200);
            _context.Response.ContentType.Should().StartWith("text/html");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI='");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("script-src 'sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI='");
            _context.Response.Body.Seek(0, SeekOrigin.Begin);
            using (var rdr = new StreamReader(_context.Response.Body))
            {
                var html = rdr.ReadToEnd();
                html.Should().Contain("");
            }
        }

        [Fact]
        public async Task form_post_mode_should_add_unsafe_inline_for_csp_level_1()
        {
            _options.Csp.Level = CspLevel.One;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'unsafe-inline' 'sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI='");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("script-src 'unsafe-inline' 'sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI='");
        }

        [Fact]
        public async Task form_post_mode_should_not_add_deprecated_header_when_it_is_disabled()
        {
            _options.Csp.AddDeprecatedHeader = false;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("script-src 'sha256-fa5rxHhZ799izGRP38+h4ud5QXNT0SFaFlh4eqDumBI='");
            _context.Response.Headers["X-Content-Security-Policy"].Should().BeEmpty();
        }

        [Theory]
        [InlineData("foobar")]
        [InlineData("morefoobar")]

        public async Task can_change_cached_cookiename(string cookieName)
        {
            _options.Authentication.CheckSessionCookieName = cookieName;
            await _subject.ExecuteAsync(_context);
            _context.Response.Body.Seek(0, SeekOrigin.Begin);
            using (var rdr = new StreamReader(_context.Response.Body))
            {
                var html = rdr.ReadToEnd();
                html.Should().Contain($"");
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Results/EndSessionCallbackResultTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Results
{
    public class EndSessionCallbackResultTests
    {
        private EndSessionCallbackResult _subject;

        private EndSessionCallbackValidationResult _result = new EndSessionCallbackValidationResult();
        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        private DefaultHttpContext _context = new DefaultHttpContext();

        public EndSessionCallbackResultTests()
        {
            _context.SetIdentityServerOrigin("https://server");
            _context.SetIdentityServerBasePath("/");
            _context.Response.Body = new MemoryStream();

            _subject = new EndSessionCallbackResult(_result, _options);
        }

        [Fact]
        public async Task error_should_return_400()
        {
            _result.IsError = true;

            await _subject.ExecuteAsync(_context);

            _context.Response.StatusCode.Should().Be(400);
        }

        [Fact]
        public async Task success_should_render_html_and_iframes()
        {
            _result.IsError = false;
            _result.FrontChannelLogoutUrls = new string[] { "http://foo.com", "http://bar.com" };

            await _subject.ExecuteAsync(_context);

            _context.Response.ContentType.Should().StartWith("text/html");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-store");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("no-cache");
            _context.Response.Headers["Cache-Control"].First().Should().Contain("max-age=0");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("style-src 'sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY=';");
            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("frame-src http://foo.com http://bar.com");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("default-src 'none';");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("style-src 'sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY=';");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("frame-src http://foo.com http://bar.com");
            _context.Response.Body.Seek(0, SeekOrigin.Begin);
            using (var rdr = new StreamReader(_context.Response.Body))
            {
                var html = rdr.ReadToEnd();
                html.Should().Contain("");
                html.Should().Contain("");
            }
        }

        [Fact]
        public async Task fsuccess_should_add_unsafe_inline_for_csp_level_1()
        {
            _result.IsError = false;

            _options.Csp.Level = CspLevel.One;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("style-src 'unsafe-inline' 'sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY='");
            _context.Response.Headers["X-Content-Security-Policy"].First().Should().Contain("style-src 'unsafe-inline' 'sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY='");
        }

        [Fact]
        public async Task form_post_mode_should_not_add_deprecated_header_when_it_is_disabled()
        {
            _result.IsError = false;

            _options.Csp.AddDeprecatedHeader = false;

            await _subject.ExecuteAsync(_context);

            _context.Response.Headers["Content-Security-Policy"].First().Should().Contain("style-src 'sha256-u+OupXgfekP+x/f6rMdoEAspPCYUtca912isERnoEjY='");
            _context.Response.Headers["X-Content-Security-Policy"].Should().BeEmpty();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Endpoints/Results/EndSessionResultTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Endpoints.Results;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.WebUtilities;
using Xunit;

namespace IdentityServer.UnitTests.Endpoints.Results
{
    public class EndSessionResultTests
    {
        private EndSessionResult _subject;

        private EndSessionValidationResult _result = new EndSessionValidationResult();
        private IdentityServerOptions _options = new IdentityServerOptions();
        private MockMessageStore _mockLogoutMessageStore = new MockMessageStore();

        private DefaultHttpContext _context = new DefaultHttpContext();

        public EndSessionResultTests()
        {
            _context.SetIdentityServerOrigin("https://server");
            _context.SetIdentityServerBasePath("/");

            _options.UserInteraction.LogoutUrl = "~/logout";
            _options.UserInteraction.LogoutIdParameter = "logoutId";

            _subject = new EndSessionResult(_result, _options, new StubClock(), _mockLogoutMessageStore);
        }

        [Fact]
        public async Task validated_signout_should_pass_logout_message()
        {
            _result.IsError = false;
            _result.ValidatedRequest = new ValidatedEndSessionRequest
            {
                Client = new Client
                {
                    ClientId = "client"
                },
                PostLogOutUri = "http://client/post-logout-callback"
            };

            await _subject.ExecuteAsync(_context);

            _mockLogoutMessageStore.Messages.Count.Should().Be(1);
            var location = _context.Response.Headers["Location"].Single();
            var query = QueryHelpers.ParseQuery(new Uri(location).Query);

            location.Should().StartWith("https://server/logout");
            query["logoutId"].First().Should().Be(_mockLogoutMessageStore.Messages.First().Key);
        }

        [Fact]
        public async Task unvalidated_signout_should_not_pass_logout_message()
        {
            _result.IsError = false;

            await _subject.ExecuteAsync(_context);

            _mockLogoutMessageStore.Messages.Count.Should().Be(0);
            var location = _context.Response.Headers["Location"].Single();
            var query = QueryHelpers.ParseQuery(new Uri(location).Query);

            location.Should().StartWith("https://server/logout");
            query.Count.Should().Be(0);
        }

        [Fact]
        public async Task error_result_should_not_pass_logout_message()
        {
            _result.IsError = true;
            _result.ValidatedRequest = new ValidatedEndSessionRequest
            {
                Client = new Client
                {
                    ClientId = "client"
                },
                PostLogOutUri = "http://client/post-logout-callback"
            };

            await _subject.ExecuteAsync(_context);

            _mockLogoutMessageStore.Messages.Count.Should().Be(0);
            var location = _context.Response.Headers["Location"].Single();
            var query = QueryHelpers.ParseQuery(new Uri(location).Query);

            location.Should().StartWith("https://server/logout");
            query.Count.Should().Be(0);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/ApiResourceSigningAlgorithmSelectionTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using FluentAssertions;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class ApiResourceSigningAlgorithmSelectionTests
    {
        [Fact]
        public void Single_resource_no_allowed_algorithms_set_should_return_empty_list()
        {
            var resource = new ApiResource();

            var allowedAlgorithms = new List { resource }.FindMatchingSigningAlgorithms();

            allowedAlgorithms.Count().Should().Be(0);
        }
        
        [Fact]
        public void Two_resources_no_allowed_algorithms_set_should_return_empty_list()
        {
            var resource1 = new ApiResource();
            var resource2 = new ApiResource();

            var allowedAlgorithms = new List { resource1, resource2 }.FindMatchingSigningAlgorithms();

            allowedAlgorithms.Count().Should().Be(0);
        }
        
        [Theory]
        [InlineData(new [] { "A" }, new [] { "A" }, 
                    new [] { "A" })]
        [InlineData(new [] { "A", "B" }, new [] { "A", "B" }, 
                    new [] { "A", "B" })]
        [InlineData(new [] { "A", "B", "C" }, new [] { "A", "B", "C" }, 
                    new [] { "A", "B", "C" })]

        [InlineData(new [] { "A", "B" }, new [] { "A", "D" }, 
                    new [] { "A" })]
        [InlineData(new [] { "A", "B", "C" }, new [] { "A", "B", "Z" }, 
                    new [] { "A", "B" })]

        [InlineData(new string[] { }, new [] { "B" },
                    new string[] { "B" })]
        [InlineData(new string[] { }, new [] { "C", "D" },
                    new string[] { "C", "D" })]

        [InlineData(new [] { "A" }, new [] { "B" }, 
                    new string[] { })]
        [InlineData(new [] { "A", "B" }, new [] { "C", "D" }, 
                    new string[] { })]
        public void Two_resources_with_allowed_algorithms_set_should_return_right_values(
            string[] resource1Algorithms, string[] resource2Algorithms, 
            string[] expectedAlgorithms)
        {
            var resource1 = new ApiResource()
            {
                AllowedAccessTokenSigningAlgorithms = resource1Algorithms
            };
            
            var resource2 = new ApiResource
            {
                AllowedAccessTokenSigningAlgorithms = resource2Algorithms
            };

            if (expectedAlgorithms.Any())
            {
                var allowedAlgorithms = new List { resource1, resource2 }.FindMatchingSigningAlgorithms();
                allowedAlgorithms.Should().BeEquivalentTo(expectedAlgorithms);
            }
            else
            {
                Action act = () => new List { resource1, resource2 }.FindMatchingSigningAlgorithms();
                act.Should().Throw();
            }
        }
        
        [Theory]
        [InlineData(new [] { "A" }, new [] { "A" }, new [] { "A" }, 
            new [] { "A" })]
        [InlineData(new [] { "A", "B" }, new [] { "A", "B" }, new [] { "A", "B" }, 
            new [] { "A", "B" })]
        [InlineData(new [] { "A", "B", "C" }, new [] { "A", "B", "C" }, new [] { "A", "B", "C" }, 
            new [] { "A", "B", "C" })]
        
        [InlineData(new [] { "A", "B" }, new [] { "A", "D" }, new [] { "A", "E" } ,
                    new [] { "A" })]
        [InlineData(new [] { "A", "B", "X" }, new [] { "A", "B", "Y" }, new [] { "A", "B", "Z" },
                    new [] { "A", "B" })]
        [InlineData(new [] { "A", "B", "X" }, new [] { "C", "D", "X" }, new [] { "E", "F", "X" },
                    new [] { "X" })]

        [InlineData(new[] { "A", "B" }, new[] { "A", "D" }, new string[] { },
                    new[] { "A" })]
        [InlineData(new[] { "A", "B" }, new[] { "A", "C", "B" }, new string[] { },
                    new[] { "A", "B" })]
        [InlineData(new[] { "A", "B" }, new string[] { }, new string[] { },
                    new[] { "A", "B" })]

        [InlineData(new [] { "A" }, new [] { "B" }, new [] { "C" }, 
            new string[] { })]
        [InlineData(new [] { "A", "B" }, new [] { "C", "D" }, new [] { "X", "Y" }, 
            new string[] { })]
        [InlineData(new [] { "A", "B", "C" }, new [] { "C", "D", "E" }, new [] { "E", "F", "G" },
                    new string[] { })]
        public void Three_resources_with_allowed_algorithms_set_should_return_right_values(
            string[] resource1Algorithms, string[] resource2Algorithms, string[] resource3Algorithms, 
            string[] expectedAlgorithms)
        {
            var resource1 = new ApiResource()
            {
                AllowedAccessTokenSigningAlgorithms = resource1Algorithms
            };
            
            var resource2 = new ApiResource
            {
                AllowedAccessTokenSigningAlgorithms = resource2Algorithms
            };
            
            var resource3 = new ApiResource
            {
                AllowedAccessTokenSigningAlgorithms = resource3Algorithms
            };

            if (expectedAlgorithms.Any())
            {
                var allowedAlgorithms = new List {resource1, resource2, resource3}.FindMatchingSigningAlgorithms();
                allowedAlgorithms.Should().BeEquivalentTo(expectedAlgorithms);
            }
            else
            {
                Action act = () => new List {resource1, resource2, resource3}.FindMatchingSigningAlgorithms();
                act.Should().Throw();
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/EndpointOptionsExtensionsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Configuration;
using IdentityServer8.Extensions;
using IdentityServer8.Hosting;
using Xunit;
using static IdentityServer8.Constants;

namespace IdentityServer.UnitTests.Extensions
{
    public class EndpointOptionsExtensionsTests
    {
        private readonly EndpointsOptions _options = new EndpointsOptions();

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForAuthorizeEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableAuthorizeEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.Authorize)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForCheckSessionEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableCheckSessionEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.CheckSession)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForDeviceAuthorizationEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableDeviceAuthorizationEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.DeviceAuthorization)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForDiscoveryEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableDiscoveryEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.Discovery)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForEndSessionEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableEndSessionEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.EndSession)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForIntrospectionEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableIntrospectionEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.Introspection)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForTokenEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableTokenEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.Token)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForRevocationEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableTokenRevocationEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.Revocation)));
        }

        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        public void IsEndpointEnabledShouldReturnExpectedForUserInfoEndpoint(bool expectedIsEndpointEnabled)
        {
            _options.EnableUserInfoEndpoint = expectedIsEndpointEnabled;

            Assert.Equal(
                expectedIsEndpointEnabled,
                _options.IsEndpointEnabled(
                    CreateTestEndpoint(EndpointNames.UserInfo)));
        }

        private Endpoint CreateTestEndpoint(string name)
        {
            return new Endpoint(name, "", null);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/HttpRequestExtensionsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.Extensions;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class HttpRequestExtensionsTests
    {
        [Fact]
        public void GetCorsOrigin_valid_cors_request_should_return_cors_origin()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "http";
            ctx.Request.Host = new HostString("foo");
            ctx.Request.Headers.Append("Origin", "http://bar");

            ctx.Request.GetCorsOrigin().Should().Be("http://bar");
        }

        [Fact]
        public void GetCorsOrigin_origin_from_same_host_should_not_return_cors_origin()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "http";
            ctx.Request.Host = new HostString("foo");
            ctx.Request.Headers.Append("Origin", "http://foo");

            ctx.Request.GetCorsOrigin().Should().BeNull();
        }

        [Fact]
        public void GetCorsOrigin_no_origin_should_not_return_cors_origin()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Scheme = "http";
            ctx.Request.Host = new HostString("foo");

            ctx.Request.GetCorsOrigin().Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/IResourceStoreExtensionsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class IResourceStoreExtensionsTests
    {
        [Fact]
        public async Task GetAllEnabledResourcesAsync_on_duplicate_identity_scopes_should_fail()
        {
            var store = new MockResourceStore()
            {
                IdentityResources = {
                    new IdentityResource { Name = "A" },
                    new IdentityResource { Name = "A" } }
            };

            Func a = async () => await store.GetAllEnabledResourcesAsync();
            (await a.Should().ThrowAsync()).And.Message.ToLowerInvariant().Should().Contain("duplicate").And.Contain("identity scopes");
        }

        [Fact]
        public async Task GetAllEnabledResourcesAsync_without_duplicate_identity_scopes_should_succeed()
        {
            var store = new MockResourceStore()
            {
                IdentityResources = {
                    new IdentityResource { Name = "A" },
                    new IdentityResource { Name = "B" } }
            };

            await store.GetAllEnabledResourcesAsync();
        }

        [Fact]
        public async Task GetAllEnabledResourcesAsync_on_duplicate_api_resources_should_fail()
        {
            var store = new MockResourceStore()
            {
                ApiResources = { new ApiResource { Name = "a" }, new ApiResource { Name = "a" } }
            };

            Func a = async () => await store.GetAllEnabledResourcesAsync();
            (await a.Should().ThrowAsync())
                .And.Message.ToLowerInvariant().Should().Contain("duplicate").And.Contain("api resources");
        }

        [Fact]
        public async Task GetAllEnabledResourcesAsync_without_duplicate_api_scopes_should_succeed()
        {
            var store = new MockResourceStore()
            {
                ApiResources = { new ApiResource("A"), new ApiResource("B") }
            };

            await store.GetAllEnabledResourcesAsync();
        }

        [Fact]
        public async Task FindResourcesByScopeAsync_on_duplicate_identity_scopes_should_fail()
        {
            var store = new MockResourceStore()
            {
                IdentityResources = {
                    new IdentityResource { Name = "A" },
                    new IdentityResource { Name = "A" } }
            };

            Func a = async () => await store.FindResourcesByScopeAsync(new string[] { "A" });
            (await a.Should().ThrowAsync()).And.Message.ToLowerInvariant().Should().Contain("duplicate").And.Contain("identity scopes");
        }

        [Fact]
        public async Task FindResourcesByScopeAsync_without_duplicate_identity_scopes_should_succeed()
        {
            var store = new MockResourceStore()
            {
                IdentityResources = {
                    new IdentityResource { Name = "A" },
                    new IdentityResource { Name = "B" } }
            };

            await store.FindResourcesByScopeAsync(new string[] { "A" });
        }

        [Fact]
        public async Task FindResourcesByScopeAsync_on_duplicate_api_scopes_should_succeed()
        {
            var store = new MockResourceStore()
            {
                ApiResources = { 
                    new ApiResource { Name = "api1", Scopes = { "a" } },
                    new ApiResource() { Name = "api2", Scopes = { "a" } },
                },
                ApiScopes = { 
                    new ApiScope("a") 
                } 
            };

            var result = await store.FindResourcesByScopeAsync(new string[] { "a" });
            result.ApiResources.Count.Should().Be(2);
            result.ApiScopes.Count.Should().Be(1);
            result.ApiResources.Select(x => x.Name).Should().BeEquivalentTo(new[] { "api1", "api2" });
            result.ApiScopes.Select(x => x.Name).Should().BeEquivalentTo(new[] { "a" });
        }

        [Fact]
        public async Task FindResourcesByScopeAsync_without_duplicate_api_scopes_should_succeed()
        {
            var store = new MockResourceStore()
            {
                ApiResources = { new ApiResource("A"), new ApiResource("B") }
            };

            await store.FindResourcesByScopeAsync(new string[] { "A" });
        }

        [Fact]
        public async Task FindResourcesByScopeAsync_with_duplicate_api_scopes_on_single_api_resource_should_succeed_and_only_reuturn_one_resource()
        {
            var store = new MockResourceStore()
            {
                ApiResources = { 
                    new ApiResource { 
                        Name = "api1", Scopes = { "a", "a" }
                    }
                },
                ApiScopes = {
                    new ApiScope("a"),
                }
            };

            var result = await store.FindResourcesByScopeAsync(new string[] { "a" });
            result.ApiResources.Count.Should().Be(1);
        }

        public class MockResourceStore : IResourceStore
        {
            public List IdentityResources { get; set; } = new List();
            public List ApiResources { get; set; } = new List();
            public List ApiScopes { get; set; } = new List();

            public Task> FindApiResourcesByNameAsync(IEnumerable names)
            {
                var apis = from a in ApiResources
                          where names.Contains(a.Name)
                          select a;
                return Task.FromResult(apis);
            }

            public Task> FindApiResourcesByScopeNameAsync(IEnumerable names)
            {
                if (names == null) throw new ArgumentNullException(nameof(names));

                var api = from a in ApiResources
                          where a.Scopes.Any(x => names.Contains(x))
                          select a;

                return Task.FromResult(api);
            }

            public Task> FindIdentityResourcesByScopeNameAsync(IEnumerable names)
            {
                if (names == null) throw new ArgumentNullException(nameof(names));

                var identity = from i in IdentityResources
                               where names.Contains(i.Name)
                               select i;

                return Task.FromResult(identity);
            }

            public Task> FindApiScopesByNameAsync(IEnumerable scopeNames)
            {
                var q = from x in ApiScopes
                        where scopeNames.Contains(x.Name)
                        select x;
                return Task.FromResult(q);
            }

            public Task GetAllResourcesAsync()
            {
                var result = new Resources(IdentityResources, ApiResources, ApiScopes);
                return Task.FromResult(result);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/IdentityServerBuilderExtensionsCacheStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class IdentityServerBuilderExtensionsCacheStoreTests
    {
        private class CustomClientStore: IClientStore
        {
            public Task FindClientByIdAsync(string clientId)
            {
                throw new System.NotImplementedException();
            }
        }

        private class CustomResourceStore : IResourceStore
        {
            public Task> FindIdentityResourcesByScopeNameAsync(IEnumerable scopeNames)
            {
                throw new System.NotImplementedException();
            }

            public Task> FindApiResourcesByScopeNameAsync(IEnumerable scopeNames)
            {
                throw new System.NotImplementedException();
            }

            public Task> FindApiResourcesByNameAsync(IEnumerable names)
            {
                throw new System.NotImplementedException();
            }

            public Task GetAllResourcesAsync()
            {
                throw new System.NotImplementedException();
            }

            public Task> FindApiScopesByNameAsync(IEnumerable scopeNames)
            {
                throw new System.NotImplementedException();
            }
        }

        [Fact]
        public void AddClientStoreCache_should_add_concrete_iclientstore_implementation()
        {
            var services = new ServiceCollection();
            var identityServerBuilder = new IdentityServerBuilder(services);

            identityServerBuilder.AddClientStoreCache();

            services.Any(x => x.ImplementationType == typeof(CustomClientStore)).Should().BeTrue();
        }

        [Fact]
        public void AddResourceStoreCache_should_attempt_to_register_iresourcestore_implementation()
        {
            var services = new ServiceCollection();
            var identityServerBuilder = new IdentityServerBuilder(services);

            identityServerBuilder.AddResourceStoreCache();

            services.Any(x => x.ImplementationType == typeof(CustomResourceStore)).Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/IdentityServerBuilderExtensionsCryptoTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8;
using IdentityServer8.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.IdentityModel.Tokens;
using System;
using System.IO;
using System.Security.Cryptography;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class IdentityServerBuilderExtensionsCryptoTests
    {
        [Fact]
        public void AddSigningCredential_with_json_web_key_containing_asymmetric_key_should_succeed()
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            String json =
            @"{
                ""alg"" : ""RS256"",
                ""kty"" : ""RSA"",
                ""use"" : ""sig"",
                ""d"" : ""KGGNkbbgm2hNMqW6fP1fmcWwEBy77WOJIPAXnDJ0KxNTtqDF8K5ULj7EElHO1A8ZnNl1Ey/x//G9lJCOQUU9wmj010dOSsW0NBbR5NtRtLLuVbkVdyft53PGeTQs+1S3c51fz9jojtNqmlfXSANPFOH6QhxmzpTx3KLsf/TpCzblkSrEGOOqCCvVdl7ybTcB230jNhh3JoL7po1rvxKtoOM4a/Bs0NtKj7e+VaHcf0GLnBPJYetsHu43ZfNejJeDoouaXZzeVEklY3B0pe10OTCIOu0JUKGZxNekklRIo1WSEYdL+CJfrSKWIv8bLj6xSr5zrASvWODyH443LN6ZvQ=="",
                ""e"" : ""AQAB"",
                ""n"" : ""q7mZfquRq8tzg/5slbNdQmrosNN/mFXS25dbSPm11qEDCgZa452KkO8+hvMtqa92QaqdlmalSF8+FRDOz3grDR5NtmnXZxuKnp+raKfzpC6hCvh2JSIe/J9enmsMM4YeI4d1FOSDwhJlZIYMdMnqG/VJtO1LSHjOaF3XN31ANKF0nPAsmr2/WysiQlxnxxiikLEnsFuNdS615ODDXFGTQ1E+zc4zVur4/Ox0cllPwHPA4PqoIgdPJPL+xM9IOIXuAGtsp4CYoxT6VWaRrALIZXXDY806WGTuctq4KKot6FGL9HQte2hRLl4E/r8SzIK86U3wRwrBe7saK+XUXoP0gQ="",
		        ""p"" :	""25dkucyCSqxRcJpRrhl7PXqw7wqBZeLQgYlZLpK493PdM8pFfq+/LK1hFtxIjdFKqXS/TOikB4YCBMEH0Im3HZ8Lo0dub3SWNhdegJyRjMbcoO+A9YSODEj7DFaNpZtdmtDi1n6etJm66ctPSR20NNpzoYZuaJ92fVQiKiOh6Qs="",
                ""q"" : ""yDKBrS8l1DOx4dwP9hdwhqZJ3XahidiIZSL7m46I/6+cjaki/1mtNiA60MOgqTKegP7Fo7jAYvliqQwnvVGmQvLv19cfKywlIuKN9DdkLHnKh75hfo7aakEbO7GJ5zVgsNnKOdf8wvpclfvIuRDEVva4cksPzsJy6K7C8ENCSCM="",
                ""dp"" :  ""GlYJ6o6wgawxCEQ5z5uWwETau5CS/Fk7kI2ceI14SZVHzlJQC2WglAcnQcqhmQCk57Xsy5iLM6vKyi8sdMJPh+nvR2HlyNA+w7YBy4L7odqn01VmLgv7zVVjZpNq4ZXEoDC1Q+xjtF1LoYaUt7wsRLp+a7znuPyHBXj1sAAeBwk="",
                ""dq"" :  ""W8OK3S83T8VCTBzq1Ap6cb3XLcQq11yBaJpYaj0zXr/IKsbUW+dnFeBAFWEWS3gAX3Bod1tAFB3rs0D3FjhO1XE1ruHUT520iAEAwGiDaj+JLh994NzqELo3GW2PoIM/BtFNeKYgHd9UgQsgPnQJCzOb6Aev/z3yHeW9RRQPVbE="",
                ""qi"" :  ""w4KdmiDN1GtK71JxaasqmEKPNfV3v2KZDXKnfyhUsdx/idKbdTVjvMOkxFPJ4FqV4yIVn06f3QHTm4NEG18Diqxsrzd6kXQIHOa858tLsCcmt9FoGfrgCFgVceh3K/Zah/r8rl9Y61u0Z1kZumwMvFpFE+mVU01t9HgTEAVkHTc=""
            }";

            JsonWebKey jsonWebKey = new JsonWebKey(json);
            SigningCredentials credentials = new SigningCredentials(jsonWebKey, jsonWebKey.Alg);
            identityServerBuilder.AddSigningCredential(credentials);
        }

        [Fact]
        public void AddSigningCredential_with_json_web_key_containing_symmetric_key_should_throw_exception()
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            String json =
            @"{
                ""alg"" : ""HS256"",
                ""kty"" : ""oct"",
                ""use"" : ""sig"",
                ""k"" : ""y5FHaQFtC294HLAtPXAcMkxZ5gHzCq24223vSYQUrDuu-3CUw7UzPru-AX30ubeB2IM_gUsNQ80bX22wwSk_3LC6XxYxqeGJZSeoQqHG0VNbaWCVkqeuB_HOiL1-ksPfGT-o8_A_Uv-6zi2NaEOYpnIyff5LpdW__LhiE-bhIenaw7GhoXSAfsGEZfNZpUUOU35NAiN2dv0T5vptb87wkL1I2zLhV0pdLvWsDWgQPINEa8bbCA_mseBYpB1eioZvt0TZbp6CL9tiEoiikYV_F3IutrJ2SOWYtDNFeQ3sbyYP7zTzh9a2eyaM8ca5_q3qosI92AbZ7WpEFLa9cZ_O7g""
            }";

            JsonWebKey jsonWebKey = new JsonWebKey(json);
            SigningCredentials credentials = new SigningCredentials(jsonWebKey, jsonWebKey.Alg);
            Assert.Throws(() => identityServerBuilder.AddSigningCredential(credentials));
        }

        [Fact]
        public void AddDeveloperSigningCredential_should_succeed()
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            identityServerBuilder.AddDeveloperSigningCredential();

            //clean up... delete stored rsa key
            var filename = Path.Combine(Directory.GetCurrentDirectory(), "tempkey.rsa");

            if (File.Exists(filename))
                File.Delete(filename);
        }

        [Fact]
        public void AddDeveloperSigningCredential_should_succeed_when_called_multiple_times()
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            try
            {
                identityServerBuilder.AddDeveloperSigningCredential();

                //calling a second time will try to load the saved rsa key from disk. An exception will be throw if the private key is not serialized properly.
                identityServerBuilder.AddDeveloperSigningCredential();
            }
            finally
            {
                //clean up... delete stored rsa key
                var filename = Path.Combine(Directory.GetCurrentDirectory(), "tempkey.rsa");

                if (File.Exists(filename))
                    File.Delete(filename);
            }
        }

        [Theory]
        [InlineData(Constants.CurveOids.P256, SecurityAlgorithms.EcdsaSha256)]
        [InlineData(Constants.CurveOids.P384, SecurityAlgorithms.EcdsaSha384)]
        [InlineData(Constants.CurveOids.P521, SecurityAlgorithms.EcdsaSha512)]
        public void AddSigningCredential_with_valid_curve_should_succeed(string curveOid, string alg)
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            var key = new ECDsaSecurityKey(ECDsa.Create(
                ECCurve.CreateFromOid(Oid.FromOidValue(curveOid, OidGroup.All))));

            identityServerBuilder.AddSigningCredential(key, alg);
        }

        [Theory]
        [InlineData(Constants.CurveOids.P256, SecurityAlgorithms.EcdsaSha512)]
        [InlineData(Constants.CurveOids.P384, SecurityAlgorithms.EcdsaSha512)]
        [InlineData(Constants.CurveOids.P521, SecurityAlgorithms.EcdsaSha256)]
        public void AddSigningCredential_with_invalid_curve_should_throw_exception(string curveOid, string alg)
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            var key = new ECDsaSecurityKey(ECDsa.Create(
                ECCurve.CreateFromOid(Oid.FromOidValue(curveOid, OidGroup.All))));

            Assert.Throws(() => identityServerBuilder.AddSigningCredential(key, alg));
        }



        [Theory]
        [InlineData(Constants.CurveOids.P256, SecurityAlgorithms.EcdsaSha256, JsonWebKeyECTypes.P256)]
        [InlineData(Constants.CurveOids.P384, SecurityAlgorithms.EcdsaSha384, JsonWebKeyECTypes.P384)]
        [InlineData(Constants.CurveOids.P521, SecurityAlgorithms.EcdsaSha512, JsonWebKeyECTypes.P521)]
        public void AddSigningCredential_with_invalid_crv_value_should_throw_exception(string curveOid, string alg, string crv)
        {
            IServiceCollection services = new ServiceCollection();
            IIdentityServerBuilder identityServerBuilder = new IdentityServerBuilder(services);

            var key = new ECDsaSecurityKey(ECDsa.Create(
                ECCurve.CreateFromOid(Oid.FromOidValue(curveOid, OidGroup.All))));
            var parameters = key.ECDsa.ExportParameters(true);

            var jsonWebKeyFromECDsa = new JsonWebKey()
            {
                Kty = JsonWebAlgorithmsKeyTypes.EllipticCurve,
                Use = "sig",
                Kid = key.KeyId,
                KeyId = key.KeyId,
                X = Base64UrlEncoder.Encode(parameters.Q.X),
                Y = Base64UrlEncoder.Encode(parameters.Q.Y),
                D = Base64UrlEncoder.Encode(parameters.D),
                Crv = crv.Replace("-", string.Empty),
                Alg = SecurityAlgorithms.EcdsaSha256
            };
            Assert.Throws(() => identityServerBuilder.AddSigningCredential(jsonWebKeyFromECDsa, alg));
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/JwtPayloadCreationTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using Microsoft.AspNetCore.Authentication;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class JwtPayloadCreationTests
    {
        private Token _token;
        
        public JwtPayloadCreationTests()
        {
            var claims = new List
            {
                new Claim(JwtClaimTypes.Scope, "scope1"),
                new Claim(JwtClaimTypes.Scope, "scope2"),
                new Claim(JwtClaimTypes.Scope, "scope3"),
            };
            
            _token = new Token(OidcConstants.TokenTypes.AccessToken)
            {
                CreationTime = DateTime.UtcNow,
                Issuer = "issuer",
                Lifetime = 60,
                Claims = claims.Distinct(new ClaimComparer()).ToList(),
                ClientId = "client"
            };
        }
        
        [Fact]
        public void Should_create_scopes_as_array_by_default()
        {
            var options = new IdentityServerOptions();
            var payload = _token.CreateJwtPayload(new SystemClock(), options, TestLogger.Create());

            payload.Should().NotBeNull();
            var scopes = payload.Claims.Where(c => c.Type == JwtClaimTypes.Scope).ToArray();
            scopes.Count().Should().Be(3);
            scopes[0].Value.Should().Be("scope1");
            scopes[1].Value.Should().Be("scope2");
            scopes[2].Value.Should().Be("scope3");
        }
        
        [Fact]
        public void Should_create_scopes_as_string()
        {
            var options = new IdentityServerOptions
            {
                EmitScopesAsSpaceDelimitedStringInJwt = true
            };
            
            var payload = _token.CreateJwtPayload(new SystemClock(), options, TestLogger.Create());

            payload.Should().NotBeNull();
            var scopes = payload.Claims.Where(c => c.Type == JwtClaimTypes.Scope).ToList();
            scopes.Count().Should().Be(1);
            scopes.First().Value.Should().Be("scope1 scope2 scope3");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/StringExtensionsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Extensions;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class StringExtensionsTests
    {
        private void CheckOrigin(string inputUrl, string expectedOrigin)
        {
            var actualOrigin = inputUrl.GetOrigin();
            Assert.Equal(expectedOrigin, actualOrigin);
        }

        [Fact]
        public void TestGetOrigin()
        {
            CheckOrigin("http://idsvr.com", "http://idsvr.com");
            CheckOrigin("http://idsvr.com/", "http://idsvr.com");
            CheckOrigin("http://idsvr.com/test", "http://idsvr.com");
            CheckOrigin("http://idsvr.com/test/resource", "http://idsvr.com");
            CheckOrigin("http://idsvr.com:8080", "http://idsvr.com:8080");
            CheckOrigin("http://idsvr.com:8080/", "http://idsvr.com:8080");
            CheckOrigin("http://idsvr.com:8080/test", "http://idsvr.com:8080");
            CheckOrigin("http://idsvr.com:8080/test/resource", "http://idsvr.com:8080");
            CheckOrigin("http://127.0.0.1", "http://127.0.0.1");
            CheckOrigin("http://127.0.0.1/", "http://127.0.0.1");
            CheckOrigin("http://127.0.0.1/test", "http://127.0.0.1");
            CheckOrigin("http://127.0.0.1/test/resource", "http://127.0.0.1");
            CheckOrigin("http://127.0.0.1:8080", "http://127.0.0.1:8080");
            CheckOrigin("http://127.0.0.1:8080/", "http://127.0.0.1:8080");
            CheckOrigin("http://127.0.0.1:8080/test", "http://127.0.0.1:8080");
            CheckOrigin("http://127.0.0.1:8080/test/resource", "http://127.0.0.1:8080");
            CheckOrigin("http://localhost", "http://localhost");
            CheckOrigin("http://localhost/", "http://localhost");
            CheckOrigin("http://localhost/test", "http://localhost");
            CheckOrigin("http://localhost/test/resource", "http://localhost");
            CheckOrigin("http://localhost:8080", "http://localhost:8080");
            CheckOrigin("http://localhost:8080/", "http://localhost:8080");
            CheckOrigin("http://localhost:8080/test", "http://localhost:8080");
            CheckOrigin("http://localhost:8080/test/resource", "http://localhost:8080");
            CheckOrigin("https://idsvr.com", "https://idsvr.com");
            CheckOrigin("https://idsvr.com/", "https://idsvr.com");
            CheckOrigin("https://idsvr.com/test", "https://idsvr.com");
            CheckOrigin("https://idsvr.com/test/resource", "https://idsvr.com");
            CheckOrigin("https://idsvr.com:8080", "https://idsvr.com:8080");
            CheckOrigin("https://idsvr.com:8080/", "https://idsvr.com:8080");
            CheckOrigin("https://idsvr.com:8080/test", "https://idsvr.com:8080");
            CheckOrigin("https://idsvr.com:8080/test/resource", "https://idsvr.com:8080");
            CheckOrigin("https://127.0.0.1", "https://127.0.0.1");
            CheckOrigin("https://127.0.0.1/", "https://127.0.0.1");
            CheckOrigin("https://127.0.0.1/test", "https://127.0.0.1");
            CheckOrigin("https://127.0.0.1/test/resource", "https://127.0.0.1");
            CheckOrigin("https://127.0.0.1:8080", "https://127.0.0.1:8080");
            CheckOrigin("https://127.0.0.1:8080/", "https://127.0.0.1:8080");
            CheckOrigin("https://127.0.0.1:8080/test", "https://127.0.0.1:8080");
            CheckOrigin("https://127.0.0.1:8080/test/resource", "https://127.0.0.1:8080");
            CheckOrigin("https://localhost", "https://localhost");
            CheckOrigin("https://localhost/", "https://localhost");
            CheckOrigin("https://localhost/test", "https://localhost");
            CheckOrigin("https://localhost/test/resource", "https://localhost");
            CheckOrigin("https://localhost:8080", "https://localhost:8080");
            CheckOrigin("https://localhost:8080/", "https://localhost:8080");
            CheckOrigin("https://localhost:8080/test", "https://localhost:8080");
            CheckOrigin("https://localhost:8080/test/resource", "https://localhost:8080");
            CheckOrigin("test://idsvr.com", null);
            CheckOrigin("test://idsvr.com/", null);
            CheckOrigin("test://idsvr.com/test", null);
            CheckOrigin("test://idsvr.com/test/resource", null);
            CheckOrigin("test://idsvr.com:8080", null);
            CheckOrigin("test://idsvr.com:8080/", null);
            CheckOrigin("test://idsvr.com:8080/test", null);
            CheckOrigin("test://idsvr.com:8080/test/resource", null);
            CheckOrigin("test://127.0.0.1", null);
            CheckOrigin("test://127.0.0.1/", null);
            CheckOrigin("test://127.0.0.1/test", null);
            CheckOrigin("test://127.0.0.1/test/resource", null);
            CheckOrigin("test://127.0.0.1:8080", null);
            CheckOrigin("test://127.0.0.1:8080/", null);
            CheckOrigin("test://127.0.0.1:8080/test", null);
            CheckOrigin("test://127.0.0.1:8080/test/resource", null);
            CheckOrigin("test://localhost", null);
            CheckOrigin("test://localhost/", null);
            CheckOrigin("test://localhost/test", null);
            CheckOrigin("test://localhost/test/resource", null);
            CheckOrigin("test://localhost:8080", null);
            CheckOrigin("test://localhost:8080/", null);
            CheckOrigin("test://localhost:8080/test", null);
            CheckOrigin("test://localhost:8080/test/resource", null);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Extensions/ValidatedAuthorizeRequestExtensionsTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Extensions
{
    public class ValidatedAuthorizeRequestExtensionsTests
    {
        [Fact]
        public void GetAcrValues_should_return_snapshot_of_values()
        {
            var request = new ValidatedAuthorizeRequest()
            {
                Raw = new System.Collections.Specialized.NameValueCollection()
            };
            request.AuthenticationContextReferenceClasses.Add("a");
            request.AuthenticationContextReferenceClasses.Add("b");
            request.AuthenticationContextReferenceClasses.Add("c");

            var acrs = request.GetAcrValues();
            foreach(var acr in acrs)
            {
                request.RemoveAcrValue(acr);
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Hosting/EndpointRouterTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Hosting;
using Microsoft.AspNetCore.Http;
using Xunit;
using static IdentityServer8.Constants;

namespace IdentityServer.UnitTests.Hosting
{
    public class EndpointRouterTests
    {
        private Dictionary _pathMap;
        private List _endpoints;
        private IdentityServerOptions _options;
        private EndpointRouter _subject;

        public EndpointRouterTests()
        {
            _pathMap = new Dictionary();
            _endpoints = new List();
            _options = new IdentityServerOptions();
            _subject = new EndpointRouter(_endpoints, _options, TestLogger.Create());
        }

        [Fact]
        public void Endpoint_ctor_requires_path_to_start_with_slash()
        {
            Action a = () => new IdentityServer8.Hosting.Endpoint("ep1", "ep1", typeof(MyEndpointHandler));
            a.Should().Throw();
        }

        [Fact]
        public void Find_should_return_null_for_incorrect_path()
        {
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep1", "/ep1", typeof(MyEndpointHandler)));
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep2", "/ep2", typeof(MyOtherEndpointHandler)));

            var ctx = new DefaultHttpContext();
            ctx.Request.Path = new PathString("/wrong");
            ctx.RequestServices = new StubServiceProvider();

            var result = _subject.Find(ctx);
            result.Should().BeNull();
        }

        [Fact]
        public void Find_should_find_path()
        {
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep1", "/ep1", typeof(MyEndpointHandler)));
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep2", "/ep2", typeof(MyOtherEndpointHandler)));

            var ctx = new DefaultHttpContext();
            ctx.Request.Path = new PathString("/ep1");
            ctx.RequestServices = new StubServiceProvider();

            var result = _subject.Find(ctx);
            result.Should().BeOfType();
        }

        [Fact]
        public void Find_should_not_find_nested_paths()
        {
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep1", "/ep1", typeof(MyEndpointHandler)));
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep2", "/ep2", typeof(MyOtherEndpointHandler)));

            var ctx = new DefaultHttpContext();
            ctx.Request.Path = new PathString("/ep1/subpath");
            ctx.RequestServices = new StubServiceProvider();

            var result = _subject.Find(ctx);
            result.Should().BeNull();
        }

        [Fact]
        public void Find_should_find_first_registered_mapping()
        {
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep1", "/ep1", typeof(MyEndpointHandler)));
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep1", "/ep1", typeof(MyOtherEndpointHandler)));

            var ctx = new DefaultHttpContext();
            ctx.Request.Path = new PathString("/ep1");
            ctx.RequestServices = new StubServiceProvider();

            var result = _subject.Find(ctx);
            result.Should().BeOfType();
        }

        [Fact]
        public void Find_should_return_null_for_disabled_endpoint()
        {
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint(EndpointNames.Authorize, "/ep1", typeof(MyEndpointHandler)));
            _endpoints.Add(new IdentityServer8.Hosting.Endpoint("ep2", "/ep2", typeof(MyOtherEndpointHandler)));

            _options.Endpoints.EnableAuthorizeEndpoint = false;

            var ctx = new DefaultHttpContext();
            ctx.Request.Path = new PathString("/ep1");
            ctx.RequestServices = new StubServiceProvider();

            var result = _subject.Find(ctx);
            result.Should().BeNull();
        }

        private class MyEndpointHandler : IEndpointHandler
        {
            public Task ProcessAsync(HttpContext context)
            {
                throw new NotImplementedException();
            }
        }

        private class MyOtherEndpointHandler : IEndpointHandler
        {
            public Task ProcessAsync(HttpContext context)
            {
                throw new NotImplementedException();
            }
        }

        private class StubServiceProvider : IServiceProvider
        {
            public object GetService(Type serviceType)
            {
                if (serviceType == typeof(MyEndpointHandler)) return new MyEndpointHandler();
                if (serviceType == typeof(MyOtherEndpointHandler)) return new MyOtherEndpointHandler();

                throw new InvalidOperationException();
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/IdentityServer.UnitTests.csproj
================================================



  
    ../../../../key.snk
    true
    true
  

 
  
    

    
    
    
    
      runtime; build; native; contentfiles; analyzers; buildtransitive
      all
    
  

  
    
      Always
    
    
      Always
    
  

  
    
  



================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Infrastructure/ObjectSerializerTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using FluentAssertions;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer.UnitTests.Infrastructure
{
    public class ObjectSerializerTests
    {
        public ObjectSerializerTests()
        {
        }

        [Fact]
        public void Can_be_deserialize_message()
        {
            Action a = () => IdentityServer8.ObjectSerializer.FromString>("{\"created\":0, \"data\": {\"error\": \"error\"}}");
            a.Should().NotThrow();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/AuthorizeInteractionResponseGenerator/AuthorizeInteractionResponseGeneratorTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;
using static IdentityModel.OidcConstants;

namespace IdentityServer.UnitTests.ResponseHandling.AuthorizeInteractionResponseGenerator
{
    public class AuthorizeInteractionResponseGeneratorTests
    {
        private IdentityServerOptions _options = new IdentityServerOptions();
        private IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator _subject;
        private MockConsentService _mockConsentService = new MockConsentService();
        private StubClock _clock = new StubClock();

        public AuthorizeInteractionResponseGeneratorTests()
        {
            _subject = new IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator(
                _clock,
                TestLogger.Create(),
                _mockConsentService,
                new MockProfileService());
        }


        [Fact]
        public async Task Authenticated_User_with_restricted_current_Idp_with_prompt_none_must_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                    EnableLocalLogin = false,
                    IdentityProviderRestrictions = new List
                    {
                        "some_idp"
                    }
                },
                PromptModes = new[] { PromptModes.None },
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_with_maxage_with_prompt_none_must_error()
        {
            _clock.UtcNowFunc = () => new DateTime(2020, 02, 03, 9, 0, 0);

            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    AuthenticationTime = new DateTime(2020, 02, 01, 9, 0, 0),
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                    EnableLocalLogin = true,
                },
                PromptModes = new[] { PromptModes.None },
                MaxAge = 3600
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_with_different_requested_Idp_with_prompt_none_must_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client(),
                AuthenticationContextReferenceClasses = new List{
                    "idp:some_idp"
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                PromptModes = new[] { PromptModes.None }
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_beyond_client_user_sso_lifetime_with_prompt_none_should_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client()
                {
                    UserSsoLifetime = 3600 // 1h
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = "local",
                    AuthenticationTime = _clock.UtcNow.UtcDateTime.Subtract(TimeSpan.FromSeconds(3700))
                }.CreatePrincipal(),
                PromptModes = new[] { PromptModes.None }
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task locally_authenticated_user_but_client_does_not_allow_local_with_prompt_none_should_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client()
                {
                    EnableLocalLogin = false
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                PromptModes = new[] { PromptModes.None }
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.IsLogin.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/AuthorizeInteractionResponseGenerator/AuthorizeInteractionResponseGeneratorTests_Consent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.ResponseHandling.AuthorizeInteractionResponseGenerator
{
    public class AuthorizeInteractionResponseGeneratorTests_Consent
    {
        private IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator _subject;
        private IdentityServerOptions _options = new IdentityServerOptions();
        private MockConsentService _mockConsent = new MockConsentService();
        private MockProfileService _fakeUserService = new MockProfileService();

        private void RequiresConsent(bool value)
        {
            _mockConsent.RequiresConsentResult = value;
        }

        private void AssertUpdateConsentNotCalled()
        {
            _mockConsent.ConsentClient.Should().BeNull();
            _mockConsent.ConsentSubject.Should().BeNull();
            _mockConsent.ConsentScopes.Should().BeNull();
        }

        private void AssertUpdateConsentCalled(Client client, ClaimsPrincipal user, params string[] scopes)
        {
            _mockConsent.ConsentClient.Should().BeSameAs(client);
            _mockConsent.ConsentSubject.Should().BeSameAs(user);
            _mockConsent.ConsentScopes.Should().BeEquivalentTo(scopes);
        }

        private static IEnumerable GetIdentityScopes()
        {
            return new IdentityResource[]
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile(),
                new IdentityResources.Email()
            };
        }

        private static IEnumerable GetApiResources()
        {
            return new ApiResource[]
            {
                new ApiResource
                {
                    Name = "api",
                    Scopes = { "read", "write", "forbidden" }
                }
             };
        }

        private static IEnumerable GetScopes()
        {
            return new ApiScope[]
            {
                new ApiScope
                {
                    Name = "read",
                    DisplayName = "Read data",
                    Emphasize = false
                },
                new ApiScope
                {
                    Name = "write",
                    DisplayName = "Write data",
                    Emphasize = true
                },
                new ApiScope
                {
                    Name = "forbidden",
                    DisplayName = "Forbidden scope",
                    Emphasize = true
                }
             };
        }

        public AuthorizeInteractionResponseGeneratorTests_Consent()
        {
            _subject = new IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator(
                new StubClock(),
                TestLogger.Create(),
                _mockConsent,
                _fakeUserService);
        }

        private static ResourceValidationResult GetValidatedResources(params string[] scopes)
        {
            var resources = new Resources(GetIdentityScopes(), GetApiResources(), GetScopes());
            return new ResourceValidationResult(resources).Filter(scopes);
        }


        [Fact]
        public async Task ProcessConsentAsync_NullRequest_Throws()
        {
            Func act = async () => await _subject.ProcessConsentAsync(null, new ConsentResponse());

            (await act.Should().ThrowAsync())
                .And.ParamName.Should().Be("request");
        }

        [Fact]
        public async Task ProcessConsentAsync_AllowsNullConsent()
        {
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.Consent },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            await _subject.ProcessConsentAsync(request, null);
        }

        [Fact]
        public async Task ProcessConsentAsync_PromptModeIsLogin_Throws()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.Login },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };

            Func act = async () => await _subject.ProcessConsentAsync(request);

            (await act.Should().ThrowAsync())
                .And.Message.Should().Contain("PromptMode");
        }

        [Fact]
        public async Task ProcessConsentAsync_PromptModeIsSelectAccount_Throws()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.SelectAccount },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };

            Func act = async () => await _subject.ProcessConsentAsync(request);

            (await act.Should().ThrowAsync())
                 .And.Message.Should().Contain("PromptMode");
        }


        [Fact]
        public async Task ProcessConsentAsync_RequiresConsentButPromptModeIsNone_ReturnsErrorResult()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.None },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var result = await _subject.ProcessConsentAsync(request);

            request.WasConsentShown.Should().BeFalse();
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.ConsentRequired);
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_PromptModeIsConsent_NoPriorConsent_ReturnsConsentResult()
        {
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.Consent },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var result = await _subject.ProcessConsentAsync(request);
            request.WasConsentShown.Should().BeFalse();
            result.IsConsent.Should().BeTrue();
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_NoPriorConsent_ReturnsConsentResult()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.Consent },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var result = await _subject.ProcessConsentAsync(request);
            request.WasConsentShown.Should().BeFalse();
            result.IsConsent.Should().BeTrue();
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_PromptModeIsConsent_ConsentNotGranted_ReturnsErrorResult()
        {
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                PromptModes = new[] { OidcConstants.PromptModes.Consent },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };

            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            request.WasConsentShown.Should().BeTrue();
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.AccessDenied);
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_ConsentNotGranted_ReturnsErrorResult()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            request.WasConsentShown.Should().BeTrue();
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.AccessDenied);
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_ConsentGrantedButMissingRequiredScopes_ReturnsErrorResult()
        {
            RequiresConsent(true);
            var client = new Client { };
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
                Client = client
            };

            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { "read" }
            };

            var result = await _subject.ProcessConsentAsync(request, consent);
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.AccessDenied);
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_NoPromptMode_ConsentServiceRequiresConsent_ConsentGranted_ScopesSelected_ReturnsConsentResult()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                Client = new Client
                {
                    AllowRememberConsent = false
                },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { "openid", "read" }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            request.ValidatedResources.Resources.IdentityResources.Count().Should().Be(1);
            request.ValidatedResources.Resources.ApiScopes.Count().Should().Be(1);
            "openid".Should().Be(request.ValidatedResources.Resources.IdentityResources.Select(x => x.Name).First());
            "read".Should().Be(request.ValidatedResources.Resources.ApiScopes.First().Name);
            request.WasConsentShown.Should().BeTrue();
            result.IsConsent.Should().BeFalse();
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_PromptModeConsent_ConsentGranted_ScopesSelected_ReturnsConsentResult()
        {
            RequiresConsent(true);
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                Client = new Client
                {
                    AllowRememberConsent = false
                },
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { "openid", "read" }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            request.ValidatedResources.Resources.IdentityResources.Count().Should().Be(1);
            request.ValidatedResources.Resources.ApiScopes.Count().Should().Be(1);
            "read".Should().Be(request.ValidatedResources.Resources.ApiScopes.First().Name);
            request.WasConsentShown.Should().BeTrue();
            result.IsConsent.Should().BeFalse();
            AssertUpdateConsentNotCalled();
        }

        [Fact]
        public async Task ProcessConsentAsync_AllowConsentSelected_SavesConsent()
        {
            RequiresConsent(true);
            var client = new Client { AllowRememberConsent = true };
            var user = new ClaimsPrincipal();
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                Client = client,
                Subject = user,
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var consent = new ConsentResponse
            {
                RememberConsent = true,
                ScopesValuesConsented = new string[] { "openid", "read" }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            AssertUpdateConsentCalled(client, user, "openid", "read");
        }

        [Fact]
        public async Task ProcessConsentAsync_NotRememberingConsent_DoesNotSaveConsent()
        {
            RequiresConsent(true);
            var client = new Client { AllowRememberConsent = true };
            var user = new ClaimsPrincipal();
            var request = new ValidatedAuthorizeRequest()
            {
                ResponseMode = OidcConstants.ResponseModes.Fragment,
                State = "12345",
                RedirectUri = "https://client.com/callback",
                Client = client,
                Subject = user,
                RequestedScopes = new List { "openid", "read", "write" },
                ValidatedResources = GetValidatedResources("openid", "read", "write"),
            };
            var consent = new ConsentResponse
            {
                RememberConsent = false,
                ScopesValuesConsented = new string[] { "openid", "read" }
            };
            var result = await _subject.ProcessConsentAsync(request, consent);
            AssertUpdateConsentCalled(client, user);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/AuthorizeInteractionResponseGenerator/AuthorizeInteractionResponseGeneratorTests_Custom.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;
using Xunit;
using static IdentityModel.OidcConstants;

namespace IdentityServer.UnitTests.ResponseHandling.AuthorizeInteractionResponseGenerator
{
    public class CustomAuthorizeInteractionResponseGenerator : IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator
    {
        public CustomAuthorizeInteractionResponseGenerator(ISystemClock clock, ILogger logger, IConsentService consent, IProfileService profile) : base(clock, logger, consent, profile)
        {
        }

        public InteractionResponse ProcessLoginResponse { get; set; }
        protected internal override Task ProcessLoginAsync(ValidatedAuthorizeRequest request)
        {
            if (ProcessLoginResponse != null)
            {
                return Task.FromResult(ProcessLoginResponse);
            }

            return base.ProcessLoginAsync(request);
        }

        public InteractionResponse ProcessConsentResponse { get; set; }
        protected internal override Task ProcessConsentAsync(ValidatedAuthorizeRequest request, ConsentResponse consent = null)
        {
            if (ProcessConsentResponse != null)
            {
                return Task.FromResult(ProcessConsentResponse);
            }
            return base.ProcessConsentAsync(request, consent);
        }
    }

    public class AuthorizeInteractionResponseGeneratorTests_Custom
    {
        private IdentityServerOptions _options = new IdentityServerOptions();
        private CustomAuthorizeInteractionResponseGenerator _subject;
        private MockConsentService _mockConsentService = new MockConsentService();
        private StubClock _clock = new StubClock();

        public AuthorizeInteractionResponseGeneratorTests_Custom()
        {
            _subject = new CustomAuthorizeInteractionResponseGenerator(
                _clock,
                TestLogger.Create(),
                _mockConsentService,
                new MockProfileService());
        }


        [Fact]
        public async Task ProcessInteractionAsync_with_overridden_login_returns_redirect_should_return_redirect()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                },
            };

            _subject.ProcessLoginResponse = new InteractionResponse
            {
                RedirectUrl = "/custom"
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsRedirect.Should().BeTrue();
            result.RedirectUrl.Should().Be("/custom");
        }

        [Fact]
        public async Task ProcessInteractionAsync_with_prompt_none_and_login_returns_login_should_return_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                },
                PromptModes = new[] { PromptModes.None },
            };

            _subject.ProcessLoginResponse = new InteractionResponse
            {
                IsLogin = true
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be("login_required");
        }

        [Fact]
        public async Task ProcessInteractionAsync_with_prompt_none_and_login_returns_redirect_should_return_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                },
                PromptModes = new[] { PromptModes.None },
            };

            _subject.ProcessLoginResponse = new InteractionResponse
            {
                RedirectUrl = "/custom"
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be("interaction_required");
            result.RedirectUrl.Should().BeNull();
        }

        [Fact]
        public async Task ProcessInteractionAsync_with_prompt_none_and_consent_returns_consent_should_return_error()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                },
                PromptModes = new[] { PromptModes.None },
            };

            _subject.ProcessConsentResponse = new InteractionResponse
            {
                IsConsent = true
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be("consent_required");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/AuthorizeInteractionResponseGenerator/AuthorizeInteractionResponseGeneratorTests_Login.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.ResponseHandling.AuthorizeInteractionResponseGenerator
{
    public class AuthorizeInteractionResponseGeneratorTests_Login
    {
        private IdentityServerOptions _options = new IdentityServerOptions();
        private IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator _subject;
        private MockConsentService _mockConsentService = new MockConsentService();
        private StubClock _clock = new StubClock();

        public AuthorizeInteractionResponseGeneratorTests_Login()
        {
            _subject = new IdentityServer8.ResponseHandling.AuthorizeInteractionResponseGenerator(
                _clock,
                TestLogger.Create(),
                _mockConsentService,
                new MockProfileService());
        }

        [Fact]
        public async Task Anonymous_User_must_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = Principal.Anonymous
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task Authenticated_User_must_not_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client(),
                ValidatedResources = new ResourceValidationResult(),
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessInteractionAsync(request);

            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_with_allowed_current_Idp_must_not_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123") {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client 
                {
                    IdentityProviderRestrictions = new List 
                    {
                        IdentityServerConstants.LocalIdentityProvider
                    }
                }
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_with_restricted_current_Idp_must_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal(),
                Client = new Client
                {
                    EnableLocalLogin = false,
                    IdentityProviderRestrictions = new List 
                    {
                        "some_idp"
                    }
                }
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task Authenticated_User_with_allowed_requested_Idp_must_not_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client(),
                 AuthenticationContextReferenceClasses = new List{
                    "idp:" + IdentityServerConstants.LocalIdentityProvider
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_with_different_requested_Idp_must_SignIn()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client(),
                AuthenticationContextReferenceClasses = new List{
                    "idp:some_idp"
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task Authenticated_User_within_client_user_sso_lifetime_should_not_signin()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client() {
                    UserSsoLifetime = 3600 // 1h
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = "local",
                    AuthenticationTime = _clock.UtcNow.UtcDateTime.Subtract(TimeSpan.FromSeconds(10))
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeFalse();
        }

        [Fact]
        public async Task Authenticated_User_beyond_client_user_sso_lifetime_should_signin()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client()
                {
                    UserSsoLifetime = 3600 // 1h
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = "local",
                    AuthenticationTime = _clock.UtcNow.UtcDateTime.Subtract(TimeSpan.FromSeconds(3700))
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task locally_authenticated_user_but_client_does_not_allow_local_should_sign_in()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Client = new Client()
                {
                    EnableLocalLogin = false
                },
                Subject = new IdentityServerUser("123")
                {
                    IdentityProvider = IdentityServerConstants.LocalIdentityProvider
                }.CreatePrincipal()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task prompt_login_should_sign_in()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                PromptModes = new[] { OidcConstants.PromptModes.Login },
                Raw = new NameValueCollection()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task prompt_select_account_should_sign_in()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                PromptModes = new[] { OidcConstants.PromptModes.SelectAccount },
                Raw = new NameValueCollection()
            };

            var result = await _subject.ProcessLoginAsync(request);

            result.IsLogin.Should().BeTrue();
        }

        [Fact]
        public async Task prompt_for_signin_should_remove_prompt_from_raw_url()
        {
            var request = new ValidatedAuthorizeRequest
            {
                ClientId = "foo",
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                PromptModes = new[] { OidcConstants.PromptModes.Login },
                Raw = new NameValueCollection
                {
                    { OidcConstants.AuthorizeRequest.Prompt, OidcConstants.PromptModes.Login }
                }
            };

            var result = await _subject.ProcessLoginAsync(request);

            request.Raw.AllKeys.Should().NotContain(OidcConstants.AuthorizeRequest.Prompt);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/DeviceAuthorizationResponseGeneratorTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Services;
using IdentityServer8.Services.Default;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging.Abstractions;
using Xunit;

namespace IdentityServer.UnitTests.ResponseHandling
{
    public class DeviceAuthorizationResponseGeneratorTests
    {
        private readonly List identityResources = new List {new IdentityResources.OpenId(), new IdentityResources.Profile()};
        private readonly List apiResources = new List { new ApiResource("resource") { Scopes = {"api1" } } };
        private readonly List scopes = new List { new ApiScope("api1") };

        private readonly FakeUserCodeGenerator fakeUserCodeGenerator = new FakeUserCodeGenerator();
        private readonly IDeviceFlowCodeService deviceFlowCodeService = new DefaultDeviceFlowCodeService(new InMemoryDeviceFlowStore(), new StubHandleGenerationService());
        private readonly IdentityServerOptions options = new IdentityServerOptions();
        private readonly StubClock clock = new StubClock();
        
        private readonly DeviceAuthorizationResponseGenerator generator;
        private readonly DeviceAuthorizationRequestValidationResult testResult;
        private const string TestBaseUrl = "http://localhost:5000/";

        public DeviceAuthorizationResponseGeneratorTests()
        {
            testResult = new DeviceAuthorizationRequestValidationResult(new ValidatedDeviceAuthorizationRequest
            {
                Client = new Client {ClientId = Guid.NewGuid().ToString()},
                IsOpenIdRequest = true,
                ValidatedResources = new ResourceValidationResult()
            });

            generator = new DeviceAuthorizationResponseGenerator(
                options,
                new DefaultUserCodeService(new IUserCodeGenerator[] {new NumericUserCodeGenerator(), fakeUserCodeGenerator }),
                deviceFlowCodeService,
                clock,
                new NullLogger());
        }

        [Fact]
        public async Task ProcessAsync_when_valiationresult_null_exect_exception()
        {
            Func act = async () => await generator.ProcessAsync(null, TestBaseUrl);
            await act.Should().ThrowAsync();
        }

        [Fact]
        public void ProcessAsync_when_valiationresult_client_null_exect_exception()
        {
            var validationResult = new DeviceAuthorizationRequestValidationResult(new ValidatedDeviceAuthorizationRequest());
            Func  act = () => generator.ProcessAsync(validationResult, TestBaseUrl);
            act.Should().ThrowAsync();
        }

        [Fact]
        public void ProcessAsync_when_baseurl_null_exect_exception()
        {
            Func act = () => generator.ProcessAsync(testResult, null);
            act.Should().ThrowAsync();
        }

        [Fact]
        public async Task ProcessAsync_when_user_code_collision_expect_retry()
        {
            var creationTime = DateTime.UtcNow;
            clock.UtcNowFunc = () => creationTime;

            testResult.ValidatedRequest.Client.UserCodeType = FakeUserCodeGenerator.UserCodeTypeValue;
            await deviceFlowCodeService.StoreDeviceAuthorizationAsync(FakeUserCodeGenerator.TestCollisionUserCode, new DeviceCode());

            var response = await generator.ProcessAsync(testResult, TestBaseUrl);

            response.UserCode.Should().Be(FakeUserCodeGenerator.TestUniqueUserCode);
        }

        [Fact]
        public async Task ProcessAsync_when_user_code_collision_retry_limit_reached_expect_error()
        {
            var creationTime = DateTime.UtcNow;
            clock.UtcNowFunc = () => creationTime;

            fakeUserCodeGenerator.RetryLimit = 1;
            testResult.ValidatedRequest.Client.UserCodeType = FakeUserCodeGenerator.UserCodeTypeValue;
            await deviceFlowCodeService.StoreDeviceAuthorizationAsync(FakeUserCodeGenerator.TestCollisionUserCode, new DeviceCode());

            await Assert.ThrowsAsync(() => generator.ProcessAsync(testResult, TestBaseUrl));
        }

        [Fact]
        public async Task ProcessAsync_when_generated_expect_user_code_stored()
        {
            var creationTime = DateTime.UtcNow;
            clock.UtcNowFunc = () => creationTime;

            testResult.ValidatedRequest.RequestedScopes = new List { "openid", "api1" };
            testResult.ValidatedRequest.ValidatedResources = new ResourceValidationResult(new Resources(
                identityResources.Where(x=>x.Name == "openid"), 
                apiResources.Where(x=>x.Name == "resource"), 
                scopes.Where(x=>x.Name == "api1")));

            var response = await generator.ProcessAsync(testResult, TestBaseUrl);

            response.UserCode.Should().NotBeNullOrWhiteSpace();

            var userCode = await deviceFlowCodeService.FindByUserCodeAsync(response.UserCode);
            userCode.Should().NotBeNull();
            userCode.ClientId.Should().Be(testResult.ValidatedRequest.Client.ClientId);
            userCode.Lifetime.Should().Be(testResult.ValidatedRequest.Client.DeviceCodeLifetime);
            userCode.CreationTime.Should().Be(creationTime);
            userCode.Subject.Should().BeNull();
            userCode.AuthorizedScopes.Should().BeNull();

            userCode.RequestedScopes.Should().Contain(testResult.ValidatedRequest.RequestedScopes);
        }

        [Fact]
        public async Task ProcessAsync_when_generated_expect_device_code_stored()
        {
            var creationTime = DateTime.UtcNow;
            clock.UtcNowFunc = () => creationTime;

            var response = await generator.ProcessAsync(testResult, TestBaseUrl);

            response.DeviceCode.Should().NotBeNullOrWhiteSpace();
            response.Interval.Should().Be(options.DeviceFlow.Interval);
            
            var deviceCode = await deviceFlowCodeService.FindByDeviceCodeAsync(response.DeviceCode);
            deviceCode.Should().NotBeNull();
            deviceCode.ClientId.Should().Be(testResult.ValidatedRequest.Client.ClientId);
            deviceCode.IsOpenId.Should().Be(testResult.ValidatedRequest.IsOpenIdRequest);
            deviceCode.Lifetime.Should().Be(testResult.ValidatedRequest.Client.DeviceCodeLifetime);
            deviceCode.CreationTime.Should().Be(creationTime);
            deviceCode.Subject.Should().BeNull();
            deviceCode.AuthorizedScopes.Should().BeNull();
            
            response.DeviceCodeLifetime.Should().Be(deviceCode.Lifetime);
        }

        [Fact]
        public async Task ProcessAsync_when_DeviceVerificationUrl_is_relative_uri_expect_correct_VerificationUris()
        {
            const string baseUrl = "http://localhost:5000/";
            options.UserInteraction.DeviceVerificationUrl = "/device";
            options.UserInteraction.DeviceVerificationUserCodeParameter = "userCode";

            var response = await generator.ProcessAsync(testResult, baseUrl);

            response.VerificationUri.Should().Be("http://localhost:5000/device");
            response.VerificationUriComplete.Should().StartWith("http://localhost:5000/device?userCode=");
        }

        [Fact]
        public async Task ProcessAsync_when_DeviceVerificationUrl_is_absolute_uri_expect_correct_VerificationUris()
        {
            const string baseUrl = "http://localhost:5000/";
            options.UserInteraction.DeviceVerificationUrl = "http://short/device";
            options.UserInteraction.DeviceVerificationUserCodeParameter = "userCode";

            var response = await generator.ProcessAsync(testResult, baseUrl);

            response.VerificationUri.Should().Be("http://short/device");
            response.VerificationUriComplete.Should().StartWith("http://short/device?userCode=");
        }
    }

    internal class FakeUserCodeGenerator : IUserCodeGenerator
    {
        public const string UserCodeTypeValue = "Collider";
        public const string TestUniqueUserCode = "123";
        public const string TestCollisionUserCode = "321";
        private int tryCount = 0;
        private int retryLimit = 2;


        public string UserCodeType => UserCodeTypeValue;

        public int RetryLimit
        {
            get => retryLimit;
            set => retryLimit = value;
        }

        public Task GenerateAsync()
        {
            if (tryCount == 0)
            {
                tryCount++;
                return Task.FromResult(TestCollisionUserCode);
            }

            tryCount++;
            return Task.FromResult(TestUniqueUserCode);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/ResponseHandling/UserInfoResponseGeneratorTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Text.Json;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.ResponseHandling;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.ResponseHandling
{
    public class UserInfoResponseGeneratorTests
    {
        private UserInfoResponseGenerator _subject;
        private MockProfileService _mockProfileService = new MockProfileService();
        private ClaimsPrincipal _user;
        private Client _client;

        private InMemoryResourcesStore _resourceStore;
        private List _identityResources = new List();
        private List _apiResources = new List();
        private List _apiScopes = new List();

        public UserInfoResponseGeneratorTests()
        {
            _client = new Client
            {
                ClientId = "client"
            };

            _user = new IdentityServerUser("bob")
            {
                AdditionalClaims =
                {
                    new Claim("foo", "foo1"),
                    new Claim("foo", "foo2"),
                    new Claim("bar", "bar1"),
                    new Claim("bar", "bar2")
                }
            }.CreatePrincipal();

            _resourceStore = new InMemoryResourcesStore(_identityResources, _apiResources, _apiScopes);
            _subject = new UserInfoResponseGenerator(_mockProfileService, _resourceStore, TestLogger.Create());
        }

        [Fact]
        public async Task GetRequestedClaimTypesAsync_when_no_scopes_requested_should_return_empty_claim_types()
        {
            var resources = await _subject.GetRequestedResourcesAsync(null);
            var claims = await _subject.GetRequestedClaimTypesAsync(resources);
            claims.Should().BeEquivalentTo(new string[] { });
        }

        [Fact]
        public async Task GetRequestedClaimTypesAsync_should_return_correct_identity_claims()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "c1", "c2" }));
            _identityResources.Add(new IdentityResource("id2", new[] { "c2", "c3" }));

            var resources = await _subject.GetRequestedResourcesAsync(new[] { "id1", "id2", "id3" });
            var claims = await _subject.GetRequestedClaimTypesAsync(resources);
            claims.Should().BeEquivalentTo(new string[] { "c1", "c2", "c3" });
        }

        [Fact]
        public async Task GetRequestedClaimTypesAsync_should_only_return_enabled_identity_claims()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "c1", "c2" }) { Enabled = false });
            _identityResources.Add(new IdentityResource("id2", new[] { "c2", "c3" }));

            var resources = await _subject.GetRequestedResourcesAsync(new[] { "id1", "id2", "id3" });
            var claims = await _subject.GetRequestedClaimTypesAsync(resources);
            claims.Should().BeEquivalentTo(new string[] { "c2", "c3" });
        }

        [Fact]
        public async Task ProcessAsync_should_call_profile_service_with_requested_claim_types()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _identityResources.Add(new IdentityResource("id2", new[] { "bar" }));

            var result = new UserInfoRequestValidationResult
            {
                Subject = _user,
                TokenValidationResult = new TokenValidationResult
                {
                    Claims = new List
                    {
                        { new Claim("scope", "id1") },
                        { new Claim("scope", "id2") },
                        { new Claim("scope", "id3") }
                    },
                    Client = _client
                }
            };

            var claims = await _subject.ProcessAsync(result);

            _mockProfileService.GetProfileWasCalled.Should().BeTrue();
            _mockProfileService.ProfileContext.RequestedClaimTypes.Should().BeEquivalentTo(new[] { "foo", "bar" });
        }

        [Fact]
        public async Task ProcessAsync_should_return_claims_issued_by_profile_service()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _identityResources.Add(new IdentityResource("id2", new[] { "bar" }));
            
            var address = new
            {
                street_address = "One Hacker Way",
                locality = "Heidelberg",
                postal_code = 69118,
                country = "Germany"
            };
            
            _mockProfileService.ProfileClaims = new[]
            {
                new Claim("email", "fred@gmail.com"),
                new Claim("name", "fred jones"),
                new Claim("address", @"{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }", IdentityServerConstants.ClaimValueTypes.Json),
                new Claim("address2", JsonSerializer.Serialize(address), IdentityServerConstants.ClaimValueTypes.Json)
            };

            var result = new UserInfoRequestValidationResult
            {
                Subject = _user,
                TokenValidationResult = new TokenValidationResult
                {
                    Claims = new List
                    {
                        { new Claim("scope", "id1") },
                        { new Claim("scope", "id2") },
                        { new Claim("scope", "id3") }
                    },
                    Client = _client
                }
            };

            var claims = await _subject.ProcessAsync(result);

            claims.Should().ContainKey("email");
            claims["email"].Should().Be("fred@gmail.com");
            claims.Should().ContainKey("name");
            claims["name"].Should().Be("fred jones");
            
            // this will be treated as a string because this is not valid JSON from the System.Text library point of view
            claims.Should().ContainKey("address");
            claims["address"].Should().Be("{ 'street_address': 'One Hacker Way', 'locality': 'Heidelberg', 'postal_code': 69118, 'country': 'Germany' }");
            
            // this is a JsonElement
            claims.Should().ContainKey("address2");
            claims["address2"].ToString().Should().Be("{\"street_address\":\"One Hacker Way\",\"locality\":\"Heidelberg\",\"postal_code\":69118,\"country\":\"Germany\"}");
        }

        [Fact]
        public async Task ProcessAsync_should_return_sub_from_user()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _identityResources.Add(new IdentityResource("id2", new[] { "bar" }));

            var result = new UserInfoRequestValidationResult
            {
                Subject = _user,
                TokenValidationResult = new TokenValidationResult
                {
                    Claims = new List
                    {
                        { new Claim("scope", "id1") },
                        { new Claim("scope", "id2") },
                        { new Claim("scope", "id3") }
                    },
                    Client = _client
                }
            };

            var claims = await _subject.ProcessAsync(result);

            claims.Should().ContainKey("sub");
            claims["sub"].Should().Be("bob");
        }

        [Fact]
        public async Task ProcessAsync_should_throw_if_incorrect_sub_issued_by_profile_service()
        {
            _identityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _identityResources.Add(new IdentityResource("id2", new[] { "bar" }));
            _mockProfileService.ProfileClaims = new[]
            {
                new Claim("sub", "fred")
            };

            var result = new UserInfoRequestValidationResult
            {
                Subject = _user,
                TokenValidationResult = new TokenValidationResult
                {
                    Claims = new List
                    {
                        { new Claim("scope", "id1") },
                        { new Claim("scope", "id2") },
                        { new Claim("scope", "id3") }
                    },
                    Client = _client
                }
            };

            Func act = async () => await _subject.ProcessAsync(result);

            (await act.Should().ThrowAsync())
                .And.Message.Should().Contain("subject");
        }

    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultClaimsServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultClaimsServiceTests
    {
        private DefaultClaimsService _subject;
        private MockProfileService _mockMockProfileService = new MockProfileService();

        private ClaimsPrincipal _user;
        private Client _client;
        private ValidatedRequest _validatedRequest;
        private Resources _resources = new Resources();

        public ResourceValidationResult ResourceValidationResult => new ResourceValidationResult(_resources);

        public DefaultClaimsServiceTests()
        {
            _client = new Client
            {
                ClientId = "client",
                Claims = { new ClientClaim("some_claim", "some_claim_value") }
            };

            _user = new IdentityServerUser("bob")
            {
                IdentityProvider = "idp",
                AuthenticationMethods = { OidcConstants.AuthenticationMethods.Password },
                AuthenticationTime = new System.DateTime(2000, 1, 1),
                AdditionalClaims =
                {
                    new Claim("foo", "foo1"),
                    new Claim("foo", "foo2"),
                    new Claim("bar", "bar1"),
                    new Claim("bar", "bar2"),
                    new Claim(JwtClaimTypes.AuthenticationContextClassReference, "acr1")
                }
            }.CreatePrincipal();

            _subject = new DefaultClaimsService(_mockMockProfileService, TestLogger.Create());

            _validatedRequest = new ValidatedRequest();
            _validatedRequest.Options = new IdentityServerOptions();
            _validatedRequest.SetClient(_client);
        }

        [Fact]
        public async Task GetIdentityTokenClaimsAsync_should_return_standard_user_claims()
        {
            var claims = await _subject.GetIdentityTokenClaimsAsync(_user, ResourceValidationResult, false, _validatedRequest);

            var types = claims.Select(x => x.Type);
            types.Should().Contain(JwtClaimTypes.Subject);
            types.Should().Contain(JwtClaimTypes.AuthenticationTime);
            types.Should().Contain(JwtClaimTypes.IdentityProvider);
            types.Should().Contain(JwtClaimTypes.AuthenticationMethod);
            types.Should().Contain(JwtClaimTypes.AuthenticationContextClassReference);
        }

        [Fact]
        public async Task GetIdentityTokenClaimsAsync_should_return_minimal_claims_when_includeAllIdentityClaims_is_false()
        {
            _resources.IdentityResources.Add(new IdentityResource("id_scope", new[] { "foo" }));

            var claims = await _subject.GetIdentityTokenClaimsAsync(_user, ResourceValidationResult, false, _validatedRequest);

            _mockMockProfileService.GetProfileWasCalled.Should().BeFalse();
        }

        [Fact]
        public async Task GetIdentityTokenClaimsAsync_should_return_all_claims_when_includeAllIdentityClaims_is_true()
        {
            _resources.IdentityResources.Add(new IdentityResource("id_scope", new[] { "foo" }));
            _mockMockProfileService.ProfileClaims.Add(new Claim("foo", "foo1"));

            var claims = await _subject.GetIdentityTokenClaimsAsync(_user, ResourceValidationResult, true, _validatedRequest);

            _mockMockProfileService.GetProfileWasCalled.Should().BeTrue();
            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("foo");
        }

        [Fact]
        public async Task GetIdentityTokenClaimsAsync_should_return_all_claims_when_client_configured_for_always_include_all_claims_in_id_token()
        {
            _client.AlwaysIncludeUserClaimsInIdToken = true;

            _resources.IdentityResources.Add(new IdentityResource("id_scope", new[] { "foo" }));
            _mockMockProfileService.ProfileClaims.Add(new Claim("foo", "foo1"));

            var claims = await _subject.GetIdentityTokenClaimsAsync(_user, ResourceValidationResult, false, _validatedRequest);

            _mockMockProfileService.GetProfileWasCalled.Should().BeTrue();
            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("foo");
        }

        [Fact]
        public async Task GetIdentityTokenClaimsAsync_should_filter_protocol_claims_from_profile_service()
        {
            _resources.IdentityResources.Add(new IdentityResource("id_scope", new[] { "foo" }));
            _mockMockProfileService.ProfileClaims.Add(new Claim("aud", "bar"));

            var claims = await _subject.GetIdentityTokenClaimsAsync(_user, ResourceValidationResult, true, _validatedRequest);

            claims.Count(x => x.Type == "aud" && x.Value == "bar").Should().Be(0);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_client_id()
        {
            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == JwtClaimTypes.ClientId && x.Value == _client.ClientId).Should().Be(1);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_client_claims_should_be_prefixed_with_default_value()
        {
            var claims = await _subject.GetAccessTokenClaimsAsync(null, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == "client_some_claim" && x.Value == "some_claim_value").Should().Be(1);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_client_claims_should_be_prefixed_with_custom_value()
        {
            _validatedRequest.Client.ClientClaimsPrefix = "custom_prefix_";
            var claims = await _subject.GetAccessTokenClaimsAsync(null, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == "custom_prefix_some_claim" && x.Value == "some_claim_value").Should().Be(1);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_client_claims_when_no_subject()
        {
            _validatedRequest.Client.ClientClaimsPrefix = null;
            var claims = await _subject.GetAccessTokenClaimsAsync(null, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == "some_claim" && x.Value == "some_claim_value").Should().Be(1);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_client_claims_when_configured_to_send_client_claims()
        {
            _validatedRequest.Client.ClientClaimsPrefix = null;
            _validatedRequest.Client.AlwaysSendClientClaims = true;

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == "some_claim" && x.Value == "some_claim_value").Should().Be(1);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_scopes()
        {
            _resources.IdentityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _resources.IdentityResources.Add(new IdentityResource("id2", new[] { "bar" }));
            _resources.ApiScopes.Add(new ApiScope("api1"));
            _resources.ApiScopes.Add(new ApiScope("api2"));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Count().Should().Be(4);
            scopes.ToArray().Should().BeEquivalentTo(new string[] { "api1", "api2", "id1", "id2" });
        }
        
        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_parameterized_scope_values()
        {
            _resources.ApiScopes.Add(new ApiScope("api"));
            var resourceResult = new ResourceValidationResult()
            {
                Resources = _resources,
                ParsedScopes = { new ParsedScopeValue("api:123", "api", "123") }
            };

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, resourceResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Count().Should().Be(1);
            scopes.ToArray().Should().BeEquivalentTo(new string[] { "api:123" });
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_when_no_ApiScopes_should_not_contain_scopes()
        {
            _resources.ApiResources.Add(new ApiResource("api1"));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Count().Should().Be(0);
        }
        
        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_only_consider_parsed_scope_values_and_not_ApiScope()
        {
            // arguably, if this situation arises, then the ResourceValidationResult was not populated properly
            // with ParsedScopes matching ApiScopes
            _resources.ApiScopes.Add(new ApiScope("api1"));
            var resourceResult = new ResourceValidationResult()
            {
                Resources = _resources,
                ParsedScopes = { new ParsedScopeValue("api2") }
            };

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, resourceResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Count().Should().Be(1);
            scopes.ToArray().Should().BeEquivalentTo(new string[] { "api2" });
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_when_multiple_resources_with_same_scope_should_contain_scope_once()
        {
            _resources.OfflineAccess = false;
            _resources.IdentityResources.Clear();
            _resources.ApiResources.Clear();
            _resources.ApiScopes.Clear();

            _resources.ApiResources.Add(new ApiResource { Name = "api1", Scopes = { "resource" } });
            _resources.ApiResources.Add(new ApiResource { Name = "api2", Scopes = { "resource" } });
            _resources.ApiResources.Add(new ApiResource { Name = "api3", Scopes = { "resource" } });
            _resources.ApiScopes.Add(new ApiScope("resource"));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Count().Should().Be(1);
            scopes.ToArray().Should().BeEquivalentTo(new string[] { "resource" });
        }
        
        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_contain_offline_scope()
        {
            _resources.IdentityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _resources.IdentityResources.Add(new IdentityResource("id2", new[] { "bar" }));
            _resources.ApiResources.Add(new ApiResource("api1"));
            _resources.ApiResources.Add(new ApiResource("api2"));
            _resources.OfflineAccess = true;

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Should().Contain(IdentityServerConstants.StandardScopes.OfflineAccess);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_not_contain_offline_scope_if_no_user()
        {
            _resources.IdentityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _resources.IdentityResources.Add(new IdentityResource("id2", new[] { "bar" }));
            _resources.ApiResources.Add(new ApiResource("api1"));
            _resources.ApiResources.Add(new ApiResource("api2"));
            _resources.OfflineAccess = true;

            var claims = await _subject.GetAccessTokenClaimsAsync(null, ResourceValidationResult, _validatedRequest);

            var scopes = claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
            scopes.Should().NotContain(IdentityServerConstants.StandardScopes.OfflineAccess);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_return_standard_user_claims()
        {
            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            var types = claims.Select(x => x.Type);
            types.Should().Contain(JwtClaimTypes.Subject);
            types.Should().Contain(JwtClaimTypes.AuthenticationTime);
            types.Should().Contain(JwtClaimTypes.IdentityProvider);
            types.Should().Contain(JwtClaimTypes.AuthenticationMethod);
            types.Should().Contain(JwtClaimTypes.AuthenticationContextClassReference);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_only_contain_api_claims()
        {
            _resources.IdentityResources.Add(new IdentityResource("id1", new[] { "foo" }));
            _resources.ApiResources.Add(new ApiResource("api1", new string[] { "bar" }));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            _mockMockProfileService.GetProfileWasCalled.Should().BeTrue();
            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().NotContain("foo");
            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("bar");
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_filter_protocol_claims_from_profile_service()
        {
            _resources.ApiResources.Add(new ApiResource("api1", new[] { "foo" }));
            _mockMockProfileService.ProfileClaims.Add(new Claim("aud", "bar"));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            claims.Count(x => x.Type == "aud" && x.Value == "bar").Should().Be(0);
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_request_api_claims()
        {
            _resources.ApiResources.Add(new ApiResource("api1", new[] { "foo" }));

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("foo");
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_request_api_scope_claims()
        {
            _resources.ApiResources.Add(
                new ApiResource("api")
                {
                    Scopes = { "api1" }
                }
            );
            _resources.ApiScopes.Add(
                new ApiScope("api1")
                {
                    UserClaims = { "foo" }
                }
            );

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("foo");
        }

        [Fact]
        public async Task GetAccessTokenClaimsAsync_should_request_both_api_and_api_scope_claims()
        {
            _resources.ApiResources.Add(
                new ApiResource("api")
                {
                    UserClaims = { "foo" },
                    Scopes = { "api1" } 
                }
            );
            _resources.ApiScopes.Add(
                new ApiScope("api1")
                {
                    UserClaims = { "bar" }
                }
            );

            var claims = await _subject.GetAccessTokenClaimsAsync(_user, ResourceValidationResult, _validatedRequest);

            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("foo");
            _mockMockProfileService.ProfileContext.RequestedClaimTypes.Should().Contain("bar");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultConsentServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultConsentServiceTests
    {
        private DefaultConsentService _subject;
        private MockProfileService _mockMockProfileService = new MockProfileService();

        private ClaimsPrincipal _user;
        private Client _client;
        private TestUserConsentStore _userConsentStore = new TestUserConsentStore();
        private StubClock _clock = new StubClock();

        private DateTime now;

        public DefaultConsentServiceTests()
        {
            _clock.UtcNowFunc = () => UtcNow;

            _client = new Client
            {
                ClientId = "client",
                RequireConsent = true,
                RequirePkce = false
            };

            _user = new IdentityServerUser("bob")
            {
                AdditionalClaims =
                {
                    new Claim("foo", "foo1"),
                    new Claim("foo", "foo2"),
                    new Claim("bar", "bar1"),
                    new Claim("bar", "bar2"),
                    new Claim(JwtClaimTypes.AuthenticationContextClassReference, "acr1")
                }
            }.CreatePrincipal();

            _subject = new DefaultConsentService(_clock, _userConsentStore, TestLogger.Create());
        }

        public DateTime UtcNow
        {
            get
            {
                if (now > DateTime.MinValue) return now;
                return DateTime.UtcNow;
            }
        }

        [Fact]
        public async Task UpdateConsentAsync_when_client_does_not_allow_remember_consent_should_not_update_store()
        {
            _client.AllowRememberConsent = false;

            await _subject.UpdateConsentAsync(_user, _client, new [] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            var consent = await _userConsentStore.GetUserConsentAsync(_user.GetSubjectId(), _client.ClientId);
            consent.Should().BeNull();
        }

        [Fact]
        public async Task UpdateConsentAsync_should_persist_consent()
        {
            await _subject.UpdateConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            var consent = await _userConsentStore.GetUserConsentAsync(_user.GetSubjectId(), _client.ClientId);
            consent.Scopes.Count().Should().Be(2);
            consent.Scopes.Should().Contain("scope1");
            consent.Scopes.Should().Contain("scope2");
        }

        [Fact]
        public async Task UpdateConsentAsync_empty_scopes_should_should_remove_consent()
        {
            await _subject.UpdateConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            await _subject.UpdateConsentAsync(_user, _client, new ParsedScopeValue[] { });

            var consent = await _userConsentStore.GetUserConsentAsync(_user.GetSubjectId(), _client.ClientId);
            consent.Should().BeNull();
        }

        [Fact]
        public async Task RequiresConsentAsync_client_does_not_require_consent_should_not_require_consent()
        {
            _client.RequireConsent = false;

            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            result.Should().BeFalse();
        }

        [Fact]
        public async Task RequiresConsentAsync_client_does_not_allow_remember_consent_should_require_consent()
        {
            _client.AllowRememberConsent = false;

            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            result.Should().BeTrue();
        }

        [Fact]
        public async Task RequiresConsentAsync_no_scopes_should_not_require_consent()
        {
            var result = await _subject.RequiresConsentAsync(_user, _client, new ParsedScopeValue[] { });

            result.Should().BeFalse();
        }

        [Fact]
        public async Task RequiresConsentAsync_offline_access_should_require_consent()
        {
            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("offline_access") });

            result.Should().BeTrue();
        }

        [Fact]
        public async Task RequiresConsentAsync_no_prior_consent_should_require_consent()
        {
            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            result.Should().BeTrue();
        }

        [Fact]
        public async Task RequiresConsentAsync_prior_consent_should_not_require_consent()
        {
            await _subject.UpdateConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            result.Should().BeFalse();
        }

        [Fact]
        public async Task RequiresConsentAsync_prior_consent_with_more_scopes_should_not_require_consent()
        {
            await _subject.UpdateConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2"), new ParsedScopeValue("scope3") });

            var result = await _subject.RequiresConsentAsync(_user, _client, new [] { new ParsedScopeValue("scope2") });

            result.Should().BeFalse();
        }

        [Fact]
        public async Task RequiresConsentAsync_prior_consent_with_too_few_scopes_should_require_consent()
        {
            await _subject.UpdateConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope2"), new ParsedScopeValue("scope3") });

            var result = await _subject.RequiresConsentAsync(_user, _client, new[] { new ParsedScopeValue("scope1"), new ParsedScopeValue("scope2") });

            result.Should().BeTrue();
        }

        [Fact]
        public async Task RequiresConsentAsync_expired_consent_should_require_consent()
        {
            now = DateTime.UtcNow;

            var scopes = new[] { new ParsedScopeValue("foo"), new ParsedScopeValue("bar") };
            _client.ConsentLifetime = 2;

            await _subject.UpdateConsentAsync(_user, _client, scopes);

            now = now.AddSeconds(3);

            var result = await _subject.RequiresConsentAsync(_user, _client, scopes);

            result.Should().BeTrue();
        }

        [Fact]
        public async Task RequiresConsentAsync_expired_consent_should_remove_consent()
        {
            now = DateTime.UtcNow;

            var scopes = new[] { new ParsedScopeValue("foo"), new ParsedScopeValue("bar") };
            _client.ConsentLifetime = 2;

            await _subject.UpdateConsentAsync(_user, _client, scopes);

            now = now.AddSeconds(3);

            await _subject.RequiresConsentAsync(_user, _client, scopes);

            var result = await _userConsentStore.GetUserConsentAsync(_user.GetSubjectId(), _client.ClientId);

            result.Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultCorsPolicyServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Services;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultCorsPolicyServiceTests
    {
        private const string Category = "DefaultCorsPolicyService";

        private DefaultCorsPolicyService subject;

        public DefaultCorsPolicyServiceTests()
        {
            subject = new DefaultCorsPolicyService(TestLogger.Create());
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IsOriginAllowed_null_param_ReturnsFalse()
        {
            (await subject.IsOriginAllowedAsync(null)).Should().Be(false);
            (await subject.IsOriginAllowedAsync(String.Empty)).Should().Be(false);
            (await subject.IsOriginAllowedAsync("    ")).Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IsOriginAllowed_OriginIsAllowed_ReturnsTrue()
        {
            subject.AllowedOrigins.Add("http://foo");
            (await subject.IsOriginAllowedAsync("http://foo")).Should().Be(true);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IsOriginAllowed_OriginIsNotAllowed_ReturnsFalse()
        {
            subject.AllowedOrigins.Add("http://foo");
            (await subject.IsOriginAllowedAsync("http://bar")).Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IsOriginAllowed_OriginIsInAllowedList_ReturnsTrue()
        {
            subject.AllowedOrigins.Add("http://foo");
            subject.AllowedOrigins.Add("http://bar");
            subject.AllowedOrigins.Add("http://baz");
            (await subject.IsOriginAllowedAsync("http://bar")).Should().Be(true);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IsOriginAllowed_OriginIsNotInAllowedList_ReturnsFalse()
        {
            subject.AllowedOrigins.Add("http://foo");
            subject.AllowedOrigins.Add("http://bar");
            subject.AllowedOrigins.Add("http://baz");
            (await subject.IsOriginAllowedAsync("http://quux")).Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task  IsOriginAllowed_AllowAllTrue_ReturnsTrue()
        {
            subject.AllowAll = true;
            (await subject.IsOriginAllowedAsync("http://foo")).Should().Be(true);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultIdentityServerInteractionServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultIdentityServerInteractionServiceTests
    {
        private DefaultIdentityServerInteractionService _subject;

        private IdentityServerOptions _options = new IdentityServerOptions();
        private MockHttpContextAccessor _mockMockHttpContextAccessor;
        private MockMessageStore _mockEndSessionStore = new MockMessageStore();
        private MockMessageStore _mockLogoutMessageStore = new MockMessageStore();
        private MockMessageStore _mockErrorMessageStore = new MockMessageStore();
        private MockConsentMessageStore _mockConsentStore = new MockConsentMessageStore();
        private MockPersistedGrantService _mockPersistedGrantService = new MockPersistedGrantService();
        private MockUserSession _mockUserSession = new MockUserSession();
        private MockReturnUrlParser _mockReturnUrlParser = new MockReturnUrlParser();

        private ResourceValidationResult _resourceValidationResult;

        public DefaultIdentityServerInteractionServiceTests()
        {
            _mockMockHttpContextAccessor = new MockHttpContextAccessor(_options, _mockUserSession, _mockEndSessionStore);

            _subject = new DefaultIdentityServerInteractionService(new StubClock(), 
                _mockMockHttpContextAccessor,
                _mockLogoutMessageStore,
                _mockErrorMessageStore,
                _mockConsentStore,
                _mockPersistedGrantService,
                _mockUserSession,
                _mockReturnUrlParser,
                TestLogger.Create()
            );

            _resourceValidationResult = new ResourceValidationResult();
            _resourceValidationResult.Resources.IdentityResources.Add(new IdentityResources.OpenId());
            _resourceValidationResult.ParsedScopes.Add(new ParsedScopeValue("openid"));
        }
        
        [Fact]
        public async Task GetLogoutContextAsync_valid_session_and_logout_id_should_not_provide_signout_iframe()
        {
            // for this, we're just confirming that since the session has changed, there's not use in doing the iframe and thsu SLO
            _mockUserSession.SessionId = null;
            _mockLogoutMessageStore.Messages.Add("id", new Message(new LogoutMessage() { SessionId = "session" }));

            var context = await _subject.GetLogoutContextAsync("id");

            context.SignOutIFrameUrl.Should().BeNull();
        }

        [Fact]
        public async Task GetLogoutContextAsync_valid_session_no_logout_id_should_provide_iframe()
        {
            _mockUserSession.Clients.Add("foo");
            _mockUserSession.SessionId = "session";
            _mockUserSession.User = new IdentityServerUser("123").CreatePrincipal();

            var context = await _subject.GetLogoutContextAsync(null);

            context.SignOutIFrameUrl.Should().NotBeNull();
        }

        [Fact]
        public async Task GetLogoutContextAsync_without_session_should_not_provide_iframe()
        {
            _mockUserSession.SessionId = null;
            _mockLogoutMessageStore.Messages.Add("id", new Message(new LogoutMessage()));

            var context = await _subject.GetLogoutContextAsync("id");

            context.SignOutIFrameUrl.Should().BeNull();
        }

        [Fact]
        public async Task CreateLogoutContextAsync_without_session_should_not_create_session()
        {
            var context = await _subject.CreateLogoutContextAsync();

            context.Should().BeNull();
            _mockLogoutMessageStore.Messages.Should().BeEmpty();
        }

        [Fact]
        public async Task CreateLogoutContextAsync_with_session_should_create_session()
        {
            _mockUserSession.Clients.Add("foo");
            _mockUserSession.User = new IdentityServerUser("123").CreatePrincipal();
            _mockUserSession.SessionId = "session";

            var context = await _subject.CreateLogoutContextAsync();

            context.Should().NotBeNull();
            _mockLogoutMessageStore.Messages.Should().NotBeEmpty();
        }

        [Fact]
        public async Task GrantConsentAsync_should_throw_if_granted_and_no_subject()
        {
            Func act = async () => await _subject.GrantConsentAsync(
                new AuthorizationRequest(), 
                new ConsentResponse() { ScopesValuesConsented = new[] { "openid" } }, 
                null);

            (await act.Should().ThrowAsync())
                .And.Message.Should().Contain("subject");
        }

        [Fact]
        public async Task GrantConsentAsync_should_allow_deny_for_anonymous_users()
        {
            var req = new AuthorizationRequest()
            {
                Client = new Client { ClientId = "client" },
                ValidatedResources = _resourceValidationResult
            };
            await _subject.GrantConsentAsync(req, new ConsentResponse { Error = AuthorizationError.AccessDenied }, null);
        }

        [Fact]
        public async Task GrantConsentAsync_should_use_current_subject_and_create_message()
        {
            _mockUserSession.User = new IdentityServerUser("bob").CreatePrincipal();

            var req = new AuthorizationRequest() { 
                Client = new Client { ClientId = "client" },
                ValidatedResources = _resourceValidationResult
            };
            await _subject.GrantConsentAsync(req, new ConsentResponse(), null);

            _mockConsentStore.Messages.Should().NotBeEmpty();
            var consentRequest = new ConsentRequest(req, "bob");
            _mockConsentStore.Messages.First().Key.Should().Be(consentRequest.Id);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultPersistedGrantServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Serialization;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultPersistedGrantServiceTests
    {
        private DefaultPersistedGrantService _subject;
        private InMemoryPersistedGrantStore _store = new InMemoryPersistedGrantStore();
        private IAuthorizationCodeStore _codes;
        private IRefreshTokenStore _refreshTokens;
        private IReferenceTokenStore _referenceTokens;
        private IUserConsentStore _userConsent;

        private ClaimsPrincipal _user = new IdentityServerUser("123").CreatePrincipal();

        public DefaultPersistedGrantServiceTests()
        {
            _subject = new DefaultPersistedGrantService(
                _store, 
                new PersistentGrantSerializer(), 
                TestLogger.Create());
            _codes = new DefaultAuthorizationCodeStore(_store,
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
            _refreshTokens = new DefaultRefreshTokenStore(_store,
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
            _referenceTokens = new DefaultReferenceTokenStore(_store,
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
            _userConsent = new DefaultUserConsentStore(_store,
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
        }

        [Fact]
        public async Task GetAllGrantsAsync_should_return_all_grants()
        {
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                CreationTime = DateTime.UtcNow,
                ClientId = "client1",
                SubjectId = "123",
                Scopes = new string[] { "foo1", "foo2" }
            });
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                CreationTime = DateTime.UtcNow,
                ClientId = "client2",
                SubjectId = "123",
                Scopes = new string[] { "foo3" }
            });
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                CreationTime = DateTime.UtcNow,
                ClientId = "client1",
                SubjectId = "456",
                Scopes = new string[] { "foo3" }
            });

            var handle1 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client1",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "bar1"),
                    new Claim("scope", "bar2")
                }
            });

            var handle2 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client2",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "bar3")
                }
            });

            var handle3 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client1",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "456"),
                    new Claim("scope", "bar3")
                }
            });

            var handle4 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client1",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "baz1"),
                        new Claim("scope", "baz2")
                    }
                },
                Version = 1
            });
            var handle5 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client1",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "456"),
                        new Claim("scope", "baz3")
                    }
                },
                Version = 1
            });
            var handle6 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client2",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "baz3")
                    }
                },
                Version = 1
            });

            var handle7 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux1", "quux2" }
            });

            var handle8 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client2",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux3" }
            });

            var handle9 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = new IdentityServerUser("456").CreatePrincipal(),
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux3" }
            });

            var grants = await _subject.GetAllGrantsAsync("123");

            grants.Count().Should().Be(2);
            var grant1 = grants.First(x => x.ClientId == "client1");
            grant1.SubjectId.Should().Be("123");
            grant1.ClientId.Should().Be("client1");
            grant1.Scopes.Should().BeEquivalentTo(new string[] { "foo1", "foo2", "bar1", "bar2", "baz1", "baz2", "quux1", "quux2" });

            var grant2 = grants.First(x => x.ClientId == "client2");
            grant2.SubjectId.Should().Be("123");
            grant2.ClientId.Should().Be("client2");
            grant2.Scopes.Should().BeEquivalentTo(new string[] { "foo3", "bar3", "baz3", "quux3" });
        }

        [Fact]
        public async Task RemoveAllGrantsAsync_should_remove_all_grants()
        {
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                ClientId = "client1",
                SubjectId = "123",
                Scopes = new string[] { "foo1", "foo2" }
            });
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                ClientId = "client2",
                SubjectId = "123",
                Scopes = new string[] { "foo3" }
            });
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                ClientId = "client1",
                SubjectId = "456",
                Scopes = new string[] { "foo3" }
            });

            var handle1 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client1",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "bar1"),
                    new Claim("scope", "bar2")
                }
            });

            var handle2 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client2",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "bar3")
                }
            });

            var handle3 = await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client1",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "456"),
                    new Claim("scope", "bar3")
                }
            });

            var handle4 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client1",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "baz1"),
                        new Claim("scope", "baz2")
                    }
                },
                Version = 1
            });
            var handle5 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client1",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "456"),
                        new Claim("scope", "baz3")
                    }
                },
                Version = 1
            });
            var handle6 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client2",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "baz3")
                    }
                },
                Version = 1
            });

            var handle7 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux1", "quux2" }
            });

            var handle8 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client2",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux3" }
            });

            var handle9 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = new IdentityServerUser("456").CreatePrincipal(),
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux3" }
            });

            await _subject.RemoveAllGrantsAsync("123", "client1");

            (await _referenceTokens.GetReferenceTokenAsync(handle1)).Should().BeNull();
            (await _referenceTokens.GetReferenceTokenAsync(handle2)).Should().NotBeNull();
            (await _referenceTokens.GetReferenceTokenAsync(handle3)).Should().NotBeNull();
            (await _refreshTokens.GetRefreshTokenAsync(handle4)).Should().BeNull();
            (await _refreshTokens.GetRefreshTokenAsync(handle5)).Should().NotBeNull();
            (await _refreshTokens.GetRefreshTokenAsync(handle6)).Should().NotBeNull();
            (await _codes.GetAuthorizationCodeAsync(handle7)).Should().BeNull();
            (await _codes.GetAuthorizationCodeAsync(handle8)).Should().NotBeNull();
            (await _codes.GetAuthorizationCodeAsync(handle9)).Should().NotBeNull();
        }
        [Fact]
        public async Task RemoveAllGrantsAsync_should_filter_on_session_id()
        {
            {
                var handle1 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle2 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client2",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle3 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client3",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session3"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });

                await _subject.RemoveAllGrantsAsync("123");

                (await _refreshTokens.GetRefreshTokenAsync(handle1)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle2)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle3)).Should().BeNull();
                await _refreshTokens.RemoveRefreshTokenAsync(handle1);
                await _refreshTokens.RemoveRefreshTokenAsync(handle2);
                await _refreshTokens.RemoveRefreshTokenAsync(handle3);
            }
            {
                var handle1 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle2 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client2",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle3 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client3",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session3"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });

                await _subject.RemoveAllGrantsAsync("123", "client1");

                (await _refreshTokens.GetRefreshTokenAsync(handle1)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle2)).Should().NotBeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle3)).Should().NotBeNull();
                await _refreshTokens.RemoveRefreshTokenAsync(handle1);
                await _refreshTokens.RemoveRefreshTokenAsync(handle2);
                await _refreshTokens.RemoveRefreshTokenAsync(handle3);
            }
            {
                var handle1 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle2 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client2",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle3 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client3",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle4 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session2"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                await _subject.RemoveAllGrantsAsync("123", "client1", "session1");

                (await _refreshTokens.GetRefreshTokenAsync(handle1)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle2)).Should().NotBeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle3)).Should().NotBeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle4)).Should().NotBeNull();
                await _refreshTokens.RemoveRefreshTokenAsync(handle1);
                await _refreshTokens.RemoveRefreshTokenAsync(handle2);
                await _refreshTokens.RemoveRefreshTokenAsync(handle3);
                await _refreshTokens.RemoveRefreshTokenAsync(handle4);
            }
            {
                var handle1 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle2 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client2",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle3 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client3",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session1"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                var handle4 = await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
                {
                    CreationTime = DateTime.UtcNow,
                    Lifetime = 10,
                    AccessToken = new Token
                    {
                        ClientId = "client1",
                        Audiences = { "aud" },
                        CreationTime = DateTime.UtcNow,
                        Type = "type",
                        Claims = new List
                        {
                            new Claim("sub", "123"),
                            new Claim("sid", "session2"),
                            new Claim("scope", "baz")
                        }
                    },
                    Version = 1
                });
                await _subject.RemoveAllGrantsAsync("123", sessionId:"session1");

                (await _refreshTokens.GetRefreshTokenAsync(handle1)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle2)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle3)).Should().BeNull();
                (await _refreshTokens.GetRefreshTokenAsync(handle4)).Should().NotBeNull();
                await _refreshTokens.RemoveRefreshTokenAsync(handle1);
                await _refreshTokens.RemoveRefreshTokenAsync(handle2);
                await _refreshTokens.RemoveRefreshTokenAsync(handle3);
                await _refreshTokens.RemoveRefreshTokenAsync(handle4);
            }
        }

        [Fact]
        public async Task GetAllGrantsAsync_should_aggregate_correctly()
        {
            await _userConsent.StoreUserConsentAsync(new Consent()
            {
                ClientId = "client1",
                SubjectId = "123",
                Scopes = new string[] { "foo1", "foo2" }
            });

            var grants = await _subject.GetAllGrantsAsync("123");

            grants.Count().Should().Be(1);
            grants.First().Scopes.Should().Contain(new string[] { "foo1", "foo2" });

            var handle9 = await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux3" }
            });

            grants = await _subject.GetAllGrantsAsync("123");

            grants.Count().Should().Be(1);
            grants.First().Scopes.Should().Contain(new string[] { "foo1", "foo2", "quux3" });
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultRefreshTokenServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Serialization;
using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer.UnitTests.Validation.Setup;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultRefreshTokenServiceTests
    {
        private DefaultRefreshTokenService _subject;
        private DefaultRefreshTokenStore _store;

        private ClaimsPrincipal _user = new IdentityServerUser("123").CreatePrincipal();
        private StubClock _clock = new StubClock();

        public DefaultRefreshTokenServiceTests()
        {
            _store = new DefaultRefreshTokenStore(
                new InMemoryPersistedGrantStore(),
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());

            _subject = new DefaultRefreshTokenService(
                _store, 
                new TestProfileService(),
                _clock, 
                TestLogger.Create());
        }

        [Fact]
        public async Task CreateRefreshToken_token_exists_in_store()
        {
            var client = new Client();
            var accessToken = new Token();

            var handle = await _subject.CreateRefreshTokenAsync(_user, accessToken, client);

            (await _store.GetRefreshTokenAsync(handle)).Should().NotBeNull();
        }

        [Fact]
        public async Task CreateRefreshToken_should_match_absolute_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Absolute,
                AbsoluteRefreshTokenLifetime = 10
            };

            var handle = await _subject.CreateRefreshTokenAsync(_user, new Token(), client);

            var refreshToken = (await _store.GetRefreshTokenAsync(handle));

            refreshToken.Should().NotBeNull();
            refreshToken.Lifetime.Should().Be(client.AbsoluteRefreshTokenLifetime);
        }

        [Fact]
        public async Task CreateRefreshToken_should_cap_sliding_lifetime_that_exceeds_absolute_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime  = 100,
                AbsoluteRefreshTokenLifetime = 10
            };

            var handle = await _subject.CreateRefreshTokenAsync(_user, new Token(), client);

            var refreshToken = (await _store.GetRefreshTokenAsync(handle));

            refreshToken.Should().NotBeNull();
            refreshToken.Lifetime.Should().Be(client.AbsoluteRefreshTokenLifetime);
        }

        [Fact]
        public async Task CreateRefreshToken_should_match_sliding_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime = 10
            };

            var handle = await _subject.CreateRefreshTokenAsync(_user, new Token(), client);

            var refreshToken = (await _store.GetRefreshTokenAsync(handle));

            refreshToken.Should().NotBeNull();
            refreshToken.Lifetime.Should().Be(client.SlidingRefreshTokenLifetime);
        }

        [Fact]
        public async Task UpdateRefreshToken_one_time_use_should_create_new_token()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            (await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client))
                .Should().NotBeNull()
                .And
                .NotBe(handle);
        }

        [Fact]
        public async Task UpdateRefreshToken_sliding_with_non_zero_absolute_should_update_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime = 10,
                AbsoluteRefreshTokenLifetime = 100
            };

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var handle = await _store.StoreRefreshTokenAsync(new RefreshToken
            {
                CreationTime = now.AddSeconds(-10),
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            });

            var refreshToken = await _store.GetRefreshTokenAsync(handle);
            var newHandle = await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client);

            newHandle.Should().NotBeNull().And.Be(handle);

            var newRefreshToken = await _store.GetRefreshTokenAsync(newHandle);

            newRefreshToken.Should().NotBeNull();
            newRefreshToken.Lifetime.Should().Be((int)(now - newRefreshToken.CreationTime).TotalSeconds + client.SlidingRefreshTokenLifetime);
        }

        [Fact]
        public async Task UpdateRefreshToken_lifetime_exceeds_absolute_should_be_absolute_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime = 10,
                AbsoluteRefreshTokenLifetime = 1000
            };

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var handle = await _store.StoreRefreshTokenAsync(new RefreshToken
            {
                CreationTime = now.AddSeconds(-1000),
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            });

            var refreshToken = await _store.GetRefreshTokenAsync(handle);
            var newHandle = await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client);

            newHandle.Should().NotBeNull().And.Be(handle);

            var newRefreshToken = await _store.GetRefreshTokenAsync(newHandle);

            newRefreshToken.Should().NotBeNull();
            newRefreshToken.Lifetime.Should().Be(client.AbsoluteRefreshTokenLifetime);
        }

        [Fact]
        public async Task UpdateRefreshToken_sliding_with_zero_absolute_should_update_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.ReUse,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime = 10,
                AbsoluteRefreshTokenLifetime = 0
            };

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var handle = await _store.StoreRefreshTokenAsync(new RefreshToken
            {
                CreationTime = now.AddSeconds(-1000),
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            });

            var refreshToken = await _store.GetRefreshTokenAsync(handle);
            var newHandle = await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client);

            newHandle.Should().NotBeNull().And.Be(handle);

            var newRefreshToken = await _store.GetRefreshTokenAsync(newHandle);

            newRefreshToken.Should().NotBeNull();
            newRefreshToken.Lifetime.Should().Be((int)(now - newRefreshToken.CreationTime).TotalSeconds + client.SlidingRefreshTokenLifetime);
        }

        [Fact]
        public async Task UpdateRefreshToken_for_onetime_and_sliding_with_zero_absolute_should_update_lifetime()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.OneTimeOnly,
                RefreshTokenExpiration = TokenExpiration.Sliding,
                SlidingRefreshTokenLifetime = 10,
                AbsoluteRefreshTokenLifetime = 0
            };

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var handle = await _store.StoreRefreshTokenAsync(new RefreshToken
            {
                CreationTime = now.AddSeconds(-1000),
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            });

            var refreshToken = await _store.GetRefreshTokenAsync(handle);
            var newHandle = await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client);

            newHandle.Should().NotBeNull().And.NotBe(handle);

            var newRefreshToken = await _store.GetRefreshTokenAsync(newHandle);

            newRefreshToken.Should().NotBeNull();
            newRefreshToken.Lifetime.Should().Be((int)(now - newRefreshToken.CreationTime).TotalSeconds + client.SlidingRefreshTokenLifetime);
        }

        [Fact]
        public async Task UpdateRefreshToken_one_time_use_should_consume_token_and_create_new_one_with_correct_dates()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var newHandle = await _subject.UpdateRefreshTokenAsync(handle, refreshToken, client);

            var oldToken = await _store.GetRefreshTokenAsync(handle);
            var newToken = await _store.GetRefreshTokenAsync(newHandle);

            oldToken.ConsumedTime.Should().Be(now);
            newToken.ConsumedTime.Should().BeNull();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_invalid_token_should_fail()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var result = await _subject.ValidateRefreshTokenAsync("invalid", client);

            result.IsError.Should().BeTrue();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_client_without_allow_offline_access_should_fail()
        {
            var client = new Client
            {
                ClientId = "client1",
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var result = await _subject.ValidateRefreshTokenAsync(handle, client);

            result.IsError.Should().BeTrue();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_invalid_client_binding_should_fail()
        {
            var client = new Client
            {
                ClientId = "client1",
                AllowOfflineAccess = true,
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client2",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var result = await _subject.ValidateRefreshTokenAsync(handle, client);

            result.IsError.Should().BeTrue();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_expired_token_should_fail()
        {
            var client = new Client
            {
                ClientId = "client1",
                AllowOfflineAccess = true,
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow.AddSeconds(20);
            _clock.UtcNowFunc = () => now;

            var result = await _subject.ValidateRefreshTokenAsync(handle, client);

            result.IsError.Should().BeTrue();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_consumed_token_should_fail()
        {
            var client = new Client
            {
                ClientId = "client1",
                AllowOfflineAccess = true,
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                ConsumedTime = DateTime.UtcNow,
                
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var result = await _subject.ValidateRefreshTokenAsync(handle, client);

            result.IsError.Should().BeTrue();
        }
        
        [Fact]
        public async Task ValidateRefreshToken_valid_token_should_succeed()
        {
            var client = new Client
            {
                ClientId = "client1",
                AllowOfflineAccess = true,
                RefreshTokenUsage = TokenUsage.OneTimeOnly
            };

            var refreshToken = new RefreshToken
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = client.ClientId,
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Claims = new List()
                    {
                        new Claim("sub", "123")
                    }
                }
            };

            var handle = await _store.StoreRefreshTokenAsync(refreshToken);

            var now = DateTime.UtcNow;
            _clock.UtcNowFunc = () => now;

            var result = await _subject.ValidateRefreshTokenAsync(handle, client);

            result.IsError.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultTokenServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultTokenServiceTests
    {
        private DefaultTokenService _subject;

        MockClaimsService _mockClaimsService = new MockClaimsService();
        MockReferenceTokenStore _mockReferenceTokenStore = new MockReferenceTokenStore();
        MockTokenCreationService _mockTokenCreationService = new MockTokenCreationService();
        DefaultHttpContext _httpContext = new DefaultHttpContext();
        MockSystemClock _mockSystemClock = new MockSystemClock();
        MockKeyMaterialService _mockKeyMaterialService = new MockKeyMaterialService();
        IdentityServerOptions _options = new IdentityServerOptions();

        public DefaultTokenServiceTests()
        {
            _options.IssuerUri = "https://test.identityserver8.io";

            var svcs = new ServiceCollection();
            svcs.AddSingleton(_options);
            _httpContext.RequestServices = svcs.BuildServiceProvider();

            _subject = new DefaultTokenService(
                _mockClaimsService,
                _mockReferenceTokenStore,
                _mockTokenCreationService,
                new HttpContextAccessor { HttpContext = _httpContext },
                _mockSystemClock,
                _mockKeyMaterialService,
                _options,
                TestLogger.Create());
        }

        [Fact]
        public async Task CreateAccessTokenAsync_should_include_aud_for_each_ApiResource()
        {
            var request = new TokenCreationRequest { 
                ValidatedResources = new ResourceValidationResult()
                {
                    Resources = new Resources()
                    {
                        ApiResources = 
                        {
                            new ApiResource("api1"){ Scopes = { "scope1" } },
                            new ApiResource("api2"){ Scopes = { "scope2" } },
                            new ApiResource("api3"){ Scopes = { "scope3" } },
                        },
                    },
                    ParsedScopes =
                    {
                        new ParsedScopeValue("scope1"),
                        new ParsedScopeValue("scope2"),
                        new ParsedScopeValue("scope3"),
                    }
                },
                ValidatedRequest = new ValidatedRequest()
                {
                    Client = new Client { }
                }
            };

            var result = await _subject.CreateAccessTokenAsync(request);

            result.Audiences.Count.Should().Be(3);
            result.Audiences.Should().BeEquivalentTo(new[] { "api1", "api2", "api3" });
        }

        [Fact]
        public async Task CreateAccessTokenAsync_when_no_apiresources_should_not_include_any_aud()
        {
            var request = new TokenCreationRequest
            {
                ValidatedResources = new ResourceValidationResult()
                {
                    Resources = new Resources()
                    {
                        ApiScopes =
                        {
                            new ApiScope("scope1"),
                            new ApiScope("scope2"),
                            new ApiScope("scope3"),
                        },
                    },
                    ParsedScopes =
                    {
                        new ParsedScopeValue("scope1"),
                        new ParsedScopeValue("scope2"),
                        new ParsedScopeValue("scope3"),
                    }
                },
                ValidatedRequest = new ValidatedRequest()
                {
                    Client = new Client { }
                }
            };

            var result = await _subject.CreateAccessTokenAsync(request);

            result.Audiences.Count.Should().Be(0);
        }


        [Fact]
        public async Task CreateAccessTokenAsync_when_no_session_should_not_include_sid()
        {
            var request = new TokenCreationRequest
            {
                ValidatedResources = new ResourceValidationResult(),
                ValidatedRequest = new ValidatedRequest()
                {
                    Client = new Client { },
                    SessionId = null
                }
            };

            var result = await _subject.CreateAccessTokenAsync(request);

            result.Claims.SingleOrDefault(x => x.Type == JwtClaimTypes.SessionId).Should().BeNull();
        }
        [Fact]
        public async Task CreateAccessTokenAsync_when_session_should_include_sid()
        {
            var request = new TokenCreationRequest
            {
                ValidatedResources = new ResourceValidationResult(),
                ValidatedRequest = new ValidatedRequest()
                {
                    Client = new Client { },
                    SessionId = "123"
                }
            };

            var result = await _subject.CreateAccessTokenAsync(request);

            result.Claims.SingleOrDefault(x => x.Type == JwtClaimTypes.SessionId).Value.Should().Be("123");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DefaultUserSessionTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Linq;
using System.Net;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Extensions;
using IdentityServer8.Services;
using Microsoft.AspNetCore.Authentication;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DefaultUserSessionTests
    {
        private DefaultUserSession _subject;
        private MockHttpContextAccessor _mockHttpContext = new MockHttpContextAccessor();
        private MockAuthenticationHandlerProvider _mockAuthenticationHandlerProvider = new MockAuthenticationHandlerProvider();
        private MockAuthenticationHandler _mockAuthenticationHandler = new MockAuthenticationHandler();

        private IdentityServerOptions _options = new IdentityServerOptions();
        private ClaimsPrincipal _user;
        private AuthenticationProperties _props = new AuthenticationProperties();

        public DefaultUserSessionTests()
        {
            _mockAuthenticationHandlerProvider.Handler = _mockAuthenticationHandler;

            _user = new IdentityServerUser("123").CreatePrincipal();
            _subject = new DefaultUserSession(
                _mockHttpContext, 
                _mockAuthenticationHandlerProvider,
                _options,
                new StubClock(), 
                TestLogger.Create());
        }

        [Fact]
        public async Task CreateSessionId_when_user_is_anonymous_should_generate_new_sid()
        {
            await _subject.CreateSessionIdAsync(_user, _props);

            _props.GetSessionId().Should().NotBeNull();
        }

        [Fact]
        public async Task CreateSessionId_when_user_is_authenticated_should_not_generate_new_sid()
        {
            // this test is needed to allow same session id when cookie is slid
            // IOW, if UI layer passes in same properties dictionary, then we assume it's the same user

            _props.SetSessionId("999");
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.CreateSessionIdAsync(_user, _props);

            _props.GetSessionId().Should().NotBeNull();
            _props.GetSessionId().Should().Be("999");
        }

        [Fact]
        public async Task CreateSessionId_when_props_does_not_contain_key_should_generate_new_sid()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            _props.GetSessionId().Should().BeNull();

            await _subject.CreateSessionIdAsync(_user, _props);

            _props.GetSessionId().Should().NotBeNull();
        }

        [Fact]
        public async Task CreateSessionId_when_user_is_authenticated_but_different_sub_should_create_new_sid()
        {
            _props.SetSessionId("999");
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.CreateSessionIdAsync(new IdentityServerUser("alice").CreatePrincipal(), _props);

            _props.GetSessionId().Should().NotBeNull();
            _props.GetSessionId().Should().NotBe("999");
        }

        [Fact]
        public async Task CreateSessionId_should_issue_session_id_cookie()
        {
            await _subject.CreateSessionIdAsync(_user, _props);

            var cookieContainer = new CookieContainer();
            var cookies = _mockHttpContext.HttpContext.Response.Headers.Where(x => x.Key.Equals("Set-Cookie", StringComparison.OrdinalIgnoreCase)).Select(x => x.Value);
            cookieContainer.SetCookies(new Uri("http://server"), string.Join(",", cookies));
            _mockHttpContext.HttpContext.Response.Headers.Clear();

            var cookie = cookieContainer.GetCookies(new Uri("http://server")).Cast().Where(x => x.Name == _options.Authentication.CheckSessionCookieName).FirstOrDefault();
            cookie.Value.Should().Be(_props.GetSessionId());
        }

        [Fact]
        public async Task EnsureSessionIdCookieAsync_should_add_cookie()
        {
            _props.SetSessionId("999");
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.EnsureSessionIdCookieAsync();

            var cookieContainer = new CookieContainer();
            var cookies = _mockHttpContext.HttpContext.Response.Headers.Where(x => x.Key.Equals("Set-Cookie", StringComparison.OrdinalIgnoreCase)).Select(x => x.Value);
            cookieContainer.SetCookies(new Uri("http://server"), string.Join(",", cookies));
            _mockHttpContext.HttpContext.Response.Headers.Clear();

            var cookie = cookieContainer.GetCookies(new Uri("http://server")).Cast().Where(x => x.Name == _options.Authentication.CheckSessionCookieName).FirstOrDefault();
            cookie.Value.Should().Be("999");
        }

        [Fact]
        public async Task EnsureSessionIdCookieAsync_should_not_add_cookie_if_no_sid()
        {
            await _subject.EnsureSessionIdCookieAsync();

            var cookieContainer = new CookieContainer();
            var cookies = _mockHttpContext.HttpContext.Response.Headers.Where(x => x.Key.Equals("Set-Cookie", StringComparison.OrdinalIgnoreCase)).Select(x => x.Value);
            cookieContainer.SetCookies(new Uri("http://server"), string.Join(",", cookies));
            _mockHttpContext.HttpContext.Response.Headers.Clear();

            var cookie = cookieContainer.GetCookies(new Uri("http://server")).Cast().Where(x => x.Name == _options.Authentication.CheckSessionCookieName).FirstOrDefault();
            cookie.Should().BeNull();
        }

        [Fact]
        public async Task RemoveSessionIdCookie_should_remove_cookie()
        {
            _props.SetSessionId("999");
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.EnsureSessionIdCookieAsync();

            var cookieContainer = new CookieContainer();
            var cookies = _mockHttpContext.HttpContext.Response.Headers.Where(x => x.Key.Equals("Set-Cookie", StringComparison.OrdinalIgnoreCase)).Select(x => x.Value);
            cookieContainer.SetCookies(new Uri("http://server"), string.Join(",", cookies));
            _mockHttpContext.HttpContext.Response.Headers.Clear();

            string cookie = cookieContainer.GetCookieHeader(new Uri("http://server"));
            _mockHttpContext.HttpContext.Request.Headers.Append("Cookie", cookie);

            await _subject.RemoveSessionIdCookieAsync();

            cookies = _mockHttpContext.HttpContext.Response.Headers.Where(x => x.Key.Equals("Set-Cookie", StringComparison.OrdinalIgnoreCase)).Select(x => x.Value);
            cookieContainer.SetCookies(new Uri("http://server"), string.Join(",", cookies));

            var query = cookieContainer.GetCookies(new Uri("http://server")).Cast().Where(x => x.Name == _options.Authentication.CheckSessionCookieName);
            query.Count().Should().Be(0);
        }

        [Fact]
        public async Task GetCurrentSessionIdAsync_when_user_is_authenticated_should_return_sid()
        {
            _props.SetSessionId("999");
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            var sid = await _subject.GetSessionIdAsync();
            sid.Should().Be("999");
        }

        [Fact]
        public async Task GetCurrentSessionIdAsync_when_user_is_anonymous_should_return_null()
        {
            var sid = await _subject.GetSessionIdAsync();
            sid.Should().BeNull();
        }

        [Fact]
        public async Task adding_client_should_set_item_in_cookie_properties()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            _props.Items.Count.Should().Be(0);
            await _subject.AddClientIdAsync("client");
            _props.Items.Count.Should().Be(1);
        }

        [Fact]
        public async Task when_authenticated_GetIdentityServerUserAsync_should_should_return_authenticated_user()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            var user = await _subject.GetUserAsync();
            user.GetSubjectId().Should().Be("123");
        }

        [Fact]
        public async Task when_anonymous_GetIdentityServerUserAsync_should_should_return_null()
        {
            var user = await _subject.GetUserAsync();
            user.Should().BeNull();
        }

        [Fact]
        public async Task corrupt_properties_entry_should_clear_entry()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.AddClientIdAsync("client");
            var item = _props.Items.First();
            _props.Items[item.Key] = "junk";

            var clients = await _subject.GetClientListAsync();
            clients.Should().BeEmpty();
            _props.Items.Count.Should().Be(0);
        }

        [Fact]
        public async Task adding_client_should_be_able_to_read_client()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.AddClientIdAsync("client");
            var clients = await _subject.GetClientListAsync();
            clients.Should().Contain(new string[] { "client" });
        }

        [Fact]
        public async Task adding_clients_should_be_able_to_read_clients()
        {
            _mockAuthenticationHandler.Result = AuthenticateResult.Success(new AuthenticationTicket(_user, _props, "scheme"));

            await _subject.AddClientIdAsync("client1");
            await _subject.AddClientIdAsync("client2");
            var clients = await _subject.GetClientListAsync();
            clients.Should().Contain(new string[] { "client2", "client1" });
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/DistributedDeviceFlowThrottlingServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using Microsoft.Extensions.Caching.Distributed;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class DistributedDeviceFlowThrottlingServiceTests
    {
        private TestCache cache = new TestCache();

        private readonly IdentityServerOptions options = new IdentityServerOptions {DeviceFlow = new DeviceFlowOptions {Interval = 5}};
        private readonly DeviceCode deviceCode = new DeviceCode
        {
            Lifetime = 300,
            CreationTime = DateTime.UtcNow
        };

        private const string CacheKey = "devicecode_";
        private readonly DateTime testDate = new DateTime(2018, 06, 28, 13, 37, 42);

        [Fact]
        public async Task First_Poll()
        {
            var handle = Guid.NewGuid().ToString();
            var service = new DistributedDeviceFlowThrottlingService(cache, new StubClock {UtcNowFunc = () => testDate}, options);

            var result = await service.ShouldSlowDown(handle, deviceCode);

            result.Should().BeFalse();

            CheckCacheEntry(handle);
        }

        [Fact]
        public async Task Second_Poll_Too_Fast()
        {
            var handle = Guid.NewGuid().ToString();
            var service = new DistributedDeviceFlowThrottlingService(cache, new StubClock { UtcNowFunc = () => testDate }, options);

            cache.Set(CacheKey + handle, Encoding.UTF8.GetBytes(testDate.AddSeconds(-1).ToString("O")));

            var result = await service.ShouldSlowDown(handle, deviceCode);

            result.Should().BeTrue();
            
            CheckCacheEntry(handle);
        }

        [Fact]
        public async Task Second_Poll_After_Interval()
        {
            var handle = Guid.NewGuid().ToString();
            
            var service = new DistributedDeviceFlowThrottlingService(cache, new StubClock { UtcNowFunc = () => testDate }, options);

            cache.Set($"devicecode_{handle}", Encoding.UTF8.GetBytes(testDate.AddSeconds(-deviceCode.Lifetime - 1).ToString("O")));

            var result = await service.ShouldSlowDown(handle, deviceCode);

            result.Should().BeFalse();

            CheckCacheEntry(handle);
        }

        /// 
        /// Addresses race condition from #3860
        /// 
        [Fact]
        public async Task Expired_Device_Code_Should_Not_Have_Expiry_in_Past()
        {
            var handle = Guid.NewGuid().ToString();
            deviceCode.CreationTime = testDate.AddSeconds(-deviceCode.Lifetime * 2);

            var service = new DistributedDeviceFlowThrottlingService(cache, new StubClock { UtcNowFunc = () => testDate }, options);

            var result = await service.ShouldSlowDown(handle, deviceCode);
            
            result.Should().BeFalse();

            cache.Items.TryGetValue(CacheKey + handle, out var values).Should().BeTrue();
            values?.Item2.AbsoluteExpiration.Should().BeOnOrAfter(testDate);
        }

        private void CheckCacheEntry(string handle)
        {
            cache.Items.TryGetValue(CacheKey + handle, out var values).Should().BeTrue();

            var dateTimeAsString = Encoding.UTF8.GetString(values?.Item1);
            var dateTime = DateTime.Parse(dateTimeAsString);
            dateTime.Should().Be(testDate);

            values?.Item2.AbsoluteExpiration.Should().BeCloseTo(testDate.AddSeconds(deviceCode.Lifetime), TimeSpan.FromMilliseconds(100));
        }
    }

    internal class TestCache : IDistributedCache
    {
        public readonly Dictionary> Items =
            new Dictionary>();

        public byte[] Get(string key)
        {
            if (Items.TryGetValue(key, out var value)) return value.Item1;
            return null;
        }

        public Task GetAsync(string key, CancellationToken token = new CancellationToken())
        {
            return Task.FromResult(Get(key));
        }

        public void Set(string key, byte[] value, DistributedCacheEntryOptions options)
        {
            Items.Remove(key);

            Items.Add(key, new Tuple(value, options));
        }

        public Task SetAsync(string key, byte[] value, DistributedCacheEntryOptions options, CancellationToken token = new CancellationToken())
        {
            Set(key, value, options);
            return Task.CompletedTask;
        }

        public void Refresh(string key)
        {
            throw new NotImplementedException();
        }

        public Task RefreshAsync(string key, CancellationToken token = new CancellationToken())
        {
            throw new NotImplementedException();
        }

        public void Remove(string key)
        {
            throw new NotImplementedException();
        }

        public Task RemoveAsync(string key, CancellationToken token = new CancellationToken())
        {
            throw new NotImplementedException();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/Default/NumericUserCodeServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Services;
using Xunit;

namespace IdentityServer.UnitTests.Services.Default
{
    public class NumericUserCodeGeneratorTests
    {
        [Fact]
        public async Task GenerateAsync_should_return_expected_code()
        {
            var sut = new NumericUserCodeGenerator();

            var userCode = await sut.GenerateAsync();
            var userCodeInt = int.Parse(userCode);

            userCodeInt.Should().BeGreaterOrEqualTo(100000000);
            userCodeInt.Should().BeLessOrEqualTo(999999999);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Services/InMemory/InMemoryCorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Services;
using Xunit;

namespace IdentityServer.UnitTests.Services.InMemory
{
    public class InMemoryCorsPolicyServiceTests
    {
        private const string Category = "InMemoryCorsPolicyService";

        private InMemoryCorsPolicyService _subject;
        private List _clients = new List();

        public InMemoryCorsPolicyServiceTests()
        {
            _subject = new InMemoryCorsPolicyService(TestLogger.Create(), _clients);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task client_has_origin_should_allow_origin()
        {
            _clients.Add(new Client
            {
                AllowedCorsOrigins = new List
                {
                    "http://foo"
                }
            });

            (await _subject.IsOriginAllowedAsync("http://foo")).Should().BeTrue();
        }

        [Theory]
        [InlineData("http://foo")]
        [InlineData("https://bar")]
        [InlineData("http://bar-baz")]
        [Trait("Category", Category)]
        public async Task client_does_not_has_origin_should_not_allow_origin(string clientOrigin)
        {
            _clients.Add(new Client
            {
                AllowedCorsOrigins = new List
                {
                    clientOrigin
                }
            });
            (await _subject.IsOriginAllowedAsync("http://bar")).Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task client_has_many_origins_and_origin_is_in_list_should_allow_origin()
        {
            _clients.Add(new Client
            {
                AllowedCorsOrigins = new List
                {
                    "http://foo",
                    "http://bar",
                    "http://baz"
                }
            });
            (await _subject.IsOriginAllowedAsync("http://bar")).Should().Be(true);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task client_has_many_origins_and_origin_is_in_not_list_should_not_allow_origin()
        {
            _clients.Add(new Client
            {
                AllowedCorsOrigins = new List
                {
                    "http://foo",
                    "http://bar",
                    "http://baz"
                }
            });
            (await _subject.IsOriginAllowedAsync("http://quux")).Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task many_clients_have_same_origins_should_allow_origin()
        {
            _clients.AddRange(new Client[] {
                new Client
                {
                    AllowedCorsOrigins = new List
                    {
                        "http://foo"
                    }
                },
                new Client
                {
                    AllowedCorsOrigins = new List
                    {
                        "http://foo"
                    }
                }
            });
            (await _subject.IsOriginAllowedAsync("http://foo")).Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task handle_invalid_cors_origin_format_exception()
        {
            _clients.AddRange(new Client[] {
                new Client
                {
                    AllowedCorsOrigins = new List
                    {
                        "http://foo",
                        "http://ba z"
                    }
                },
                new Client
                {
                    AllowedCorsOrigins = new List
                    {
                        "http://foo",
                        "http://bar"
                    }
                }
            });
            (await _subject.IsOriginAllowedAsync("http://bar")).Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Stores/Default/DefaultPersistedGrantStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Serialization;
using Xunit;

namespace IdentityServer.UnitTests.Stores.Default
{
    public class DefaultPersistedGrantStoreTests
    {
        private InMemoryPersistedGrantStore _store = new InMemoryPersistedGrantStore();
        private IAuthorizationCodeStore _codes;
        private IRefreshTokenStore _refreshTokens;
        private IReferenceTokenStore _referenceTokens;
        private IUserConsentStore _userConsent;
        private StubHandleGenerationService _stubHandleGenerationService = new StubHandleGenerationService();

        private ClaimsPrincipal _user = new IdentityServerUser("123").CreatePrincipal();

        public DefaultPersistedGrantStoreTests()
        {
            _codes = new DefaultAuthorizationCodeStore(_store,
                new PersistentGrantSerializer(),
                _stubHandleGenerationService,
                TestLogger.Create());
            _refreshTokens = new DefaultRefreshTokenStore(_store,
                new PersistentGrantSerializer(),
                _stubHandleGenerationService,
                TestLogger.Create());
            _referenceTokens = new DefaultReferenceTokenStore(_store,
                new PersistentGrantSerializer(),
                _stubHandleGenerationService,
                TestLogger.Create());
            _userConsent = new DefaultUserConsentStore(_store,
                new PersistentGrantSerializer(),
                _stubHandleGenerationService,
                TestLogger.Create());
        }
        
        [Fact]
        public async Task StoreAuthorizationCodeAsync_should_persist_grant()
        {
            var code1 = new AuthorizationCode()
            {
                ClientId = "test",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "scope1", "scope2" }
            };

            var handle = await _codes.StoreAuthorizationCodeAsync(code1);
            var code2 = await _codes.GetAuthorizationCodeAsync(handle);

            code1.ClientId.Should().Be(code2.ClientId);
            code1.CreationTime.Should().Be(code2.CreationTime);
            code1.Lifetime.Should().Be(code2.Lifetime);
            code1.Subject.GetSubjectId().Should().Be(code2.Subject.GetSubjectId());
            code1.CodeChallenge.Should().Be(code2.CodeChallenge);
            code1.RedirectUri.Should().Be(code2.RedirectUri);
            code1.Nonce.Should().Be(code2.Nonce);
            code1.RequestedScopes.Should().BeEquivalentTo(code2.RequestedScopes);
        }

        [Fact]
        public async Task RemoveAuthorizationCodeAsync_should_remove_grant()
        {
            var code1 = new AuthorizationCode()
            {
                ClientId = "test",
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "scope1", "scope2" }
            };

            var handle = await _codes.StoreAuthorizationCodeAsync(code1);
            await _codes.RemoveAuthorizationCodeAsync(handle);
            var code2 = await _codes.GetAuthorizationCodeAsync(handle);
            code2.Should().BeNull();
        }

        [Fact]
        public async Task StoreRefreshTokenAsync_should_persist_grant()
        {
            var token1 = new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "foo")
                    }
                },
                Version = 1
            };

            var handle = await _refreshTokens.StoreRefreshTokenAsync(token1);
            var token2 = await _refreshTokens.GetRefreshTokenAsync(handle);

            token1.ClientId.Should().Be(token2.ClientId);
            token1.CreationTime.Should().Be(token2.CreationTime);
            token1.Lifetime.Should().Be(token2.Lifetime);
            token1.Subject.GetSubjectId().Should().Be(token2.Subject.GetSubjectId());
            token1.Version.Should().Be(token2.Version);
            token1.AccessToken.Audiences.Count.Should().Be(1);
            token1.AccessToken.Audiences.First().Should().Be("aud");
            token1.AccessToken.ClientId.Should().Be(token2.AccessToken.ClientId);
            token1.AccessToken.CreationTime.Should().Be(token2.AccessToken.CreationTime);
            token1.AccessToken.Type.Should().Be(token2.AccessToken.Type);
        }

        [Fact]
        public async Task RemoveRefreshTokenAsync_should_remove_grant()
        {
            var token1 = new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "foo")
                    }
                },
                Version = 1
            };


            var handle = await _refreshTokens.StoreRefreshTokenAsync(token1);
            await _refreshTokens.RemoveRefreshTokenAsync(handle);
            var token2 = await _refreshTokens.GetRefreshTokenAsync(handle);
            token2.Should().BeNull();
        }

        [Fact]
        public async Task RemoveRefreshTokenAsync_by_sub_and_client_should_remove_grant()
        {
            var token1 = new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                AccessToken = new Token
                {
                    ClientId = "client",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "foo")
                    }
                },
                Version = 1
            };

            var handle1 = await _refreshTokens.StoreRefreshTokenAsync(token1);
            var handle2 = await _refreshTokens.StoreRefreshTokenAsync(token1);
            await _refreshTokens.RemoveRefreshTokensAsync("123", "client");

            var token2 = await _refreshTokens.GetRefreshTokenAsync(handle1);
            token2.Should().BeNull();
            token2 = await _refreshTokens.GetRefreshTokenAsync(handle2);
            token2.Should().BeNull();
        }

        [Fact]
        public async Task StoreReferenceTokenAsync_should_persist_grant()
        {
            var token1 = new Token()
            {
                ClientId = "client",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "foo")
                },
                Version = 1
            };

            var handle = await _referenceTokens.StoreReferenceTokenAsync(token1);
            var token2 = await _referenceTokens.GetReferenceTokenAsync(handle);

            token1.ClientId.Should().Be(token2.ClientId);
            token1.Audiences.Count.Should().Be(1);
            token1.Audiences.First().Should().Be("aud");
            token1.CreationTime.Should().Be(token2.CreationTime);
            token1.Type.Should().Be(token2.Type);
            token1.Lifetime.Should().Be(token2.Lifetime);
            token1.Version.Should().Be(token2.Version);
        }

        [Fact]
        public async Task RemoveReferenceTokenAsync_should_remove_grant()
        {
            var token1 = new Token()
            {
                ClientId = "client",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "foo")
                },
                Version = 1
            };

            var handle = await _referenceTokens.StoreReferenceTokenAsync(token1);
            await _referenceTokens.RemoveReferenceTokenAsync(handle);
            var token2 = await _referenceTokens.GetReferenceTokenAsync(handle);
            token2.Should().BeNull();
        }

        [Fact]
        public async Task RemoveReferenceTokenAsync_by_sub_and_client_should_remove_grant()
        {
            var token1 = new Token()
            {
                ClientId = "client",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "foo")
                },
                Version = 1
            };

            var handle1 = await _referenceTokens.StoreReferenceTokenAsync(token1);
            var handle2 = await _referenceTokens.StoreReferenceTokenAsync(token1);
            await _referenceTokens.RemoveReferenceTokensAsync("123", "client");

            var token2 = await _referenceTokens.GetReferenceTokenAsync(handle1);
            token2.Should().BeNull();
            token2 = await _referenceTokens.GetReferenceTokenAsync(handle2);
            token2.Should().BeNull();
        }

        [Fact]
        public async Task StoreUserConsentAsync_should_persist_grant()
        {
            var consent1 = new Consent()
            {
                CreationTime = DateTime.UtcNow,
                ClientId = "client",
                SubjectId = "123",
                Scopes = new string[] { "foo", "bar" }
            };

            await _userConsent.StoreUserConsentAsync(consent1);
            var consent2 = await _userConsent.GetUserConsentAsync("123", "client");

            consent2.ClientId.Should().Be(consent1.ClientId);
            consent2.SubjectId.Should().Be(consent1.SubjectId);
            consent2.Scopes.Should().BeEquivalentTo(new string[] { "bar", "foo" });
        }

        [Fact]
        public async Task RemoveUserConsentAsync_should_remove_grant()
        {
            var consent1 = new Consent()
            {
                CreationTime = DateTime.UtcNow,
                ClientId = "client",
                SubjectId = "123",
                Scopes = new string[] { "foo", "bar" }
            };

            await _userConsent.StoreUserConsentAsync(consent1);
            await _userConsent.RemoveUserConsentAsync("123", "client");
            var consent2 = await _userConsent.GetUserConsentAsync("123", "client");
            consent2.Should().BeNull();
        }

        [Fact]
        public async Task same_key_for_different_grant_types_should_not_interfere_with_each_other()
        {
            _stubHandleGenerationService.Handle = "key";

            await _referenceTokens.StoreReferenceTokenAsync(new Token()
            {
                ClientId = "client1",
                Audiences = { "aud" },
                CreationTime = DateTime.UtcNow,
                Lifetime = 10,
                Type = "type",
                Claims = new List
                {
                    new Claim("sub", "123"),
                    new Claim("scope", "bar1"),
                    new Claim("scope", "bar2")
                }
            });

            await _refreshTokens.StoreRefreshTokenAsync(new RefreshToken()
            {
                CreationTime = DateTime.UtcNow,
                Lifetime = 20,
                AccessToken = new Token
                {
                    ClientId = "client1",
                    Audiences = { "aud" },
                    CreationTime = DateTime.UtcNow,
                    Type = "type",
                    Claims = new List
                    {
                        new Claim("sub", "123"),
                        new Claim("scope", "baz1"),
                        new Claim("scope", "baz2")
                    }
                },
                Version = 1
            });

            await _codes.StoreAuthorizationCodeAsync(new AuthorizationCode()
            {
                ClientId = "client1",
                CreationTime = DateTime.UtcNow,
                Lifetime = 30,
                Subject = _user,
                CodeChallenge = "challenge",
                RedirectUri = "http://client/cb",
                Nonce = "nonce",
                RequestedScopes = new string[] { "quux1", "quux2" }
            });

            (await _codes.GetAuthorizationCodeAsync("key")).Lifetime.Should().Be(30);
            (await _refreshTokens.GetRefreshTokenAsync("key")).Lifetime.Should().Be(20);
            (await _referenceTokens.GetReferenceTokenAsync("key")).Lifetime.Should().Be(10);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Stores/InMemoryClientStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Stores;
using System;
using System.Collections.Generic;
using Xunit;
using FluentAssertions;

namespace IdentityServer.UnitTests.Stores
{
    public class InMemoryClientStoreTests
    {
        [Fact]
        public void InMemoryClient_should_throw_if_contain_duplicate_client_ids()
        {
            List clients = new List
            {
                new Client { ClientId = "1"},
                new Client { ClientId = "1"},
                new Client { ClientId = "3"}
            };

            Action act = () => new InMemoryClientStore(clients);
            act.Should().Throw();
        }

        [Fact]
        public void InMemoryClient_should_not_throw_if_does_not_contain_duplicate_client_ids()
        {
            List clients = new List
            {
                new Client { ClientId = "1"},
                new Client { ClientId = "2"},
                new Client { ClientId = "3"}
            };

            new InMemoryClientStore(clients);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Stores/InMemoryDeviceFlowStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Stores
{
    public class InMemoryDeviceFlowStoreTests
    {
        private InMemoryDeviceFlowStore _store = new InMemoryDeviceFlowStore();

        [Fact]
        public async Task StoreDeviceAuthorizationAsync_should_persist_data_by_user_code()
        {
            var deviceCode = Guid.NewGuid().ToString();
            var userCode = Guid.NewGuid().ToString();
            var data = new DeviceCode
            {
                ClientId = Guid.NewGuid().ToString(),
                CreationTime = DateTime.UtcNow,
                Lifetime = 300,
                IsAuthorized = false,
                IsOpenId = true,
                Subject = null,
                RequestedScopes = new[] {"scope1", "scope2"}
            };

            await _store.StoreDeviceAuthorizationAsync(deviceCode, userCode, data);
            var foundData = await _store.FindByUserCodeAsync(userCode);

            foundData.ClientId.Should().Be(data.ClientId);
            foundData.CreationTime.Should().Be(data.CreationTime);
            foundData.Lifetime.Should().Be(data.Lifetime);
            foundData.IsAuthorized.Should().Be(data.IsAuthorized);
            foundData.IsOpenId.Should().Be(data.IsOpenId);
            foundData.Subject.Should().Be(data.Subject);
            foundData.RequestedScopes.Should().BeEquivalentTo(data.RequestedScopes);
        }

        [Fact]
        public async Task StoreDeviceAuthorizationAsync_should_persist_data_by_device_code()
        {
            var deviceCode = Guid.NewGuid().ToString();
            var userCode = Guid.NewGuid().ToString();
            var data = new DeviceCode
            {
                ClientId = Guid.NewGuid().ToString(),
                CreationTime = DateTime.UtcNow,
                Lifetime = 300,
                IsAuthorized = false,
                IsOpenId = true,
                Subject = null,
                RequestedScopes = new[] {"scope1", "scope2"}
            };

            await _store.StoreDeviceAuthorizationAsync(deviceCode, userCode, data);
            var foundData = await _store.FindByDeviceCodeAsync(deviceCode);

            foundData.ClientId.Should().Be(data.ClientId);
            foundData.CreationTime.Should().Be(data.CreationTime);
            foundData.Lifetime.Should().Be(data.Lifetime);
            foundData.IsAuthorized.Should().Be(data.IsAuthorized);
            foundData.IsOpenId.Should().Be(data.IsOpenId);
            foundData.Subject.Should().Be(data.Subject);
            foundData.RequestedScopes.Should().BeEquivalentTo(data.RequestedScopes);
        }

        [Fact]
        public async Task UpdateByUserCodeAsync_should_update_data()
        {
            var deviceCode = Guid.NewGuid().ToString();
            var userCode = Guid.NewGuid().ToString();
            var initialData = new DeviceCode
            {
                ClientId = Guid.NewGuid().ToString(),
                CreationTime = DateTime.UtcNow,
                Lifetime = 300,
                IsAuthorized = false,
                IsOpenId = true,
                Subject = null,
                RequestedScopes = new[] {"scope1", "scope2"}
            };

            await _store.StoreDeviceAuthorizationAsync(deviceCode, userCode, initialData);

            var updatedData = new DeviceCode
            {
                ClientId = Guid.NewGuid().ToString(),
                CreationTime = initialData.CreationTime.AddHours(2),
                Lifetime = initialData.Lifetime + 600,
                IsAuthorized = !initialData.IsAuthorized,
                IsOpenId = !initialData.IsOpenId,
                Subject = new ClaimsPrincipal(new ClaimsIdentity(new List {new Claim("sub", "123")})),
                RequestedScopes = new[] {"api1", "api2"}
            };

            await _store.UpdateByUserCodeAsync(userCode, updatedData);

            var foundData = await _store.FindByUserCodeAsync(userCode);

            foundData.ClientId.Should().Be(updatedData.ClientId);
            foundData.CreationTime.Should().Be(updatedData.CreationTime);
            foundData.Lifetime.Should().Be(updatedData.Lifetime);
            foundData.IsAuthorized.Should().Be(updatedData.IsAuthorized);
            foundData.IsOpenId.Should().Be(updatedData.IsOpenId);
            foundData.Subject.Should().BeEquivalentTo(updatedData.Subject);
            foundData.RequestedScopes.Should().BeEquivalentTo(updatedData.RequestedScopes);
        }

        [Fact]
        public async Task RemoveByDeviceCodeAsync_should_update_data()
        {
            var deviceCode = Guid.NewGuid().ToString();
            var userCode = Guid.NewGuid().ToString();
            var data = new DeviceCode
            {
                ClientId = Guid.NewGuid().ToString(),
                CreationTime = DateTime.UtcNow,
                Lifetime = 300,
                IsAuthorized = false,
                IsOpenId = true,
                Subject = null,
                RequestedScopes = new[] { "scope1", "scope2" }
            };

            await _store.StoreDeviceAuthorizationAsync(deviceCode, userCode, data);
            await _store.RemoveByDeviceCodeAsync(deviceCode);
            var foundData = await _store.FindByUserCodeAsync(userCode);

            foundData.Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Stores/InMemoryPersistedGrantStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;
using FluentAssertions;
using System.Threading.Tasks;
using System.Linq;

namespace IdentityServer.UnitTests.Stores
{
    public class InMemoryPersistedGrantStoreTests
    {
        InMemoryPersistedGrantStore _subject;

        public InMemoryPersistedGrantStoreTests()
        {
            _subject = new InMemoryPersistedGrantStore();
        }

        [Fact]
        public async Task Store_should_persist_value()
        {
            {
                var item = await _subject.GetAsync("key1");
                item.Should().BeNull();
            }

            await _subject.StoreAsync(new PersistedGrant() { Key = "key1" });

            {
                var item = await _subject.GetAsync("key1");
                item.Should().NotBeNull();
            }
        }

        [Fact]
        public async Task GetAll_should_filter()
        {
            await _subject.StoreAsync(new PersistedGrant() { Key = "key1", SubjectId = "sub1", ClientId = "client1", SessionId = "session1" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key2", SubjectId = "sub1", ClientId = "client2", SessionId = "session1" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key3", SubjectId = "sub1", ClientId = "client1", SessionId = "session2" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key4", SubjectId = "sub1", ClientId = "client3", SessionId = "session2" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key5", SubjectId = "sub1", ClientId = "client4", SessionId = "session3" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key6", SubjectId = "sub1", ClientId = "client4", SessionId = "session4" });

            await _subject.StoreAsync(new PersistedGrant() { Key = "key7", SubjectId = "sub2", ClientId = "client4", SessionId = "session4" });



            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key1", "key2", "key3", "key4", "key5", "key6" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key7" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub3"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client1"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key1", "key3" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client2"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key2" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client3"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key4" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client4"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key5", "key6" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client5"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2",
                ClientId = "client1"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2",
                ClientId = "client4"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key7" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub3",
                ClientId = "client1"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client1",
                SessionId = "session1"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key1" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client1",
                SessionId = "session2"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key3" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client1",
                SessionId = "session3"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client2",
                SessionId = "session1"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key2" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client2",
                SessionId = "session2"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub1",
                ClientId = "client4",
                SessionId = "session4"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key6" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2",
                ClientId = "client4",
                SessionId = "session4"
            }))
            .Select(x => x.Key).Should().BeEquivalentTo(new[] { "key7" });

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2",
                ClientId = "client4",
                SessionId = "session1"
            }))
            .Select(x => x.Key).Should().BeEmpty();

            (await _subject.GetAllAsync(new PersistedGrantFilter
            {
                SubjectId = "sub2",
                ClientId = "client4",
                SessionId = "session5"
            }))
            .Select(x => x.Key).Should().BeEmpty();
        }

        [Fact]
        public async Task RemoveAll_should_filter()
        {
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1"
                });
                (await _subject.GetAsync("key1")).Should().BeNull();
                (await _subject.GetAsync("key2")).Should().BeNull();
                (await _subject.GetAsync("key3")).Should().BeNull();
                (await _subject.GetAsync("key4")).Should().BeNull();
                (await _subject.GetAsync("key5")).Should().BeNull();
                (await _subject.GetAsync("key6")).Should().BeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub2"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().BeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub3"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client1"
                });
                (await _subject.GetAsync("key1")).Should().BeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().BeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client2"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().BeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client3"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().BeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client4"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().BeNull();
                (await _subject.GetAsync("key6")).Should().BeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client5"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub2",
                    ClientId = "client1"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client4"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().BeNull();
                (await _subject.GetAsync("key6")).Should().BeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub3",
                    ClientId = "client1"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client1",
                    SessionId = "session1"
                });
                (await _subject.GetAsync("key1")).Should().BeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client1",
                    SessionId = "session2"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().BeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client1",
                    SessionId = "session3"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client2",
                    SessionId = "session1"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().BeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client2",
                    SessionId = "session2"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub1",
                    ClientId = "client4",
                    SessionId = "session4"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().BeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub2",
                    ClientId = "client4",
                    SessionId = "session4"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().BeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub2",
                    ClientId = "client4",
                    SessionId = "session1"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub2",
                    ClientId = "client4",
                    SessionId = "session5"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
            {
                await Populate();
                await _subject.RemoveAllAsync(new PersistedGrantFilter
                {
                    SubjectId = "sub3",
                    ClientId = "client1",
                    SessionId = "session1"
                });
                (await _subject.GetAsync("key1")).Should().NotBeNull();
                (await _subject.GetAsync("key2")).Should().NotBeNull();
                (await _subject.GetAsync("key3")).Should().NotBeNull();
                (await _subject.GetAsync("key4")).Should().NotBeNull();
                (await _subject.GetAsync("key5")).Should().NotBeNull();
                (await _subject.GetAsync("key6")).Should().NotBeNull();
                (await _subject.GetAsync("key7")).Should().NotBeNull();
            }
        }

        private async Task Populate()
        {
            await _subject.StoreAsync(new PersistedGrant() { Key = "key1", SubjectId = "sub1", ClientId = "client1", SessionId = "session1" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key2", SubjectId = "sub1", ClientId = "client2", SessionId = "session1" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key3", SubjectId = "sub1", ClientId = "client1", SessionId = "session2" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key4", SubjectId = "sub1", ClientId = "client3", SessionId = "session2" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key5", SubjectId = "sub1", ClientId = "client4", SessionId = "session3" });
            await _subject.StoreAsync(new PersistedGrant() { Key = "key6", SubjectId = "sub1", ClientId = "client4", SessionId = "session4" });

            await _subject.StoreAsync(new PersistedGrant() { Key = "key7", SubjectId = "sub2", ClientId = "client4", SessionId = "session4" });
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Stores/InMemoryResourcesStoreTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Stores;
using System;
using System.Collections.Generic;
using Xunit;
using FluentAssertions;

namespace IdentityServer.UnitTests.Stores
{
    public class InMemoryResourcesStoreTests
    {
        [Fact]
        public void InMemoryResourcesStore_should_throw_if_contains_duplicate_names()
        {
            List identityResources = new List
            {
                new IdentityResource { Name = "A" },
                new IdentityResource { Name = "A" },
                new IdentityResource { Name = "C" }
            };

            List apiResources = new List
            {
                new ApiResource { Name = "B" },
                new ApiResource { Name = "B" },
                new ApiResource { Name = "C" }
            };

            List scopes = new List
            {
                new ApiScope { Name = "B" },
                new ApiScope { Name = "C" },
                new ApiScope { Name = "C" },
            };

            Action act = () => new InMemoryResourcesStore(identityResources, null, null);
            act.Should().Throw();

            act = () => new InMemoryResourcesStore(null, apiResources, null);
            act.Should().Throw();
            
            act = () => new InMemoryResourcesStore(null, null, scopes);
            act.Should().Throw();
        }

        [Fact]
        public void InMemoryResourcesStore_should_not_throw_if_does_not_contains_duplicate_names()
        {
            List identityResources = new List
            {
                new IdentityResource { Name = "A" },
                new IdentityResource { Name = "B" },
                new IdentityResource { Name = "C" }
            };

            List apiResources = new List
            {
                new ApiResource { Name = "A" },
                new ApiResource { Name = "B" },
                new ApiResource { Name = "C" }
            };

            List apiScopes = new List
            {
                new ApiScope { Name = "A" },
                new ApiScope { Name = "B" },
                new ApiScope { Name = "C" },
            };
            
            new InMemoryResourcesStore(identityResources, null, null);
            new InMemoryResourcesStore(null, apiResources, null);
            new InMemoryResourcesStore(null, null, apiScopes);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AccessTokenValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.IdentityModel.Tokens.Jwt;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class AccessTokenValidation
    {
        private const string Category = "Access token validation";

        private IClientStore _clients = Factory.CreateClientStore();
        private IdentityServerOptions _options = new IdentityServerOptions();
        private StubClock _clock = new StubClock();

        static AccessTokenValidation()
        {
            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
        }

        private DateTime now;
        public DateTime UtcNow
        {
            get
            {
                if (now > DateTime.MinValue) return now;
                return DateTime.UtcNow;
            }
        }

        public AccessTokenValidation()
        {
            _clock.UtcNowFunc = () => UtcNow;
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Reference_Token()
        {
            var store = Factory.CreateReferenceTokenStore();
            var validator = Factory.CreateTokenValidator(store);

            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write");

            var handle = await store.StoreReferenceTokenAsync(token);

            var result = await validator.ValidateAccessTokenAsync(handle);

            result.IsError.Should().BeFalse();
            result.Claims.Count().Should().Be(8);
            result.Claims.First(c => c.Type == JwtClaimTypes.ClientId).Value.Should().Be("roclient");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Reference_Token_with_required_Scope()
        {
            var store = Factory.CreateReferenceTokenStore();
            var validator = Factory.CreateTokenValidator(store);

            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write");

            var handle = await store.StoreReferenceTokenAsync(token);

            var result = await validator.ValidateAccessTokenAsync(handle, "read");

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Reference_Token_with_missing_Scope()
        {
            var store = Factory.CreateReferenceTokenStore();
            var validator = Factory.CreateTokenValidator(store);

            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write");

            var handle = await store.StoreReferenceTokenAsync(token);

            var result = await validator.ValidateAccessTokenAsync(handle, "missing");

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InsufficientScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Reference_Token()
        {
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateAccessTokenAsync("unknown");

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Reference_Token_Too_Long()
        {
            var validator = Factory.CreateTokenValidator();
            var options = new IdentityServerOptions();

            var longToken = "x".Repeat(options.InputLengthRestrictions.TokenHandle + 1);
            var result = await validator.ValidateAccessTokenAsync(longToken);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Expired_Reference_Token()
        {
            now = DateTime.UtcNow;

            var store = Factory.CreateReferenceTokenStore();
            var validator = Factory.CreateTokenValidator(store, clock:_clock);

            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 2, "read", "write");
            token.CreationTime = now;

            var handle = await store.StoreReferenceTokenAsync(token);

            now = now.AddSeconds(3);

            var result = await validator.ValidateAccessTokenAsync(handle);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.ExpiredToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Malformed_JWT_Token()
        {
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateAccessTokenAsync("unk.nown");

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_JWT_Token()
        {
            var signer = Factory.CreateDefaultTokenCreator();
            var jwt = await signer.CreateTokenAsync(TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write"));

            var validator = Factory.CreateTokenValidator(null);
            var result = await validator.ValidateAccessTokenAsync(jwt);

            result.IsError.Should().BeFalse();
        }
        
        [Theory]
        [InlineData(true)]
        [InlineData(false)]
        [Trait("Category", Category)]
        public async Task JWT_Token_with_scopes_have_expected_claims(bool flag)
        {
            var options = TestIdentityServerOptions.Create();
            options.EmitScopesAsSpaceDelimitedStringInJwt = flag;
            
            var signer = Factory.CreateDefaultTokenCreator(options);
            var jwt = await signer.CreateTokenAsync(TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write"));

            var validator = Factory.CreateTokenValidator(null);
            var result = await validator.ValidateAccessTokenAsync(jwt);

            result.IsError.Should().BeFalse();
            result.Jwt.Should().NotBeNullOrEmpty();
            result.Client.ClientId.Should().Be("roclient");

            result.Claims.Count().Should().Be(8);
            var scopes = result.Claims.Where(c => c.Type == "scope").Select(c => c.Value).ToArray();
            scopes.Count().Should().Be(2);
            scopes[0].Should().Be("read");
            scopes[1].Should().Be("write");
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task JWT_Token_invalid_Issuer()
        {
            var signer = Factory.CreateDefaultTokenCreator();
            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "roclient" }, "valid", 600, "read", "write");
            token.Issuer = "invalid";
            var jwt = await signer.CreateTokenAsync(token);

            var validator = Factory.CreateTokenValidator(null);
            var result = await validator.ValidateAccessTokenAsync(jwt);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task JWT_Token_Too_Long()
        {
            var signer = Factory.CreateDefaultTokenCreator();
            var jwt = await signer.CreateTokenAsync(TokenFactory.CreateAccessTokenLong(new Client { ClientId = "roclient" }, "valid", 600, 1000, "read", "write"));
            
            var validator = Factory.CreateTokenValidator(null);
            var result = await validator.ValidateAccessTokenAsync(jwt);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_AccessToken_but_Client_not_active()
        {
            var store = Factory.CreateReferenceTokenStore();
            var validator = Factory.CreateTokenValidator(store);

            var token = TokenFactory.CreateAccessToken(new Client { ClientId = "unknown" }, "valid", 600, "read", "write");

            var handle = await store.StoreReferenceTokenAsync(token);

            var result = await validator.ValidateAccessTokenAsync(handle);

            result.IsError.Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ClientValidation_Code.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ClientValidation_Code
    {
        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task Code_Request_Unknown_Scope()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "unknown");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task OpenId_Code_Request_Invalid_RedirectUri()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://invalid");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task OpenId_Code_Request_Invalid_IdToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task OpenId_Code_Request_Invalid_IdTokenToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task OpenId_Code_Request_With_Unknown_Client()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "unknown");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Code")]
        public async Task OpenId_Code_Request_With_Restricted_Scope()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient_restricted");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid profile");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ClientValidation_IdToken.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{

    public class Authorize_ClientValidation_IdToken
    {
        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - IdToken")]
        public async Task Mixed_IdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ClientValidation_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ClientValidation_Invalid
    {
        private const string Category = "AuthorizeRequest Client Validation - Invalid";

        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Protocol_Client()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "wsfed");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://wsfed/callback");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ClientValidation_Token.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ClientValidation_Token
    {
        private const string Category = "AuthorizeRequest Client Validation - Token";

        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        [Fact]
        [Trait("Category", Category)]
        public async Task Mixed_Token_Request_Without_OpenId_Scope()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource profile");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Token);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IdTokenToken_Request_with_no_AAVB()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient_no_aavb");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }


        [Fact]
        [Trait("Category", Category)]
        public async Task CodeIdTokenToken_Request_with_no_AAVB()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient_no_aavb");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "nonce");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdTokenToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ClientValidation_Valid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ClientValidation_Valid
    {
        private const string Category = "AuthorizeRequest Client Validation - Valid";

        private IdentityServerOptions _options = TestIdentityServerOptions.Create();

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Resource_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_Code_Request_Multiple_Scopes()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid profile resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_CodeIdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "nonce");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_CodeIdTokenToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "nonce");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdTokenToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_CodeIdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "nonce");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_CodeIdTokenToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "nonce");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdTokenToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_IdTokenToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_IdTokenToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_IdTokenToken_Request_Multiple_Scopes()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid profile resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Resource_Token_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Token);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);
            
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", "AuthorizeRequest Client Validation - Valid")]
        public async Task Valid_OpenId_TokenIdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, "token id_token"); // Unconventional order
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ProtocolValidation_CustomValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ProtocolValidation_CustomValidator
    {
        private const string Category = "AuthorizeRequest Protocol Validation";

        private StubAuthorizeRequestValidator _stubAuthorizeRequestValidator = new StubAuthorizeRequestValidator();
        private AuthorizeRequestValidator _subject;

        public Authorize_ProtocolValidation_CustomValidator()
        {
            _subject = Factory.CreateAuthorizeRequestValidator(customValidator: _stubAuthorizeRequestValidator);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task should_call_custom_validator()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var result = await _subject.ValidateAsync(parameters);

            _stubAuthorizeRequestValidator.WasCalled.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task should_return_error_info_from_custom_validator()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            _stubAuthorizeRequestValidator.Callback = ctx =>
            {
                ctx.Result = new AuthorizeRequestValidationResult(ctx.Result.ValidatedRequest, "foo", "bar");
            };
            var result = await _subject.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be("foo");
            result.ErrorDescription.Should().Be("bar");
        }
    }

    public class StubAuthorizeRequestValidator : ICustomAuthorizeRequestValidator
    {
        public Action Callback;
        public bool WasCalled { get; set; }

        public Task ValidateAsync(CustomAuthorizeRequestValidationContext context)
        {
            WasCalled = true;
            Callback?.Invoke(context);
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ProtocolValidation_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ProtocolValidation_Invalid
    {
        private const string Category = "AuthorizeRequest Protocol Validation";

        [Fact]
        [Trait("Category", Category)]
        public void Null_Parameter()
        {
            var validator = Factory.CreateAuthorizeRequestValidator();

            Func act = () => validator.ValidateAsync(null);

            act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Empty_Parameters()
        {
            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(new NameValueCollection());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        // fails because openid scope is requested, but no response type that indicates an identity token
        [Fact]
        [Trait("Category", Category)]
        public async Task OpenId_Token_Only_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, IdentityServerConstants.StandardScopes.OpenId);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Token);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Resource_Only_IdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Mixed_Token_Only_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Token);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task OpenId_IdToken_Request_Nonce_Missing()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_ClientId()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/callback");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_Scope()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_RedirectUri()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "client");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Malformed_RedirectUri()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "client");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "malformed");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Malformed_RedirectUri_Triple_Slash()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "client");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https:///attacker.com");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnsupportedResponseType);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, "unknown");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnsupportedResponseType);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_IdToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_IdTokenToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_CodeToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_CodeIdToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_CodeIdTokenToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Malformed_MaxAge()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.MaxAge, "malformed");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Negative_MaxAge()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.MaxAge, "-1");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_TokenIdToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, "token id_token"); // Unconventional order
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResponseMode_For_IdTokenCodeToken_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, "id_token code token"); // Unconventional ordering
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Query);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task prompt_none_and_other_values_should_fail()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Fragment);
            parameters.Add(OidcConstants.AuthorizeRequest.Prompt, "none login");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ProtocolValidation_PKCE.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ProtocolValidation_Valid_PKCE
    {
        private const string Category = "AuthorizeRequest Protocol Validation - PKCE";

        private InputLengthRestrictions lengths = new InputLengthRestrictions();

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task valid_openid_code_request_with_challenge_and_plain_method_should_be_forbidden_if_plain_is_forbidden(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength));
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallengeMethod, OidcConstants.CodeChallengeMethods.Plain);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.ErrorDescription.Should().Be("Transform algorithm not supported");
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task valid_openid_code_request_with_challenge_and_sh256_method_should_be_allowed(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength));
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallengeMethod, OidcConstants.CodeChallengeMethods.Sha256);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(false);
        }

        [Theory]
        [InlineData("codeclient.pkce.plain")]
        [InlineData("codeclient.plain")]
        [Trait("Category", Category)]
        public async Task valid_openid_code_request_with_challenge_and_missing_method_should_be_allowed_if_plain_is_allowed(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength));
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(false);
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task valid_openid_code_request_with_challenge_and_missing_method_should_be_forbidden_if_plain_is_forbidden(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength));
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.ErrorDescription.Should().Be("Transform algorithm not supported");
        }


        [Fact]
        [Trait("Category", Category)]
        public async Task openid_code_request_missing_challenge_should_be_rejected()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient.pkce");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
            result.ErrorDescription.Should().Be("code challenge required");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task openid_hybrid_request_missing_challenge_should_be_rejected()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "hybridclient.pkce");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.CodeIdToken);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
            result.ErrorDescription.Should().Be("code challenge required");
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient.pkce.plain")]
        [InlineData("codeclient")]
        [InlineData("codeclient.plain")]
        [Trait("Category", Category)]
        public async Task openid_code_request_with_challenge_and_invalid_method_should_be_rejected(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength));
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallengeMethod, "invalid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
            result.ErrorDescription.Should().Be("Transform algorithm not supported");
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient.pkce.plain")]
        [InlineData("codeclient")]
        [InlineData("codeclient.plain")]
        [Trait("Category", Category)]
        public async Task openid_code_request_with_too_short_challenge_should_be_rejected(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMinLength - 1));
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallengeMethod, OidcConstants.CodeChallengeMethods.Plain);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient.pkce.plain")]
        [InlineData("codeclient")]
        [InlineData("codeclient.plain")]
        [Trait("Category", Category)]
        public async Task openid_code_request_with_too_long_challenge_should_be_rejected(string clientId)
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, clientId);
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallenge, "x".Repeat(lengths.CodeChallengeMaxLength + 1));
            parameters.Add(OidcConstants.AuthorizeRequest.CodeChallengeMethod, OidcConstants.CodeChallengeMethods.Plain);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(true);
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidRequest);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/AuthorizeRequest Validation/Authorize_ProtocolValidation_Valid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using Xunit;

namespace IdentityServer.UnitTests.Validation.AuthorizeRequest_Validation
{
    public class Authorize_ProtocolValidation_Valid
    {
        private const string Category = "AuthorizeRequest Protocol Validation - Valid";

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().Be(false);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Resource_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_Code_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Resource_Token_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Token);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_IdToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_IdTokenToken_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_IdToken_With_FormPost_ResponseMode_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, IdentityServerConstants.StandardScopes.OpenId);
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.FormPost);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_IdToken_Token_With_FormPost_ResponseMode_Request()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "implicitclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid resource");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "oob://implicit/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.IdTokenToken);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.FormPost);
            parameters.Add(OidcConstants.AuthorizeRequest.Nonce, "abc");

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_ResponseMode_For_Code_ResponseType()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Fragment);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task anonymous_user_should_produce_session_state_value()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Fragment);
            parameters.Add(OidcConstants.AuthorizeRequest.Prompt, OidcConstants.PromptModes.None);

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.ValidatedRequest.SessionId.Should().NotBeNull();
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task multiple_prompt_values_should_be_accepted()
        {
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.AuthorizeRequest.ClientId, "codeclient");
            parameters.Add(OidcConstants.AuthorizeRequest.Scope, "openid");
            parameters.Add(OidcConstants.AuthorizeRequest.RedirectUri, "https://server/cb");
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseType, OidcConstants.ResponseTypes.Code);
            parameters.Add(OidcConstants.AuthorizeRequest.ResponseMode, OidcConstants.ResponseModes.Fragment);
            parameters.Add(OidcConstants.AuthorizeRequest.Prompt, OidcConstants.PromptModes.Consent.ToString() + " " + OidcConstants.PromptModes.Login.ToString());

            var validator = Factory.CreateAuthorizeRequestValidator();
            var result = await validator.ValidateAsync(parameters);

            result.ValidatedRequest.PromptModes.Count().Should().Be(2);
            result.ValidatedRequest.PromptModes.Should().Contain(OidcConstants.PromptModes.Login);
            result.ValidatedRequest.PromptModes.Should().Contain(OidcConstants.PromptModes.Consent);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/BearerTokenUsageValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class BearerTokenUsageValidation
    {
        private const string Category = "BearerTokenUsageValidator Tests";

        [Fact]
        [Trait("Category", Category)]
        public async Task No_Header_no_Body_Get()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";

            var validator = new BearerTokenUsageValidator(TestLogger.Create< BearerTokenUsageValidator>());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task No_Header_no_Body_Post()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "POST";

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Non_Bearer_Scheme_Header()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";
            ctx.Request.Headers.Append("Authorization", new string[] { "Foo Bar" });

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Empty_Bearer_Scheme_Header()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";
            ctx.Request.Headers.Append("Authorization", new string[] { "Bearer" });

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Whitespaces_Bearer_Scheme_Header()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";
            ctx.Request.Headers.Append("Authorization", new string[] { "Bearer           " });

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Bearer_Scheme_Header()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "GET";
            ctx.Request.Headers.Append("Authorization", new string[] { "Bearer token" });

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeTrue();
            result.Token.Should().Be("token");
            result.UsageType.Should().Be(BearerTokenUsageType.AuthorizationHeader);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Body_Post()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "POST";
            ctx.Request.ContentType = "application/x-www-form-urlencoded";
            var body = "access_token=token";
            ctx.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeTrue();
            result.Token.Should().Be("token");
            result.UsageType.Should().Be(BearerTokenUsageType.PostBody);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Body_Post_empty_Token()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "POST";
            ctx.Request.ContentType = "application/x-www-form-urlencoded";
            var body = "access_token=";
            ctx.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Body_Post_Whitespace_Token()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "POST";
            ctx.Request.ContentType = "application/x-www-form-urlencoded";
            var body = "access_token=                ";
            ctx.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Body_Post_no_Token()
        {
            var ctx = new DefaultHttpContext();
            ctx.Request.Method = "POST";
            ctx.Request.ContentType = "application/x-www-form-urlencoded";
            var body = "foo=bar";
            ctx.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));

            var validator = new BearerTokenUsageValidator(TestLogger.Create());
            var result = await validator.ValidateAsync(ctx);

            result.TokenFound.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/ClientConfigurationValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using System;
using System.Threading.Tasks;
using IdentityServer.UnitTests.Validation.Setup;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class ClientConfigurationValidation
    {
        private const string Category = "Client Configuration Validation Tests";
        private IClientConfigurationValidator _validator;
        IdentityServerOptions _options;

        public ClientConfigurationValidation()
        {
            _options = new IdentityServerOptions();
            _validator = new DefaultClientConfigurationValidator(_options);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Standard_clients_should_succeed()
        {
            foreach (var client in TestClients.Get())
            {
                // deliberate invalid configuration
                if (client.ClientId == "implicit_and_client_creds") continue;

                var context = await ValidateAsync(client);

                if (!context.IsValid)
                {
                    throw new System.Exception($"client {client.ClientId} failed configuration validation: {context.ErrorMessage}");
                }

            }
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_access_token_lifetime_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                RequireClientSecret = false,
                AllowedScopes = { "foo" },

                AccessTokenLifetime = 0
            };

            await ShouldFailAsync(client, "access token lifetime is 0 or negative");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_identity_token_lifetime_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                RequireClientSecret = false,
                AllowedScopes = { "foo" },

                IdentityTokenLifetime = 0
            };

            await ShouldFailAsync(client, "identity token lifetime is 0 or negative");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_absolute_refresh_token_lifetime_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                RequireClientSecret = false,
                AllowedScopes = { "foo" },

                AbsoluteRefreshTokenLifetime = -1
            };

            await ShouldFailAsync(client, "absolute refresh token lifetime is negative");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_sliding_refresh_token_lifetime_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                RequireClientSecret = false,
                AllowedScopes = { "foo" },

                SlidingRefreshTokenLifetime = -1
            };

            await ShouldFailAsync(client, "sliding refresh token lifetime is negative");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_allowed_grant_type_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                RequireClientSecret = false,
                AllowedScopes = { "foo" },
            };

            await ShouldFailAsync(client, "no allowed grant type specified");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_client_secret_for_client_credentials_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                AllowedScopes = { "foo" },
            };

            await ShouldFailAsync(client, "Client secret is required for client_credentials, but no client secret is configured.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_client_secret_for_implicit_and_client_credentials_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ImplicitAndClientCredentials,
                RedirectUris = { "https://foo" },
                AllowedScopes = { "foo" },
            };

            await ShouldFailAsync(client, "Client secret is required for client_credentials, but no client secret is configured.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_client_secret_for_hybrid_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Hybrid,
                RedirectUris = { "https://foo" },
                AllowedScopes = { "foo" },
            };

            await ShouldFailAsync(client, "Client secret is required for hybrid, but no client secret is configured.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_client_secret_for_code_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Code,
                RedirectUris = { "https://foo" },
                AllowedScopes = { "foo" },
            };

            await ShouldFailAsync(client, "Client secret is required for authorization_code, but no client secret is configured.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Not_required_client_secret_for_hybrid_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Hybrid,
                RequireClientSecret = false,
                RedirectUris = { "https://foo" },
                AllowedScopes = { "foo" },
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_client_secret_for_implicit_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = { "https://foo" }
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task empty_grant_types_collection_should_fail()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = { },
                AllowedScopes = { "foo" },
                RedirectUris = { "https://foo" }
            };

            var context = await ValidateAsync(client);
            await ShouldFailAsync(client, "no allowed grant type specified");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task null_redirect_uris_collection_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                RedirectUris = null,
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task null_post_logout_redirect_uris_collection_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                PostLogoutRedirectUris = null
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }
        [Fact]
        [Trait("Category", Category)]
        public async Task null_redirect_uris_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                RedirectUris = { null }
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }
        [Fact]
        [Trait("Category", Category)]
        public async Task null_post_logout_redirect_uris_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                PostLogoutRedirectUris = { null }
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }
        [Fact]
        [Trait("Category", Category)]
        public async Task empty_redirect_uris_collection_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                RedirectUris = { },
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }
        [Fact]
        [Trait("Category", Category)]
        public async Task empty_post_logout_redirect_uris_collection_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.ClientCredentials,
                ClientSecrets = { new Secret("hash") },
                AllowedScopes = { "foo" },
                PostLogoutRedirectUris = { },
            };

            var context = await ValidateAsync(client);
            context.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ValidateUriSchemesAsync_for_invalid_redirecturi_scheme_should_fail()
        {
            _options.Validation.InvalidRedirectUriPrefixes.Add("custom");
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = { "http://callback", "custom://callback" }
            };

            var result = await ValidateAsync(client);
            await ShouldFailAsync(client, "RedirectUri 'custom://callback' uses invalid scheme. If this scheme should be allowed, then configure it via ValidationOptions.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ValidateUriSchemesAsync_for_null_redirecturi_scheme_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = null
            };

            var result = await ValidateAsync(client);
            result.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ValidateUriSchemesAsync_for_valid_redirect_uri_scheme_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = { "http://callback", "custom://callback" }
            };

            var result = await ValidateAsync(client);
            result.IsValid.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ValidateUriSchemesAsync_for_invalid_post_logout_redirect_uri_scheme_should_fail()
        {
            _options.Validation.InvalidRedirectUriPrefixes.Add("custom");
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = { "http://callback" },
                PostLogoutRedirectUris = { "http://postcallback", "custom://postcallback" }
            };

            var result = await ValidateAsync(client);
            await ShouldFailAsync(client, "PostLogoutRedirectUri 'custom://postcallback' uses invalid scheme. If this scheme should be allowed, then configure it via ValidationOptions.");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task ValidateUriSchemesAsync_for_valid_post_logout_redirect_uri_scheme_should_succeed()
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                AllowedScopes = { "foo" },
                RedirectUris = { "http://callback" },
                PostLogoutRedirectUris = { "http://postcallback", "custom://postcallback" }
            };

            var result = await ValidateAsync(client);
            result.IsValid.Should().BeTrue();
        }

        [Theory]
        [Trait("Category", Category)]
        [InlineData("bad")]
        [InlineData("urn:foo")]
        [InlineData("urn:foo:123")]
        [InlineData("http://foo/")]
        [InlineData("http://foo:80/path")]
        [InlineData("http://foo/path")]
        [InlineData("http://foo:123/path")]
        [InlineData("https://foo:443/path")]
        [InlineData("custom://foo/")]
        [InlineData("custom://foo/path")]
        [InlineData("custom://foo:443/")]
        [InlineData("custom://foo:443/path")]
        [InlineData("")]
        [InlineData("   ")]
        [InlineData((string)null)]
        public async Task ValidateAllowedCorsOriginsAsync_should_report_invalid_URL_format(string origin)
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                RedirectUris = { "http://client" },
                AllowedCorsOrigins = { origin }
            };

            var result = await ValidateAsync(client);
            result.IsValid.Should().BeFalse();
            result.ErrorMessage.Should().Contain("invalid origin");
            if (!String.IsNullOrWhiteSpace(origin))
            {
                result.ErrorMessage.Should().Contain(origin);
            }
            else
            {
                result.ErrorMessage.Should().Contain("empty value");
            }
        }

        [Theory]
        [Trait("Category", Category)]
        [InlineData("http://foo")]
        [InlineData("http://foo:80")]
        [InlineData("https://foo")]
        [InlineData("http://foo:123")]
        [InlineData("https://foo:456")]
        [InlineData("https://foo:443")]
        [InlineData("custom://foo")]
        [InlineData("custom://foo:443")]
        public async Task ValidateAllowedCorsOriginsAsync_should_allow_valid_formats(string origin)
        {
            var client = new Client
            {
                ClientId = "id",
                AllowedGrantTypes = GrantTypes.Implicit,
                RedirectUris = { "http://client" },
                AllowedCorsOrigins = { origin }
            };

            var result = await ValidateAsync(client);
            result.IsValid.Should().BeTrue();
        }


        private async Task ValidateAsync(Client client)
        {
            var context = new ClientConfigurationValidationContext(client);
            await _validator.ValidateAsync(context);

            return context;
        }

        private async Task ShouldFailAsync(Client client, string expectedError)
        {
            var context = await ValidateAsync(client);

            context.IsValid.Should().BeFalse();
            context.ErrorMessage.Should().Be(expectedError);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/DeviceAuthorizationRequestValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class DeviceAuthorizationRequestValidation
    {
        private const string Category = "Device authorization request validation";

        private readonly NameValueCollection testParameters = new NameValueCollection { { "scope", "resource" } };
        private readonly Client testClient = new Client
        {
            ClientId = "device_flow",
            AllowedGrantTypes = GrantTypes.DeviceFlow,
            AllowedScopes = {"openid", "profile", "resource"},
            AllowOfflineAccess = true
        };
        
        [Fact]
        [Trait("Category", Category)]
        public void Null_Parameter()
        {
            var validator = Factory.CreateDeviceAuthorizationRequestValidator();

            Func act = () => validator.ValidateAsync(null, null);

            act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Protocol_Client()
        {
            testClient.ProtocolType = IdentityServerConstants.ProtocolTypes.WsFederation;

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(testParameters, new ClientSecretValidationResult {Client = testClient});

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Grant_Type()
        {
            testClient.AllowedGrantTypes = GrantTypes.Implicit;

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(testParameters, new ClientSecretValidationResult {Client = testClient});

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unauthorized_Scope()
        {
            var parameters = new NameValueCollection {{"scope", "resource2"}};

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(parameters, new ClientSecretValidationResult {Client = testClient});

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Scope()
        {
            var parameters = new NameValueCollection {{"scope", Guid.NewGuid().ToString()}};

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(parameters, new ClientSecretValidationResult {Client = testClient});

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_OpenId_Request()
        {
            var parameters = new NameValueCollection {{"scope", "openid"}};

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(parameters, new ClientSecretValidationResult {Client = testClient});

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.IsOpenIdRequest.Should().BeTrue();
            result.ValidatedRequest.RequestedScopes.Should().Contain("openid");

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Should().Contain(x => x.Name == "openid");
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Should().BeEmpty();
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeFalse();

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Any().Should().BeFalse();
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Resource_Request()
        {
            var parameters = new NameValueCollection { { "scope", "resource" } };

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(parameters, new ClientSecretValidationResult { Client = testClient });

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.IsOpenIdRequest.Should().BeFalse();
            result.ValidatedRequest.RequestedScopes.Should().Contain("resource");

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Should().BeEmpty();
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Should().Contain(x => x.Name == "api");
            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Should().Contain(x => x.Name == "resource");
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeFalse();

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Any().Should().BeFalse();
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Mixed_Request()
        {
            var parameters = new NameValueCollection { { "scope", "openid resource offline_access" } };

            var validator = Factory.CreateDeviceAuthorizationRequestValidator();
            var result = await validator.ValidateAsync(parameters, new ClientSecretValidationResult { Client = testClient });

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.IsOpenIdRequest.Should().BeTrue();
            result.ValidatedRequest.RequestedScopes.Should().Contain("openid");
            result.ValidatedRequest.RequestedScopes.Should().Contain("resource");
            result.ValidatedRequest.RequestedScopes.Should().Contain("offline_access");

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Should().Contain(x => x.Name == "openid");
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Should().Contain(x => x.Name == "api");
            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Should().Contain(x => x.Name == "resource");
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeTrue();

            result.ValidatedRequest.ValidatedResources.Resources.IdentityResources.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Any().Should().BeTrue();
            result.ValidatedRequest.ValidatedResources.Resources.OfflineAccess.Should().BeTrue();
        }


        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_Scopes_Expect_Client_Scopes()
        {
            var validator = Factory.CreateDeviceAuthorizationRequestValidator();

            var result = await validator.ValidateAsync(
                new NameValueCollection(),
                new ClientSecretValidationResult { Client = testClient });

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.RequestedScopes.Should().Contain(testClient.AllowedScopes);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_Scopes_And_Client_Scopes_Empty()
        {
            testClient.AllowedScopes.Clear();
            var validator = Factory.CreateDeviceAuthorizationRequestValidator();

            var result = await validator.ValidateAsync(
                new NameValueCollection(),
                new ClientSecretValidationResult { Client = testClient });

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.AuthorizeErrors.InvalidScope);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/DeviceCodeValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class DeviceCodeValidation
    {
        private const string Category = "Device code validation";

        private readonly IClientStore _clients = Factory.CreateClientStore();

        private readonly DeviceCode deviceCode = new DeviceCode
        {
            ClientId = "device_flow",
            IsAuthorized = true,
            Subject = new IdentityServerUser("bob").CreatePrincipal(),
            IsOpenId = true,
            Lifetime = 300,
            CreationTime = DateTime.UtcNow,
            AuthorizedScopes = new[] { "openid", "profile", "resource" }
        };

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_Missing()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = null, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_From_Different_Client()
        {
            var badActor = await _clients.FindClientByIdAsync("codeclient");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(badActor);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Expired_DeviceCode()
        {
            deviceCode.CreationTime = DateTime.UtcNow.AddDays(-10);
            deviceCode.Lifetime = 300;

            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.ExpiredToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Access_Denied()
        {
            deviceCode.AuthorizedScopes = new List();

            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.AccessDenied);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_Not_Yet_Authorized()
        {
            deviceCode.IsAuthorized = false;

            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.AuthorizationPending);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_Missing_Subject()
        {
            deviceCode.Subject = null;

            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.AuthorizationPending);
        }


        [Fact]
        [Trait("Category", Category)]
        public async Task User_Disabled()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service, new TestProfileService(false));

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_Polling_Too_Fast()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service, throttlingService: new TestDeviceFlowThrottlingService(true));

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext { DeviceCode = handle, Request = request };

            await validator.ValidateAsync(context);

            context.Result.IsError.Should().BeTrue();
            context.Result.Error.Should().Be(OidcConstants.TokenErrors.SlowDown);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_DeviceCode()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");
            var service = Factory.CreateDeviceCodeService();

            var handle = await service.StoreDeviceAuthorizationAsync(Guid.NewGuid().ToString(), deviceCode);

            var validator = Factory.CreateDeviceCodeValidator(service);

            var request = new ValidatedTokenRequest();
            request.SetClient(client);

            var context = new DeviceCodeValidationContext {DeviceCode = handle, Request = request};

            await validator.ValidateAsync(context);
            
            context.Result.IsError.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/EndSessionRequestValidation/EndSessionRequestValidatorTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation.EndSessionRequestValidation
{
    public class EndSessionRequestValidatorTests
    {
        private EndSessionRequestValidator _subject;
        private IdentityServerOptions _options;
        private StubTokenValidator _stubTokenValidator = new StubTokenValidator();
        private StubRedirectUriValidator _stubRedirectUriValidator = new StubRedirectUriValidator();
        private MockHttpContextAccessor _context = new MockHttpContextAccessor();
        private MockUserSession _userSession = new MockUserSession();
        private MockLogoutNotificationService _mockLogoutNotificationService = new MockLogoutNotificationService();
        private MockMessageStore _mockEndSessionMessageStore = new MockMessageStore();

        private ClaimsPrincipal _user;

        public EndSessionRequestValidatorTests()
        {
            _user = new IdentityServerUser("alice").CreatePrincipal();

            _options = TestIdentityServerOptions.Create();
            _subject = new EndSessionRequestValidator(
                _context,
                _options,
                _stubTokenValidator,
                _stubRedirectUriValidator,
                _userSession,
                _mockLogoutNotificationService,
                _mockEndSessionMessageStore,
                TestLogger.Create());
        }

        [Fact]
        public async Task anonymous_user_when_options_require_authenticated_user_should_return_error()
        {
            _options.Authentication.RequireAuthenticatedUserForSignOutMessage = true;

            var parameters = new NameValueCollection();
            var result = await _subject.ValidateAsync(parameters, null);
            result.IsError.Should().BeTrue();

            result = await _subject.ValidateAsync(parameters, new ClaimsPrincipal());
            result.IsError.Should().BeTrue();

            result = await _subject.ValidateAsync(parameters, new ClaimsPrincipal(new ClaimsIdentity()));
            result.IsError.Should().BeTrue();
        }

        [Fact]
        public async Task valid_params_should_return_success()
        {
            _stubTokenValidator.IdentityTokenValidationResult = new TokenValidationResult()
            {
                IsError = false,
                Claims = new Claim[] { new Claim("sub", _user.GetSubjectId()) },
                Client = new Client() { ClientId = "client"}
            };
            _stubRedirectUriValidator.IsPostLogoutRedirectUriValid = true;

            var parameters = new NameValueCollection();
            parameters.Add("id_token_hint", "id_token");
            parameters.Add("post_logout_redirect_uri", "http://client/signout-cb");
            parameters.Add("client_id", "client1");
            parameters.Add("state", "foo");

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeFalse();

            result.ValidatedRequest.Client.ClientId.Should().Be("client");
            result.ValidatedRequest.PostLogOutUri.Should().Be("http://client/signout-cb");
            result.ValidatedRequest.State.Should().Be("foo");
            result.ValidatedRequest.Subject.GetSubjectId().Should().Be(_user.GetSubjectId());
        }

        [Fact]
        public async Task no_post_logout_redirect_uri_should_not_use_single_registered_uri()
        {
            _stubTokenValidator.IdentityTokenValidationResult = new TokenValidationResult()
            {
                IsError = false,
                Claims = new Claim[] { new Claim("sub", _user.GetSubjectId()) },
                Client = new Client() { ClientId = "client1", PostLogoutRedirectUris = new List { "foo" } }
            };
            _stubRedirectUriValidator.IsPostLogoutRedirectUriValid = true;

            var parameters = new NameValueCollection();
            parameters.Add("id_token_hint", "id_token");

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeFalse();
            result.ValidatedRequest.PostLogOutUri.Should().BeNull();
        }

        [Fact]
        public async Task no_post_logout_redirect_uri_should_not_use_multiple_registered_uri()
        {
            _stubTokenValidator.IdentityTokenValidationResult = new TokenValidationResult()
            {
                IsError = false,
                Claims = new Claim[] { new Claim("sub", _user.GetSubjectId()) },
                Client = new Client() { ClientId = "client1", PostLogoutRedirectUris = new List { "foo", "bar" } }
            };
            _stubRedirectUriValidator.IsPostLogoutRedirectUriValid = true;

            var parameters = new NameValueCollection();
            parameters.Add("id_token_hint", "id_token");

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeFalse();
            result.ValidatedRequest.PostLogOutUri.Should().BeNull();
        }

        [Fact]
        public async Task post_logout_uri_fails_validation_should_not_honor_logout_uri()
        {
            _stubTokenValidator.IdentityTokenValidationResult = new TokenValidationResult()
            {
                IsError = false,
                Claims = new Claim[] { new Claim("sub", _user.GetSubjectId()) },
                Client = new Client() { ClientId = "client" }
            };
            _stubRedirectUriValidator.IsPostLogoutRedirectUriValid = false;

            var parameters = new NameValueCollection();
            parameters.Add("id_token_hint", "id_token");
            parameters.Add("post_logout_redirect_uri", "http://client/signout-cb");
            parameters.Add("client_id", "client1");
            parameters.Add("state", "foo");

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeFalse();

            result.ValidatedRequest.Client.ClientId.Should().Be("client");
            result.ValidatedRequest.Subject.GetSubjectId().Should().Be(_user.GetSubjectId());
            
            result.ValidatedRequest.State.Should().BeNull();
            result.ValidatedRequest.PostLogOutUri.Should().BeNull();
        }

        [Fact]
        public async Task subject_mismatch_should_return_error()
        {
            _stubTokenValidator.IdentityTokenValidationResult = new TokenValidationResult()
            {
                IsError = false,
                Claims = new Claim[] { new Claim("sub", "xoxo") },
                Client = new Client() { ClientId = "client" }
            };
            _stubRedirectUriValidator.IsPostLogoutRedirectUriValid = true;

            var parameters = new NameValueCollection();
            parameters.Add("id_token_hint", "id_token");
            parameters.Add("post_logout_redirect_uri", "http://client/signout-cb");
            parameters.Add("client_id", "client1");
            parameters.Add("state", "foo");

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeTrue();
        }

        [Fact]
        public async Task successful_request_should_return_inputs()
        {
            var parameters = new NameValueCollection();

            var result = await _subject.ValidateAsync(parameters, _user);
            result.IsError.Should().BeFalse();
            result.ValidatedRequest.Raw.Should().BeSameAs(parameters);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/EndSessionRequestValidation/StubRedirectUriValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.EndSessionRequestValidation
{
    public class StubRedirectUriValidator : IRedirectUriValidator
    {
        public bool IsRedirectUriValid { get; set; }
        public bool IsPostLogoutRedirectUriValid { get; set; }

        public Task IsPostLogoutRedirectUriValidAsync(string requestedUri, Client client)
        {
            return Task.FromResult(IsPostLogoutRedirectUriValid);
        }

        public Task IsRedirectUriValidAsync(string requestedUri, Client client)
        {
            return Task.FromResult(IsRedirectUriValid);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/EndSessionRequestValidation/StubTokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.EndSessionRequestValidation
{
    public class StubTokenValidator : ITokenValidator
    {
        public TokenValidationResult AccessTokenValidationResult { get; set; } = new TokenValidationResult();
        public TokenValidationResult IdentityTokenValidationResult { get; set; } = new TokenValidationResult();

        public Task ValidateAccessTokenAsync(string token, string expectedScope = null)
        {
            return Task.FromResult(AccessTokenValidationResult);
        }

        public Task ValidateIdentityTokenAsync(string token, string clientId = null, bool validateLifetime = true)
        {
            return Task.FromResult(IdentityTokenValidationResult);
        }

        public Task ValidateRefreshTokenAsync(string token, Client client)
        {
            throw new System.NotImplementedException();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/GrantTypesValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using FluentAssertions;
using IdentityServer8.Models;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class GrantTypesValidation
    {
        private const string Category = "Grant Types Validation";

        [Fact]
        [Trait("Category", Category)]
        public void empty_should_be_allowed()
        {
            var client = new Client();
            client.AllowedGrantTypes = new List();
        }

        [Fact]
        [Trait("Category", Category)]
        public void implicit_should_be_allowed()
        {
            var client = new Client();
            client.AllowedGrantTypes = GrantTypes.Implicit;
        }

        [Fact]
        [Trait("Category", Category)]
        public void custom_should_be_allowed()
        {
            var client = new Client();
            client.AllowedGrantTypes = new[] { "custom" };
        }

        [Fact]
        [Trait("Category", Category)]
        public void custom_should_be_allowed_raw()
        {
            var client = new Client();
            client.AllowedGrantTypes = new[] { "custom" };
        }
        
        [Theory]
        [Trait("Category", Category)]
        [InlineData(GrantType.Implicit, GrantType.Hybrid)]
        [InlineData(GrantType.Implicit, GrantType.AuthorizationCode)]
        [InlineData(GrantType.AuthorizationCode, GrantType.Hybrid)]
        public void forbidden_grant_type_combinations_should_throw(string type1, string type2)
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = new[] { type1, type2 };

            act.Should().Throw();            
        }

        [Theory]
        [Trait("Category", Category)]
        [InlineData(GrantType.Implicit, GrantType.Hybrid)]
        [InlineData(GrantType.Implicit, GrantType.AuthorizationCode)]
        [InlineData(GrantType.AuthorizationCode, GrantType.Hybrid)]
        public void custom_and_forbidden_grant_type_combinations_should_throw(string type1, string type2)
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = new[] { "custom1", type2, "custom2", type1 };

            act.Should().Throw();
        }

        [Fact]
        public void duplicate_values_should_throw()
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = new[] { "custom1", "custom2", "custom1" };

            act.Should().Throw();
        }

        [Fact]
        public void null_grant_type_list_should_throw_single()
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = null;

            act.Should().Throw();
        }

        [Fact]
        public void grant_type_with_space_should_throw_single()
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = new[] { "custo m2" };

            act.Should().Throw();
        }

        [Fact]
        public void grant_type_with_space_should_throw_multiple()
        {
            var client = new Client();

            Action act = () => client.AllowedGrantTypes = new[] { "custom1", "custo m2", "custom1" };

            act.Should().Throw();
        }

        [Fact]
        public void adding_invalid_value_to_collection_should_throw()
        {
            var client = new Client()
            {
                AllowedGrantTypes = { "implicit" }
            };

            Action act = () => client.AllowedGrantTypes.Add("authorization_code");

            act.Should().Throw();
        }

        [Fact]
        public void adding_valid_value_to_collection_should_succeed()
        {
            var client = new Client()
            {
                AllowedGrantTypes = { "implicit" }
            };

            client.AllowedGrantTypes.Add("custom");

            client.AllowedGrantTypes.Count.Should().Be(2);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/IdentityTokenValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IdentityModel.Tokens.Jwt;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class IdentityTokenValidation
    {
        private const string Category = "Identity token validation";

        static IdentityTokenValidation()
        {
            JwtSecurityTokenHandler.DefaultInboundClaimTypeMap.Clear();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_IdentityToken_DefaultKeyType()
        {
            var creator = Factory.CreateDefaultTokenCreator();
            var token = TokenFactory.CreateIdentityToken("roclient", "valid");
            var jwt = await creator.CreateTokenAsync(token);

            var validator = Factory.CreateTokenValidator();
            var result = await validator.ValidateIdentityTokenAsync(jwt, "roclient");

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_IdentityToken_DefaultKeyType_no_ClientId_supplied()
        {
            var creator = Factory.CreateDefaultTokenCreator();
            var jwt = await creator.CreateTokenAsync(TokenFactory.CreateIdentityToken("roclient", "valid"));
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateIdentityTokenAsync(jwt, "roclient");
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_IdentityToken_no_ClientId_supplied()
        {
            var creator = Factory.CreateDefaultTokenCreator();
            var jwt = await creator.CreateTokenAsync(TokenFactory.CreateIdentityToken("roclient", "valid"));
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateIdentityTokenAsync(jwt);
            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IdentityToken_InvalidClientId()
        {
            var creator = Factory.CreateDefaultTokenCreator();
            var jwt = await creator.CreateTokenAsync(TokenFactory.CreateIdentityToken("roclient", "valid"));
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateIdentityTokenAsync(jwt, "invalid");
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task IdentityToken_Too_Long()
        {
            var creator = Factory.CreateDefaultTokenCreator();
            var jwt = await creator.CreateTokenAsync(TokenFactory.CreateIdentityTokenLong("roclient", "valid", 1000));
            var validator = Factory.CreateTokenValidator();

            var result = await validator.ValidateIdentityTokenAsync(jwt, "roclient");
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/IntrospectionRequestValidatorTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class IntrospectionRequestValidatorTests
    {
        private const string Category = "Introspection request validation";

        private IntrospectionRequestValidator _subject;
        private IReferenceTokenStore _referenceTokenStore;

        public IntrospectionRequestValidatorTests()
        {
            _referenceTokenStore = Factory.CreateReferenceTokenStore();
            var tokenValidator = Factory.CreateTokenValidator(_referenceTokenStore);

            _subject = new IntrospectionRequestValidator(tokenValidator, TestLogger.Create());
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task valid_token_should_successfully_validate()
        {
            var token = new Token {
                CreationTime = DateTime.UtcNow,
                Issuer = "http://op",
                ClientId = "codeclient",
                Lifetime = 1000,
                Claims =
                {
                    new System.Security.Claims.Claim("scope", "a"),
                    new System.Security.Claims.Claim("scope", "b")
                }
            };
            var handle = await _referenceTokenStore.StoreReferenceTokenAsync(token);
            
            var param = new NameValueCollection()
            {
                { "token", handle}
            };

            var result = await _subject.ValidateAsync(param, null);

            result.IsError.Should().Be(false);
            result.IsActive.Should().Be(true);
            result.Claims.Count().Should().Be(5);
            result.Token.Should().Be(handle);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task missing_token_should_error()
        {
            var param = new NameValueCollection();
            
            var result = await _subject.ValidateAsync(param, null);

            result.IsError.Should().Be(true);
            result.Error.Should().Be("missing_token");
            result.IsActive.Should().Be(false);
            result.Claims.Should().BeNull();
            result.Token.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task invalid_token_should_return_inactive()
        {
            var param = new NameValueCollection()
            {
                { "token", "invalid" }
            };

            var result = await _subject.ValidateAsync(param, null);

            result.IsError.Should().Be(false);
            result.IsActive.Should().Be(false);
            result.Claims.Should().BeNull();
            result.Token.Should().Be("invalid");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/ResourceValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Extensions;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class ResourceValidation
    {
        private const string Category = "Resource Validation";

        private List _identityResources = new List
        {
            new IdentityResource
            {
                Name = "openid",
                Required = true
            },
            new IdentityResource
            {
                Name = "email"
            }
        };

        private List _apiResources = new List
        {
            new ApiResource
            {
                Name = "api",
                Scopes = { "resource1", "resource2" }
            },
            new ApiResource
            {
                Name = "disabled_api",
                Enabled = false,
                Scopes = { "disabled" }
            }
        };

        private List _scopes = new List {
            new ApiScope
            {
                Name = "resource1",
                Required = true
            },
            new ApiScope
            {
                Name = "resource2"
            }
        };

        private Client _restrictedClient = new Client
        {
            ClientId = "restricted",

            AllowedScopes = new List
                {
                    "openid",
                    "resource1",
                    "disabled"
                }
        };

        private IResourceStore _store;

        public ResourceValidation()
        {
            _store = new InMemoryResourcesStore(_identityResources, _apiResources, _scopes);
        }

        [Fact]
        [Trait("Category", Category)]
        public void Parse_Scopes_with_Empty_Scope_List()
        {
            var scopes = string.Empty.ParseScopesString();

            scopes.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public void Parse_Scopes_with_Sorting()
        {
            var scopes = "scope3 scope2 scope1".ParseScopesString();

            scopes.Count.Should().Be(3);

            scopes[0].Should().Be("scope1");
            scopes[1].Should().Be("scope2");
            scopes[2].Should().Be("scope3");
        }

        [Fact]
        [Trait("Category", Category)]
        public void Parse_Scopes_with_Extra_Spaces()
        {
            var scopes = "   scope3     scope2     scope1   ".ParseScopesString();

            scopes.Count.Should().Be(3);

            scopes[0].Should().Be("scope1");
            scopes[1].Should().Be("scope2");
            scopes[2].Should().Be("scope3");
        }

        [Fact]
        [Trait("Category", Category)]
        public void Parse_Scopes_with_Duplicate_Scope()
        {
            var scopes = "scope2 scope1 scope2".ParseScopesString();

            scopes.Count.Should().Be(2);

            scopes[0].Should().Be("scope1");
            scopes[1].Should().Be("scope2");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Only_Offline_Access_Requested()
        {
            var scopes = "offline_access".ParseScopesString();


            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeFalse();
            result.InvalidScopes.Should().Contain("offline_access");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task All_Scopes_Valid()
        {
            var scopes = "openid resource1".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeTrue();
            result.InvalidScopes.Should().BeEmpty();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Scope()
        {
            {
                var scopes = "openid email resource1 unknown".ParseScopesString();

                var validator = Factory.CreateResourceValidator(_store);
                var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
                {
                    Client = _restrictedClient,
                    Scopes = scopes
                });

                result.Succeeded.Should().BeFalse();
                result.InvalidScopes.Should().Contain("unknown");
                result.InvalidScopes.Should().Contain("email");
            }
            {
                var scopes = "openid resource1 resource2".ParseScopesString();

                var validator = Factory.CreateResourceValidator(_store);
                var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
                {
                    Client = _restrictedClient,
                    Scopes = scopes
                });

                result.Succeeded.Should().BeFalse();
                result.InvalidScopes.Should().Contain("resource2");
            }
            {
                var scopes = "openid email resource1".ParseScopesString();

                var validator = Factory.CreateResourceValidator(_store);
                var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
                {
                    Client = _restrictedClient,
                    Scopes = scopes
                });

                result.Succeeded.Should().BeFalse();
                result.InvalidScopes.Should().Contain("email");
            }
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Disabled_Scope()
        {
            var scopes = "openid resource1 disabled".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeFalse();
            result.InvalidScopes.Should().Contain("disabled");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task All_Scopes_Allowed_For_Restricted_Client()
        {
            var scopes = "openid resource1".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeTrue();
            result.InvalidScopes.Should().BeEmpty();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Scopes()
        {
            var scopes = "openid email resource1 resource2".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeFalse();
            result.InvalidScopes.Should().Contain("email");
            result.InvalidScopes.Should().Contain("resource2");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Contains_Resource_and_Identity_Scopes()
        {
            var scopes = "openid resource1".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeTrue();
            result.Resources.IdentityResources.SelectMany(x => x.Name).Should().Contain("openid");
            result.Resources.ApiScopes.Select(x => x.Name).Should().Contain("resource1");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Contains_Resource_Scopes_Only()
        {
            var scopes = "resource1".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeTrue();
            result.Resources.IdentityResources.Should().BeEmpty();
            result.Resources.ApiScopes.Select(x => x.Name).Should().Contain("resource1");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Contains_Identity_Scopes_Only()
        {
            var scopes = "openid".ParseScopesString();

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = _restrictedClient,
                Scopes = scopes
            });

            result.Succeeded.Should().BeTrue();
            result.Resources.IdentityResources.SelectMany(x => x.Name).Should().Contain("openid");
            result.Resources.ApiResources.Should().BeEmpty();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Scope_matches_multipls_apis_should_succeed()
        {
            _apiResources.Clear();
            _apiResources.Add(new ApiResource { Name = "api1", Scopes = { "resource" } });
            _apiResources.Add(new ApiResource { Name = "api2", Scopes = { "resource" } });
            _scopes.Clear();
            _scopes.Add(new ApiScope("resource"));

            var validator = Factory.CreateResourceValidator(_store);
            var result = await validator.ValidateRequestedResourcesAsync(new IdentityServer8.Validation.ResourceValidationRequest
            {
                Client = new Client { AllowedScopes = { "resource" } },
                Scopes = new[] { "resource" }
            });

            result.Succeeded.Should().BeTrue();
            result.Resources.ApiResources.Count.Should().Be(2);
            result.Resources.ApiResources.Select(x => x.Name).Should().BeEquivalentTo(new[] { "api1", "api2" });
            result.RawScopeValues.Count().Should().Be(1);
            result.RawScopeValues.Should().BeEquivalentTo(new[] { "resource" });
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/ResponseTypeEqualityComparison.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    /// 
    /// Tests for ResponseTypeEqualityComparer
    /// 
    /// 
    /// Some of these are pretty fundamental equality checks, but the purpose here is to ensure the
    /// important property: that the order is insignificant when multiple values are
    /// sent in a space-delimited string.  We want to ensure that property holds and at the same time
    /// the basic equality function works as well.
    /// 
    public class ResponseTypeEqualityComparison
    {
        /// 
        /// These tests ensure that single-value strings compare with the
        /// same behavior as default string comparisons.
        /// 
        public class SingleValueStringComparisons
        {
            [Fact]
            public void Both_null()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = null;
                string y = null;
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }

            [Fact]
            public void Left_null_other_not()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = null;
                string y = string.Empty;
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }

            [Fact]
            public void Right_null_other_not()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = string.Empty;
                string y = null;
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }

            [Fact]
            public void token_token()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "token";
                string y = "token";
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }

            [Fact]
            public void id_token_id_token()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "id_token";
                string y = "id_token";
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }

            [Fact]
            public void id_token_token()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "id_token";
                string y = "token";
                var result = comparer.Equals(x, y);
                var expected = (x == y);
                result.Should().Be(expected);
            }
        }

        /// 
        /// These tests ensure the property demanded by the 
        /// OAuth2 spec
        /// where, in a space-delimited list of values, the order is not important.
        /// 
        public class MultipleValueStringComparisons
        {
            [Fact]
            public void id_token_token_both_ways()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "id_token token";
                string y = "token id_token";
                var result = comparer.Equals(x, y);
                result.Should().BeTrue();
            }

            [Fact]
            public void code_id_token_both_ways()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token";
                string y = "id_token code";
                var result = comparer.Equals(x, y);
                result.Should().BeTrue();
            }

            [Fact]
            public void code_token_both_ways()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code token";
                string y = "token code";
                var result = comparer.Equals(x, y);
                result.Should().BeTrue();
            }

            [Fact]
            public void code_id_token_token_combo1()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token token";
                string y = "id_token code token";
                var result = comparer.Equals(x, y);
                result.Should().BeTrue();
            }

            [Fact]
            public void code_id_token_token_combo2()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token token";
                string y = "token id_token code";
                var result = comparer.Equals(x, y);
                result.Should().BeTrue();
            }

            [Fact]
            public void code_id_token_token_missing_code()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token token";
                string y = "id_token token";
                var result = comparer.Equals(x, y);
                result.Should().BeFalse();
            }

            [Fact]
            public void code_id_token_token_missing_code_and_token()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token token";
                string y = "id_token";
                var result = comparer.Equals(x, y);
                result.Should().BeFalse();
            }

            [Fact]
            public void Totally_different_words()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "blerg smoo";
                string y = "token code";
                var result = comparer.Equals(x, y);
                result.Should().BeFalse();
            }

            [Fact]
            public void Same_length_different_count()
            {
                ResponseTypeEqualityComparer comparer = new ResponseTypeEqualityComparer();
                string x = "code id_token token";
                string y = "tokenizer bleegerfi";
                var result = comparer.Equals(x, y);
                result.Should().BeFalse();
            }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/RevocationRequestValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class RevocationRequestValidation
    {
        private const string Category = "Revocation Request Validation Tests";

        private ITokenRevocationRequestValidator _validator;
        private Client _client;

        public RevocationRequestValidation()
        {
            _validator = new TokenRevocationRequestValidator(TestLogger.Create());
            _client = new Client
            {
                ClientName = "Code Client",
                Enabled = true,
                ClientId = "codeclient",
                ClientSecrets = new List
                {
                    new Secret("secret".Sha256())
                },

                AllowedGrantTypes = GrantTypes.Code,

                RequireConsent = false,

                RedirectUris = new List
                {
                    "https://server/cb"
                },

                AuthorizationCodeLifetime = 60
            };
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Empty_Parameters()
        {
            var parameters = new NameValueCollection();

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_Token_Valid_Hint()
        {
            var parameters = new NameValueCollection
            {
                { "token_type_hint", "access_token" }
            };

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidRequest);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Token_And_AccessTokenHint()
        {
            var parameters = new NameValueCollection
            {
                { "token", "foo" },
                { "token_type_hint", "access_token" }
            };

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeFalse();
            result.Token.Should().Be("foo");
            result.TokenTypeHint.Should().Be("access_token");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Token_and_RefreshTokenHint()
        {
            var parameters = new NameValueCollection
            {
                { "token", "foo" },
                { "token_type_hint", "refresh_token" }
            };

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeFalse();
            result.Token.Should().Be("foo");
            result.TokenTypeHint.Should().Be("refresh_token");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Token_And_Missing_Hint()
        {
            var parameters = new NameValueCollection
            {
                { "token", "foo" }
            };

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeFalse();
            result.Token.Should().Be("foo");
            result.TokenTypeHint.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Token_And_Invalid_Hint()
        {
            var parameters = new NameValueCollection
            {
                { "token", "foo" },
                { "token_type_hint", "invalid" }
            };

            var result = await _validator.ValidateRequestAsync(parameters, _client);

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(Constants.RevocationErrors.UnsupportedTokenType);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/BasicAuthenticationCredentialParsing.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Text;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Primitives;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class BasicAuthenticationSecretParsing
    {
        private const string Category = "Secrets - Basic Authentication Secret Parsing";

        private IdentityServerOptions _options;
        private BasicAuthenticationSecretParser _parser;

        public BasicAuthenticationSecretParsing()
        {
            _options = new IdentityServerOptions();
            _parser = new BasicAuthenticationSecretParser(_options, TestLogger.Create());
        }

        [Fact]
        [Trait("Category", Category)]
        public async void EmptyContext()
        {
            var context = new DefaultHttpContext();

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Valid_BasicAuthentication_Request()
        {
            var context = new DefaultHttpContext();

            var headerValue = string.Format("Basic {0}",
                Convert.ToBase64String(Encoding.UTF8.GetBytes("client:secret")));
            context.Request.Headers.Append("Authorization", new StringValues(headerValue));


            var secret = await _parser.ParseAsync(context);

            secret.Type.Should().Be(IdentityServerConstants.ParsedSecretTypes.SharedSecret);
            secret.Id.Should().Be("client");
            secret.Credential.Should().Be("secret");
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Valid_BasicAuthentication_Request_With_UserName_Only_And_Colon_For_Optional_ClientSecret()
        {
            var context = new DefaultHttpContext();

            var headerValue = string.Format("Basic {0}",
                Convert.ToBase64String(Encoding.UTF8.GetBytes("client:")));
            context.Request.Headers.Append("Authorization", new StringValues(headerValue));

            var secret = await _parser.ParseAsync(context);

            secret.Type.Should().Be(IdentityServerConstants.ParsedSecretTypes.NoSecret);
            secret.Id.Should().Be("client");
            secret.Credential.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void BasicAuthentication_Request_With_Empty_Basic_Header()
        {
            var context = new DefaultHttpContext();

            context.Request.Headers.Append("Authorization", new StringValues(string.Empty));

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Valid_BasicAuthentication_Request_ClientId_Too_Long()
        {
            var context = new DefaultHttpContext();

            var longClientId = "x".Repeat(_options.InputLengthRestrictions.ClientId + 1);
            var credential = string.Format("{0}:secret", longClientId);

            var headerValue = string.Format("Basic {0}",
                Convert.ToBase64String(Encoding.UTF8.GetBytes(credential)));
            context.Request.Headers.Append("Authorization", new StringValues(headerValue));

            var secret = await _parser.ParseAsync(context);
            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Valid_BasicAuthentication_Request_ClientSecret_Too_Long()
        {
            var context = new DefaultHttpContext();

            var longClientSecret = "x".Repeat(_options.InputLengthRestrictions.ClientSecret + 1);
            var credential = string.Format("client:{0}", longClientSecret);

            var headerValue = string.Format("Basic {0}",
                Convert.ToBase64String(Encoding.UTF8.GetBytes(credential)));
            context.Request.Headers.Append("Authorization", new StringValues(headerValue));

            var secret = await _parser.ParseAsync(context);
            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void BasicAuthentication_Request_With_Empty_Basic_Header_Variation()
        {
            var context = new DefaultHttpContext();

            context.Request.Headers.Append("Authorization", new StringValues("Basic "));

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void BasicAuthentication_Request_With_Unknown_Scheme()
        {
            var context = new DefaultHttpContext();

            context.Request.Headers.Append("Authorization", new StringValues("Unknown"));

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void BasicAuthentication_Request_With_Malformed_Credentials_NoBase64_Encoding()
        {
            var context = new DefaultHttpContext();

            context.Request.Headers.Append("Authorization", new StringValues("Basic somerandomdata"));

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void BasicAuthentication_Request_With_Malformed_Credentials_Base64_Encoding_UserName_Only()
        {
            var context = new DefaultHttpContext();

            var headerValue = string.Format("Basic {0}",
                Convert.ToBase64String(Encoding.UTF8.GetBytes("client")));
            context.Request.Headers.Append("Authorization", new StringValues(headerValue));

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/ClientAssertionSecretParsing.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IdentityModel.Tokens.Jwt;
using System.IO;
using System.Security.Claims;
using System.Text;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class ClientAssertionSecretParsing
    {
        private IdentityServerOptions _options;
        private JwtBearerClientAssertionSecretParser _parser;

        public ClientAssertionSecretParsing()
        {
            _options = new IdentityServerOptions();
            _parser = new JwtBearerClientAssertionSecretParser(_options, new LoggerFactory().CreateLogger());
        }

        [Fact]
        public async void EmptyContext()
        {
            var context = new DefaultHttpContext();
            context.Request.Body = new MemoryStream();
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        public async void Valid_ClientAssertion()
        {
            var context = new DefaultHttpContext();

            var token = new JwtSecurityToken(issuer: "issuer", claims: new[] { new Claim("sub", "client") });
            var tokenString = new JwtSecurityTokenHandler().WriteToken(token);

            var body = "client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer&client_assertion=" + tokenString;

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().NotBeNull();
            secret.Type.Should().Be(IdentityServerConstants.ParsedSecretTypes.JwtBearer);
            secret.Id.Should().Be("client");
            secret.Credential.Should().Be(tokenString);
        }

        [Fact]
        public async void Missing_ClientAssertionType()
        {
            var context = new DefaultHttpContext();

            var body = "client_id=client&client_assertion=token";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        public async void Missing_ClientAssertion()
        {
            var context = new DefaultHttpContext();

            var body = "client_id=client&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        public async void Malformed_PostBody()
        {
            var context = new DefaultHttpContext();
            var body = "malformed";
            
            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        public async void ClientId_TooLong()
        {
            var context = new DefaultHttpContext();

            var longClientId = "x".Repeat(_options.InputLengthRestrictions.ClientId + 1);
            var body = $"client_id={longClientId}&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer&client_assertion=token";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        public async void ClientAssertion_TooLong()
        {
            var context = new DefaultHttpContext();

            var longToken = "x".Repeat(_options.InputLengthRestrictions.Jwt + 1);
            var body = $"client_id=client&client_assertion_type=urn:ietf:params:oauth:client-assertion-type:jwt-bearer&client_assertion={longToken}";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/ClientSecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Validation.Setup;
using Microsoft.AspNetCore.Http;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class ClientSecretValidation
    {
        private const string Category = "Secrets - Client Secret Validator";

        [Fact]
        [Trait("Category", Category)]
        public async Task confidential_client_with_correct_secret_should_be_able_to_request_token()
        {
            var validator = Factory.CreateClientSecretValidator();

            var context = new DefaultHttpContext();
            var body = "client_id=roclient&client_secret=secret";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var result = await validator.ValidateAsync(context);

            result.IsError.Should().BeFalse();
            result.Client.ClientId.Should().Be("roclient");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task confidential_client_with_incorrect_secret_should_not_be_able_to_request_token()
        {
            var validator = Factory.CreateClientSecretValidator();

            var context = new DefaultHttpContext();
            var body = "client_id=roclient&client_secret=invalid";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var result = await validator.ValidateAsync(context);

            result.IsError.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task public_client_without_secret_should_be_able_to_request_token()
        {
            var validator = Factory.CreateClientSecretValidator();

            var context = new DefaultHttpContext();
            var body = "client_id=roclient.public";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var result = await validator.ValidateAsync(context);

            result.IsError.Should().BeFalse();
            result.Client.ClientId.Should().Be("roclient.public");
            result.Client.RequireClientSecret.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task implicit_client_without_secret_should_be_able_to_authenticate()
        {
            var validator = Factory.CreateClientSecretValidator();

            var context = new DefaultHttpContext();
            var body = "client_id=client.implicit";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var result = await validator.ValidateAsync(context);

            result.IsError.Should().BeFalse();
            result.Client.ClientId.Should().Be("client.implicit");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task implicit_client_and_client_creds_without_secret_should_not_be_able_to_authenticate()
        {
            var validator = Factory.CreateClientSecretValidator();

            var context = new DefaultHttpContext();
            var body = "client_id=implicit_and_client_creds";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var result = await validator.ValidateAsync(context);

            result.IsError.Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/FormPostCredentialParsing.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.IO;
using System.Text;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class FormPostCredentialExtraction
    {
        private const string Category = "Secrets - Form Post Secret Parsing";

        private IdentityServerOptions _options;
        private PostBodySecretParser _parser;

        public FormPostCredentialExtraction()
        {
            _options = new IdentityServerOptions();
            _parser = new PostBodySecretParser(_options, new LoggerFactory().CreateLogger());
        }

        [Fact]
        [Trait("Category", Category)]
        public async void EmptyContext()
        {
            var context = new DefaultHttpContext();
            context.Request.Body = new MemoryStream();

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Valid_PostBody()
        {
            var context = new DefaultHttpContext();

            var body = "client_id=client&client_secret=secret";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Type.Should().Be(IdentityServerConstants.ParsedSecretTypes.SharedSecret);
            secret.Id.Should().Be("client");
            secret.Credential.Should().Be("secret");
        }

        [Fact]
        [Trait("Category", Category)]
        public async void ClientId_Too_Long()
        {
            var context = new DefaultHttpContext();

            var longClientId = "x".Repeat(_options.InputLengthRestrictions.ClientId + 1);
            var body = string.Format("client_id={0}&client_secret=secret", longClientId);

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void ClientSecret_Too_Long()
        {
            var context = new DefaultHttpContext();

            var longClientSecret = "x".Repeat(_options.InputLengthRestrictions.ClientSecret + 1);
            var body = string.Format("client_id=client&client_secret={0}", longClientSecret);

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Missing_ClientId()
        {
            var context = new DefaultHttpContext();

            var body = "client_secret=secret";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Missing_ClientSecret()
        {
            var context = new DefaultHttpContext();

            var body = "client_id=client";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().NotBeNull();
            secret.Type.Should().Be(IdentityServerConstants.ParsedSecretTypes.NoSecret);
        }

        [Fact]
        [Trait("Category", Category)]
        public async void Malformed_PostBody()
        {
            var context = new DefaultHttpContext();

            var body = "malformed";

            context.Request.Body = new MemoryStream(Encoding.UTF8.GetBytes(body));
            context.Request.ContentType = "application/x-www-form-urlencoded";

            var secret = await _parser.ParseAsync(context);

            secret.Should().BeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/HashedSharedSecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class HashedSharedSecretValidation
    {
        private const string Category = "Secrets - Hashed Shared Secret Validation";

        private ISecretValidator _validator = new HashedSharedSecretValidator(new Logger(new LoggerFactory()));
        private IClientStore _clients = new InMemoryClientStore(ClientValidationTestClients.Get());

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Single_Secret()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Credential_Type()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = "invalid"
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Multiple_Secrets()
        {
            var clientId = "multiple_secrets_hashed";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "foobar";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "quux";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "notexpired";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Single_Secret()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Multiple_Secrets()
        {
            var clientId = "multiple_secrets_hashed";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_with_no_Secret_Should_Fail()
        {
            var clientId = "no_secret_client";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_with_null_Secret_Should_Fail()
        {
            var clientId = "null_secret_client";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret,
                Credential = "secret"
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/MutualTlsSecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class MutualTlsSecretValidation
    {
        private const string Category = "Secrets - MutualTls Secret Validation";

        private IClientStore _clients = new InMemoryClientStore(ClientValidationTestClients.Get());

        ///////////////////
        // thumbprints
        ///////////////////

        [Fact]
        [Trait("Category", Category)]
        public async Task Thumbprint_invalid_secret_type_should_not_match()
        {
            ISecretValidator validator = new X509ThumbprintSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Thumbprint_missing_cert_should_throw()
        {
            ISecretValidator validator = new X509ThumbprintSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            Func act = async () => await validator.ValidateAsync(client.ClientSecrets, secret);
            await act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Thumbprint_invalid_secret_should_not_match()
        {
            ISecretValidator validator = new X509ThumbprintSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = TestCert.Load(),
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Thumbprint_valid_secret_should_match()
        {
            ISecretValidator validator = new X509ThumbprintSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = TestCert.Load(),
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }

        ///////////////////
        // names
        ///////////////////

        [Fact]
        [Trait("Category", Category)]
        public async Task Name_invalid_secret_type_should_not_match()
        {
            ISecretValidator validator = new X509NameSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Name_missing_cert_should_throw()
        {
            ISecretValidator validator = new X509NameSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            Func act = async () => await validator.ValidateAsync(client.ClientSecrets, secret);
            await act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Name_invalid_secret_should_not_match()
        {
            ISecretValidator validator = new X509NameSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = TestCert.Load(),
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Name_valid_secret_should_match()
        {
            ISecretValidator validator = new X509NameSecretValidator(new Logger(new LoggerFactory()));

            var clientId = "mtls_client_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = TestCert.Load(),
                Type = IdentityServerConstants.ParsedSecretTypes.X509Certificate
            };

            var result = await validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/PlainTextClientSecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class PlainTextClientSecretValidation
    {
        private const string Category = "Secrets - PlainText Shared Secret Validation";

        private ISecretValidator _validator = new PlainTextSharedSecretValidator(new Logger(new LoggerFactory()));
        private IClientStore _clients = new InMemoryClientStore(ClientValidationTestClients.Get());

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Single_Secret()
        {
            var clientId = "single_secret_no_protection_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Credential_Type()
        {
            var clientId = "single_secret_no_protection_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = "invalid"
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Multiple_Secrets_No_Protection()
        {
            var clientId = "multiple_secrets_no_protection";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "foobar";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "quux";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "notexpired";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Single_Secret()
        {
            var clientId = "single_secret_no_protection_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Multiple_Secrets()
        {
            var clientId = "multiple_secrets_no_protection";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_with_no_Secret_Should_Fail()
        {
            var clientId = "no_secret_client";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_with_null_Secret_Should_Fail()
        {
            var clientId = "null_secret_client";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret,
                Credential = "secret"
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/PrivateKeyJwtSecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.IdentityModel.Tokens.Jwt;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Services.Default;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging;
using Microsoft.IdentityModel.Tokens;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class PrivateKeyJwtSecretValidation
    {
        private readonly ISecretValidator _validator;
        private readonly IClientStore _clients;

        public PrivateKeyJwtSecretValidation()
        {
            _validator = new PrivateKeyJwtSecretValidator(
                new MockHttpContextAccessor(
                    new IdentityServerOptions()
                        {
                            IssuerUri = "https://idsrv3.com"
                        }
                    ),
                    new DefaultReplayCache(new TestCache()), 
                    new LoggerFactory().CreateLogger()
                );
            _clients = new InMemoryClientStore(ClientValidationTestClients.Get());
        }

        private JwtSecurityToken CreateToken(string clientId, DateTime? nowOverride = null)
        {
            var certificate = TestCert.Load();
            var now = nowOverride ?? DateTime.UtcNow;

            var token = new JwtSecurityToken(
                    clientId,
                    "https://idsrv3.com/connect/token",
                    new List()
                    {
                        new Claim("jti", Guid.NewGuid().ToString()),
                        new Claim(JwtClaimTypes.Subject, clientId),
                        new Claim(JwtClaimTypes.IssuedAt, new DateTimeOffset(now).ToUnixTimeSeconds().ToString(), ClaimValueTypes.Integer64)
                    },
                    now,
                    now.AddMinutes(1),
                    new SigningCredentials(
                        new X509SecurityKey(certificate),
                        SecurityAlgorithms.RsaSha256
                    )
                );
            return token;
        }

        [Fact]
        public async Task Invalid_Certificate_X5t_Only_Requires_Full_Certificate()
        {
            var clientId = "certificate_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var token = CreateToken(clientId);
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(token),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Certificate_Thumbprint()
        {
            var clientId = "certificate_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(CreateToken(clientId)),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Valid_Certificate_Base64()
        {
            var clientId = "certificate_base64_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(CreateToken(clientId)),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }
        
        [Fact]
        public async Task Invalid_Replay()
        {
            var clientId = "certificate_base64_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var token = new JwtSecurityTokenHandler().WriteToken(CreateToken(clientId));
            
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = token,
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();
            
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Certificate_Base64()
        {
            var clientId = "certificate_base64_invalid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(CreateToken(clientId)),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Issuer()
        {
            var clientId = "certificate_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var token = CreateToken(clientId);
            token.Payload.Remove(JwtClaimTypes.Issuer);
            token.Payload.Add(JwtClaimTypes.Issuer, "invalid");
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(token),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Subject()
        {
            var clientId = "certificate_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var token = CreateToken(clientId);
            token.Payload.Remove(JwtClaimTypes.Subject);
            token.Payload.Add(JwtClaimTypes.Subject, "invalid");
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(token),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Expired_Token()
        {
            var clientId = "certificate_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var token = CreateToken(clientId, DateTime.UtcNow.AddHours(-1));
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(token),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        public async Task Invalid_Unsigned_Token()
        {
            var clientId = "certificate_valid";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var token = CreateToken(clientId);
            token.Header.Remove("alg");
            token.Header.Add("alg", "none");
            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = new JwtSecurityTokenHandler().WriteToken(token),
                Type = IdentityServerConstants.ParsedSecretTypes.JwtBearer
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Secrets/SecretValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Microsoft.Extensions.Logging;
using Xunit;

namespace IdentityServer.UnitTests.Validation.Secrets
{
    public class SecretValidation
    {
        private const string Category = "Secrets - Secret Validator";

        private ISecretValidator _hashedSecretValidator = new HashedSharedSecretValidator(new Logger(new LoggerFactory()));
        private IClientStore _clients = new InMemoryClientStore(ClientValidationTestClients.Get());
        private SecretValidator _validator;
        private IdentityServerOptions _options = new IdentityServerOptions();

        public SecretValidation()
        {
            _validator = new SecretValidator(
                new StubClock(),
                new[] { _hashedSecretValidator }, 
                new Logger(new LoggerFactory()));
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Single_Secret()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Credential_Type()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = "invalid"
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_Multiple_Secrets()
        {
            var clientId = "multiple_secrets_hashed";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "secret",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "foobar";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "quux";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();

            secret.Credential = "notexpired";
            result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Single_Secret()
        {
            var clientId = "single_secret_hashed_no_expiration";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);

            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Expired_Secret()
        {
            var clientId = "multiple_secrets_hashed";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "expired",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Multiple_Secrets()
        {
            var clientId = "multiple_secrets_hashed";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Credential = "invalid",
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };

            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_with_no_Secret_Should_Fail()
        {
            var clientId = "no_secret_client";
            var client = await _clients.FindEnabledClientByIdAsync(clientId);

            var secret = new ParsedSecret
            {
                Id = clientId,
                Type = IdentityServerConstants.ParsedSecretTypes.SharedSecret
            };
            
            var result = await _validator.ValidateAsync(client.ClientSecrets, secret);
            result.Success.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/ClientValidationTestClients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Security.Cryptography.X509Certificates;
using IdentityServer.UnitTests.Common;
using IdentityServer8;
using IdentityServer8.Models;
using static IdentityServer8.IdentityServerConstants;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal static class ClientValidationTestClients
    {
        public static List Get()
        {
            return new List
            {
                new Client
                {
                    ClientName = "Disabled client",
                    ClientId = "disabled_client",
                    Enabled = false,

                    ClientSecrets = new List
                    {
                        new Secret("secret")
                    }
                },

                new Client
                {
                    ClientName = "Client with no secret set",
                    ClientId = "no_secret_client",
                    Enabled = true
                },

                new Client
                {
                    ClientName = "Client with null secret set",
                    ClientId = "null_secret_client",
                    Enabled = true,
                    ClientSecrets = { new Secret(null) }
                },

                new Client
                {
                    ClientName = "Client with single secret, no protection, no expiration",
                    ClientId = "single_secret_no_protection_no_expiration",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret("secret")
                    }
                },

                new Client
                {
                    ClientName = "Client with X509 Certificate",
                    ClientId = "certificate_valid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret
                        {
                            Type = IdentityServerConstants.SecretTypes.X509CertificateThumbprint,
                            Value = TestCert.Load().Thumbprint
                        }
                    }
                },

                new Client
                {
                    ClientName = "Client with X509 Certificate",
                    ClientId = "certificate_invalid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret
                        {
                            Type = IdentityServerConstants.SecretTypes.X509CertificateThumbprint,
                            Value = "invalid"
                        }
                    }
                },

                new Client
                {
                    ClientName = "Client with Base64 encoded X509 Certificate",
                    ClientId = "certificate_base64_valid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret
                        {
                            Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                            Value = Convert.ToBase64String(TestCert.Load().Export(X509ContentType.Cert))
                        }
                    }
                },

                new Client
                {
                    ClientName = "Client with Base64 encoded X509 Certificate",
                    ClientId = "certificate_base64_invalid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret
                        {
                            Type = IdentityServerConstants.SecretTypes.X509CertificateBase64,
                            Value = "invalid"
                        }
                    }
                },

                new Client
                {
                    ClientName = "Client with single secret, hashed, no expiration",
                    ClientId = "single_secret_hashed_no_expiration",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        // secret
                        new Secret("secret".Sha256())
                    }
                },

                new Client
                {
                    ClientName = "Client with multiple secrets, no protection",
                    ClientId = "multiple_secrets_no_protection",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret("secret"),
                        new Secret("foobar", "some description"),
                        new Secret("quux"),
                        new Secret("notexpired", DateTime.UtcNow.AddDays(1)),
                        new Secret("expired", DateTime.UtcNow.AddDays(-1))
                    }
                },

                new Client
                {
                    ClientName = "Client with multiple secrets, hashed",
                    ClientId = "multiple_secrets_hashed",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        // secret
                        new Secret("secret".Sha256()),
                        // foobar
                        new Secret("foobar".Sha256(), "some description"),
                        // quux
                        new Secret("quux".Sha512()),
                        // notexpired
                        new Secret("notexpired".Sha256(), DateTime.UtcNow.AddDays(1)),
                        // expired
                        new Secret("expired".Sha512(), DateTime.UtcNow.AddDays(-1))
                    },
                },

                new Client
                {
                    ClientName = "MTLS Client with invalid secrets",
                    ClientId = "mtls_client_invalid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret(@"CN=invalid", "mtls.test")
                        {
                            Type = SecretTypes.X509CertificateName
                        },
                        new Secret("invalid", "mtls.test")
                        {
                            Type = SecretTypes.X509CertificateThumbprint
                        },
                    }
                },

                new Client
                {
                    ClientName = "MTLS Client with valid secrets",
                    ClientId = "mtls_client_valid",
                    Enabled = true,

                    ClientSecrets = new List
                    {
                        new Secret(@"CN=identityserver_testing", "mtls.test")
                        {
                            Type = SecretTypes.X509CertificateName
                        },
                        new Secret("4B5FE072C7AD8A9B5DCFDD1A20608BB54DE0954F", "mtls.test")
                        {
                            Type = SecretTypes.X509CertificateThumbprint
                        },
                    }
                }
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/Factory.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Services;
using IdentityServer8.Services.Default;
using IdentityServer8.Stores;
using IdentityServer8.Stores.Serialization;
using IdentityServer8.Validation;
using Microsoft.AspNetCore.Authentication;
using Microsoft.Extensions.Logging;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal static class Factory
    {
        public static IClientStore CreateClientStore()
        {
            return new InMemoryClientStore(TestClients.Get());
        }

        public static TokenRequestValidator CreateTokenRequestValidator(
            IdentityServerOptions options = null,
            IResourceStore resourceStore = null,
            IAuthorizationCodeStore authorizationCodeStore = null,
            IRefreshTokenStore refreshTokenStore = null,
            IResourceOwnerPasswordValidator resourceOwnerValidator = null,
            IProfileService profile = null,
            IDeviceCodeValidator deviceCodeValidator = null,
            IEnumerable extensionGrantValidators = null,
            ICustomTokenRequestValidator customRequestValidator = null,
            ITokenValidator tokenValidator = null,
            IRefreshTokenService refreshTokenService = null,
            IResourceValidator resourceValidator = null)
        {
            if (options == null)
            {
                options = TestIdentityServerOptions.Create();
            }

            if (resourceStore == null)
            {
                resourceStore = new InMemoryResourcesStore(TestScopes.GetIdentity(), TestScopes.GetApis(), TestScopes.GetScopes());
            }

            if (resourceOwnerValidator == null)
            {
                resourceOwnerValidator = new TestResourceOwnerPasswordValidator();
            }

            if (profile == null)
            {
                profile = new TestProfileService();
            }
            
            if (deviceCodeValidator == null)
            {
                deviceCodeValidator = new TestDeviceCodeValidator();
            }

            if (customRequestValidator == null)
            {
                customRequestValidator = new DefaultCustomTokenRequestValidator();
            }

            ExtensionGrantValidator aggregateExtensionGrantValidator;
            if (extensionGrantValidators == null)
            {
                aggregateExtensionGrantValidator = new ExtensionGrantValidator(new[] { new TestGrantValidator() }, TestLogger.Create());
            }
            else
            {
                aggregateExtensionGrantValidator = new ExtensionGrantValidator(extensionGrantValidators, TestLogger.Create());
            }

            if (authorizationCodeStore == null)
            {
                authorizationCodeStore = CreateAuthorizationCodeStore();
            }

            if (refreshTokenStore == null)
            {
                refreshTokenStore = CreateRefreshTokenStore();
            }

            if (resourceValidator == null)
            {
                resourceValidator = CreateResourceValidator(resourceStore);
            }
            
            if (tokenValidator == null)
            {
                tokenValidator = CreateTokenValidator(refreshTokenStore: refreshTokenStore, profile: profile);
            }

            if (refreshTokenService == null)
            {
                refreshTokenService = CreateRefreshTokenService(
                    refreshTokenStore,
                    profile);
            }

            return new TokenRequestValidator(
                options,
                authorizationCodeStore,
                resourceOwnerValidator,
                profile,
                deviceCodeValidator,
                aggregateExtensionGrantValidator,
                customRequestValidator,
                resourceValidator,
                resourceStore,
                tokenValidator,
                refreshTokenService,
                new TestEventService(), 
                new StubClock(), 
                TestLogger.Create());
        }

        private static IRefreshTokenService CreateRefreshTokenService(IRefreshTokenStore store, IProfileService profile)
        {
            var service = new DefaultRefreshTokenService(
                store,
                profile,
                new StubClock(),
                TestLogger.Create());

            return service;
        }

        internal static IResourceValidator CreateResourceValidator(IResourceStore store = null)
        {
            store = store ?? new InMemoryResourcesStore(TestScopes.GetIdentity(), TestScopes.GetApis(), TestScopes.GetScopes());
            return new DefaultResourceValidator(store, new DefaultScopeParser(TestLogger.Create()), TestLogger.Create());
        }

        internal static ITokenCreationService CreateDefaultTokenCreator(IdentityServerOptions options = null)
        {
            return new DefaultTokenCreationService(
                new StubClock(),
                new DefaultKeyMaterialService(new IValidationKeysStore[] { },
                    new ISigningCredentialStore[] { new InMemorySigningCredentialsStore(TestCert.LoadSigningCredentials()) }),
                options ?? TestIdentityServerOptions.Create(),
                TestLogger.Create());
        }

        public static DeviceAuthorizationRequestValidator CreateDeviceAuthorizationRequestValidator(
            IdentityServerOptions options = null,
            IResourceStore resourceStore = null,
            IResourceValidator resourceValidator = null)
        {
            if (options == null)
            {
                options = TestIdentityServerOptions.Create();
            }
            
            if (resourceStore == null)
            {
                resourceStore = new InMemoryResourcesStore(TestScopes.GetIdentity(), TestScopes.GetApis(), TestScopes.GetScopes());
            }

            if (resourceValidator == null)
            {
                resourceValidator = CreateResourceValidator(resourceStore);
            }


            return new DeviceAuthorizationRequestValidator(
                options,
                resourceValidator,
                TestLogger.Create());
        }

        public static AuthorizeRequestValidator CreateAuthorizeRequestValidator(
            IdentityServerOptions options = null,
            IResourceStore resourceStore = null,
            IClientStore clients = null,
            IProfileService profile = null,
            ICustomAuthorizeRequestValidator customValidator = null,
            IRedirectUriValidator uriValidator = null,
            IResourceValidator resourceValidator = null,
            JwtRequestValidator jwtRequestValidator = null,
            IJwtRequestUriHttpClient jwtRequestUriHttpClient = null)
        {
            if (options == null)
            {
                options = TestIdentityServerOptions.Create();
            }

            if (resourceStore == null)
            {
                resourceStore = new InMemoryResourcesStore(TestScopes.GetIdentity(), TestScopes.GetApis(), TestScopes.GetScopes());
            }

            if (clients == null)
            {
                clients = new InMemoryClientStore(TestClients.Get());
            }

            if (customValidator == null)
            {
                customValidator = new DefaultCustomAuthorizeRequestValidator();
            }

            if (uriValidator == null)
            {
                uriValidator = new StrictRedirectUriValidator();
            }

            if (resourceValidator == null)
            {
                resourceValidator = CreateResourceValidator(resourceStore);
            }

            if (jwtRequestValidator == null)
            {
                jwtRequestValidator = new JwtRequestValidator("https://identityserver", new LoggerFactory().CreateLogger());
            }

            if (jwtRequestUriHttpClient == null)
            {
                jwtRequestUriHttpClient = new DefaultJwtRequestUriHttpClient(new HttpClient(new NetworkHandler(new Exception("no jwt request uri response configured"))), options, new LoggerFactory());
            }


            var userSession = new MockUserSession();

            return new AuthorizeRequestValidator(
                options,
                clients,
                customValidator,
                uriValidator,
                resourceValidator,
                userSession,
                jwtRequestValidator,
                jwtRequestUriHttpClient,
                TestLogger.Create());
        }

        public static TokenValidator CreateTokenValidator(
            IReferenceTokenStore store = null, 
            IRefreshTokenStore refreshTokenStore = null,
            IProfileService profile = null, 
            IdentityServerOptions options = null, ISystemClock clock = null)
        {
            if (options == null)
            {
                options = TestIdentityServerOptions.Create();
            }

            if (profile == null)
            {
                profile = new TestProfileService();
            }

            if (store == null)
            {
                store = CreateReferenceTokenStore();
            }

            clock = clock ?? new StubClock();

            if (refreshTokenStore == null)
            {
                refreshTokenStore = CreateRefreshTokenStore();
            }

            var clients = CreateClientStore();
            var context = new MockHttpContextAccessor(options);
            var logger = TestLogger.Create();

            var keyInfo = new SecurityKeyInfo
            {
                Key = TestCert.LoadSigningCredentials().Key,
                SigningAlgorithm = "RS256"
            };

            var validator = new TokenValidator(
                clients: clients,
                clock: clock,
                profile: profile,
                referenceTokenStore: store,
                refreshTokenStore: refreshTokenStore,
                customValidator: new DefaultCustomTokenValidator(),
                    keys: new DefaultKeyMaterialService(new[] { new InMemoryValidationKeysStore(new[] { keyInfo }) }, Enumerable.Empty()),
                logger: logger,
                options: options,
                context: context);

            return validator;
        }

        public static IDeviceCodeValidator CreateDeviceCodeValidator(
            IDeviceFlowCodeService service,
            IProfileService profile = null,
            IDeviceFlowThrottlingService throttlingService = null,
            ISystemClock clock = null)
        {
            profile = profile ?? new TestProfileService();
            throttlingService = throttlingService ?? new TestDeviceFlowThrottlingService();
            clock = clock ?? new StubClock();
            
            var validator = new DeviceCodeValidator(service, profile, throttlingService, clock, TestLogger.Create());

            return validator;
        }

        public static IClientSecretValidator CreateClientSecretValidator(IClientStore clients = null, SecretParser parser = null, SecretValidator validator = null, IdentityServerOptions options = null)
        {
            options = options ?? TestIdentityServerOptions.Create();

            if (clients == null) clients = new InMemoryClientStore(TestClients.Get());

            if (parser == null)
            {
                var parsers = new List
                {
                    new BasicAuthenticationSecretParser(options, TestLogger.Create()),
                    new PostBodySecretParser(options, TestLogger.Create())
                };

                parser = new SecretParser(parsers, TestLogger.Create());
            }

            if (validator == null)
            {
                var validators = new List
                {
                    new HashedSharedSecretValidator(TestLogger.Create()),
                    new PlainTextSharedSecretValidator(TestLogger.Create())
                };

                validator = new SecretValidator(new StubClock(), validators, TestLogger.Create());
            }

            return new ClientSecretValidator(clients, parser, validator, new TestEventService(), TestLogger.Create());
        }

        public static IAuthorizationCodeStore CreateAuthorizationCodeStore()
        {
            return new DefaultAuthorizationCodeStore(new InMemoryPersistedGrantStore(),
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
        }
        
        public static IRefreshTokenStore CreateRefreshTokenStore()
        {
            return new DefaultRefreshTokenStore(new InMemoryPersistedGrantStore(),
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
        }
        
        public static IReferenceTokenStore CreateReferenceTokenStore()
        {
            return new DefaultReferenceTokenStore(new InMemoryPersistedGrantStore(),
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
        }

        public static IDeviceFlowCodeService CreateDeviceCodeService()
        {
            return new DefaultDeviceFlowCodeService(new InMemoryDeviceFlowStore(), new DefaultHandleGenerationService());
        }
        
        public static IUserConsentStore CreateUserConsentStore()
        {
            return new DefaultUserConsentStore(new InMemoryPersistedGrantStore(),
                new PersistentGrantSerializer(),
                new DefaultHandleGenerationService(),
                TestLogger.Create());
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestClients.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8;
using IdentityServer8.Models;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal class TestClients
    {
        public static IEnumerable Get()
        {
            return new List
            {
                new Client
                {
                    ClientName = "Code Client",
                    Enabled = true,
                    ClientId = "codeclient",
                    ClientSecrets = new List
                    {
                        new Secret("secret".Sha256())
                    },

                    AllowedGrantTypes = GrantTypes.Code,
                    AllowedScopes = { "openid", "profile", "resource", "resource2" },

                    RequireConsent = false,
                    RequirePkce = false,

                    RedirectUris = new List
                    {
                        "https://server/cb"
                    },

                    AuthorizationCodeLifetime = 60
                },
                new Client
                {
                    ClientName = "Code Client (allows plain text PKCE)",
                    Enabled = true,
                    ClientId = "codeclient.plain",
                    ClientSecrets = new List
                    {
                        new Secret("secret".Sha256())
                    },

                    AllowedGrantTypes = GrantTypes.Code,
                    AllowedScopes = { "openid", "profile", "resource", "resource2" },
                    AllowPlainTextPkce = true,

                    RequireConsent = false,

                    RedirectUris = new List
                    {
                        "https://server/cb"
                    },

                    AuthorizationCodeLifetime = 60
                },
                new Client
                {
                    ClientName = "Code Client with PKCE",
                    Enabled = true,
                    ClientId = "codeclient.pkce",
                    ClientSecrets = new List
                    {
                        new Secret("secret".Sha256())
                    },

                    AllowedGrantTypes = GrantTypes.Code,
                    RequirePkce = true,
                    AllowedScopes = { "openid", "profile", "resource", "resource2" },

                    RequireConsent = false,

                    RedirectUris = new List
                    {
                        "https://server/cb"
                    },

                    AuthorizationCodeLifetime = 60
                },
                new Client
                {
                    ClientName = "Code Client with PKCE and plain allowed",
                    Enabled = true,
                    ClientId = "codeclient.pkce.plain",
                    ClientSecrets = new List
                    {
                        new Secret("secret".Sha256())
                    },

                    AllowedGrantTypes = GrantTypes.Code,
                    RequirePkce = true,
                    AllowPlainTextPkce = true,
                    AllowedScopes = { "openid", "profile", "resource", "resource2" },

                    RequireConsent = false,

                    RedirectUris = new List
                    {
                        "https://server/cb"
                    },

                    AuthorizationCodeLifetime = 60
                },
                new Client
                {
                        ClientName = "Hybrid Client",
                        Enabled = true,
                        ClientId = "hybridclient",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.Hybrid,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowAccessTokensViaBrowser = true,

                        RequireConsent = false,
                        RequirePkce = false,

                        RedirectUris = new List
                        {
                            "https://server/cb"
                        },

                        AuthorizationCodeLifetime = 60
                    },
                    new Client
                    {
                        ClientName = "Hybrid Client with PKCE",
                        Enabled = true,
                        ClientId = "hybridclient.pkce",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.Hybrid,
                        RequirePkce = true,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowAccessTokensViaBrowser = true,

                        RequireConsent = false,

                        RedirectUris = new List
                        {
                            "https://server/cb"
                        },

                        AuthorizationCodeLifetime = 60
                    },
                    new Client
                    {
                        ClientName = "Hybrid Client",
                        Enabled = true,
                        ClientId = "hybridclient_no_aavb",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.Hybrid,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowAccessTokensViaBrowser = false,

                        RequireConsent = false,
                        RequirePkce = false,

                        RedirectUris = new List
                        {
                            "https://server/cb"
                        },

                        AuthorizationCodeLifetime = 60
                    },
                    new Client
                    {
                        ClientName = "Implicit Client",
                        ClientId = "implicitclient",

                        AllowedGrantTypes = GrantTypes.Implicit,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowAccessTokensViaBrowser = true,

                        RequireConsent = false,

                        RedirectUris = new List
                        {
                            "oob://implicit/cb"
                        }
                    },
                    new Client
                    {
                        ClientName = "Implicit Client",
                        ClientId = "implicitclient_no_aavb",

                        AllowedGrantTypes = GrantTypes.Implicit,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowAccessTokensViaBrowser = false,

                        RequireConsent = false,

                        RedirectUris = new List
                        {
                            "oob://implicit/cb"
                        }
                    },
                    new Client
                    {
                        ClientName = "Implicit and Client Credentials Client",
                        Enabled = true,
                        ClientId = "implicit_and_client_creds_client",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ImplicitAndClientCredentials,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        RequireConsent = false,

                        RedirectUris = new List
                        {
                            "oob://implicit/cb"
                        }
                    },
                    new Client
                    {
                        ClientName = "Code Client with Scope Restrictions",
                        Enabled = true,
                        ClientId = "codeclient_restricted",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.Code,
                        RequireConsent = false,
                        RequirePkce = false,

                        AllowedScopes = new List
                        {
                            "openid"
                        },

                        RedirectUris = new List
                        {
                            "https://server/cb"
                        }
                    },
                    new Client
                    {
                        ClientName = "Client Credentials Client",
                        Enabled = true,
                        ClientId = "client",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ClientCredentials,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        AllowOfflineAccess = true,

                        AccessTokenType = AccessTokenType.Jwt
                    },
                    new Client
                    {
                        ClientName = "Client Credentials Client (restricted)",
                        Enabled = true,
                        ClientId = "client_restricted",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ClientCredentials,

                        AllowedScopes = new List
                        {
                            "resource"
                        }
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client",
                        Enabled = true,
                        ClientId = "roclient",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        AllowOfflineAccess = true
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client - Public",
                        Enabled = true,
                        ClientId = "roclient.public",
                        RequireClientSecret = false,

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" }
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client",
                        Enabled = true,
                        ClientId = "roclient_absolute_refresh_expiration_one_time_only",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        RefreshTokenExpiration = TokenExpiration.Absolute,
                        RefreshTokenUsage = TokenUsage.OneTimeOnly,
                        AbsoluteRefreshTokenLifetime = 200
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client",
                        Enabled = true,
                        ClientId = "roclient_absolute_refresh_expiration_reuse",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        RefreshTokenExpiration = TokenExpiration.Absolute,
                        RefreshTokenUsage = TokenUsage.ReUse,
                        AbsoluteRefreshTokenLifetime = 200
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client",
                        Enabled = true,
                        ClientId = "roclient_sliding_refresh_expiration_one_time_only",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        RefreshTokenExpiration = TokenExpiration.Sliding,
                        RefreshTokenUsage = TokenUsage.OneTimeOnly,
                        AbsoluteRefreshTokenLifetime = 10,
                        SlidingRefreshTokenLifetime = 4
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client",
                        Enabled = true,
                        ClientId = "roclient_sliding_refresh_expiration_reuse",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        RefreshTokenExpiration = TokenExpiration.Sliding,
                        RefreshTokenUsage = TokenUsage.ReUse,
                        AbsoluteRefreshTokenLifetime = 200,
                        SlidingRefreshTokenLifetime = 100
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client (restricted)",
                        Enabled = true,
                        ClientId = "roclient_restricted",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,

                        AllowedScopes = new List
                        {
                            "resource"
                        }
                    },
                    new Client
                    {
                        ClientName = "Resource Owner Client (restricted with refresh)",
                        Enabled = true,
                        ClientId = "roclient_restricted_refresh",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ResourceOwnerPassword,

                        AllowOfflineAccess = true,
                        AllowedScopes = new List
                        {
                            "resource"
                        }
                    },

                    new Client
                    {
                        ClientName = "Custom Grant Client",
                        Enabled = true,
                        ClientId = "customgrantclient",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = { "custom_grant" },
                        AllowedScopes = { "openid", "profile", "resource", "resource2" }
                    },

                    new Client
                    {
                        ClientName = "Disabled Client",
                        Enabled = false,
                        ClientId = "disabled",
                        ClientSecrets = new List
                        {
                            new Secret("invalid".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.ClientCredentials,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" }
                    },
                    new Client
                    {
                        ClientName = "Reference Token Client",

                        Enabled = true,
                        ClientId = "referencetokenclient",
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },

                        AllowedGrantTypes = GrantTypes.Implicit,
                        RedirectUris = { "https://notused" },
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },

                        AccessTokenType = AccessTokenType.Reference
                    },
                    new Client
                    {
                        ClientId = "wsfed",
                        ClientName = "WS-Fed Client",
                        ProtocolType = IdentityServerConstants.ProtocolTypes.WsFederation,
                        AllowedGrantTypes = GrantTypes.Implicit,
                        Enabled = true,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" },
                        RedirectUris = { "http://wsfed/callback"  }
                    },
                    new Client
                    {
                        ClientId = "client.cred.wsfed",
                        ClientName = "WS-Fed Client",
                        ProtocolType = IdentityServerConstants.ProtocolTypes.WsFederation,
                        AllowedGrantTypes = GrantTypes.ClientCredentials,
                        ClientSecrets = { new Secret("secret".Sha256()) },

                        Enabled = true,
                        AllowedScopes = { "openid", "profile", "resource", "resource2" }
                    },
                    new Client
                    {
                        ClientId = "client.implicit",
                        ClientName = "Implicit Client",
                        AllowedGrantTypes = GrantTypes.Implicit,
                        RedirectUris = { "https://notused" },
                        AllowedScopes = { "openid", "profile", "resource", "resource2" }
                    },
                    new Client
                    {
                        ClientId = "implicit_and_client_creds",
                        AllowedGrantTypes = GrantTypes.ImplicitAndClientCredentials,
                        RedirectUris = { "https://notused" },
                        AllowedScopes = {"api1"}
                    },
                    new Client
                    {
                        ClientId = "device_flow",
                        ClientName = "Device Flow Client",
                        AllowedGrantTypes = GrantTypes.DeviceFlow,
                        AllowedScopes = { "openid", "profile", "resource" },
                        AllowOfflineAccess = true,
                        ClientSecrets = new List
                        {
                            new Secret("secret".Sha256())
                        },
                    }
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestDeviceCodeValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.Setup
{
    public class TestDeviceCodeValidator : IDeviceCodeValidator
    {
        private readonly bool shouldError;

        public TestDeviceCodeValidator(bool shouldError = false)
        {
            this.shouldError = shouldError;
        }

        public Task ValidateAsync(DeviceCodeValidationContext context)
        {
            if (shouldError) context.Result = new TokenRequestValidationResult(context.Request, "error");
            else context.Result = new TokenRequestValidationResult(context.Request);

            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestDeviceFlowThrottlingService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Validation.Setup
{
    public class TestDeviceFlowThrottlingService : IDeviceFlowThrottlingService
    {
        private readonly bool shouldSlownDown;

        public TestDeviceFlowThrottlingService(bool shouldSlownDown = false)
        {
            this.shouldSlownDown = shouldSlownDown;
        }

        public Task ShouldSlowDown(string deviceCode, DeviceCode details) => Task.FromResult(shouldSlownDown);
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestGrantValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal class TestGrantValidator : IExtensionGrantValidator
    {
        private readonly bool _isInvalid;
        private readonly string _errorDescription;

        public TestGrantValidator(bool isInvalid = false, string errorDescription = null)
        {
            _isInvalid = isInvalid;
            _errorDescription = errorDescription;
        }

        public Task ValidateAsync(ValidatedTokenRequest request)
        {
            if (_isInvalid)
            {
                return Task.FromResult(new GrantValidationResult(TokenRequestErrors.InvalidGrant, _errorDescription));
            }

            return Task.FromResult(new GrantValidationResult("bob", "CustomGrant"));
        }

        public Task ValidateAsync(ExtensionGrantValidationContext context)
        {
            if (_isInvalid)
            {
                context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, _errorDescription);
            }
            else
            {
                context.Result = new GrantValidationResult("bob", "CustomGrant");
            }

            return Task.CompletedTask;
        }

        public string GrantType
        {
            get { return "custom_grant"; }
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestProfileService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Services;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal class TestProfileService : IProfileService
    {
        private bool _shouldBeActive;

        public TestProfileService(bool shouldBeActive = true)
        {
            _shouldBeActive = shouldBeActive;
        }

        public Task GetProfileDataAsync(ProfileDataRequestContext context)
        {
            return Task.CompletedTask;
        }

        public Task IsActiveAsync(IsActiveContext context)
        {
            context.IsActive = _shouldBeActive;
            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestResourceOwnerPasswordValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Threading.Tasks;
using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.Setup
{
    public class TestResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
    {
        private string _erroDescription;
        private TokenRequestErrors _error;
        private readonly bool _sendError;

        public TestResourceOwnerPasswordValidator()
        { }

        public TestResourceOwnerPasswordValidator(TokenRequestErrors error, string errorDescription = null)
        {
            _sendError = true;
            _error = error;
            _erroDescription = errorDescription;
        }

        public Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
        {
            if (_sendError)
            {
                context.Result = new GrantValidationResult(_error, _erroDescription);
                return Task.CompletedTask;
            }

            if (context.UserName == context.Password)
            {
                context.Result = new GrantValidationResult(context.UserName, "password");
            }
            
            if (context.UserName == "bob_no_password" && context.Password == "")
            {
                context.Result = new GrantValidationResult(context.UserName, "password");
            }

            return Task.CompletedTask;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestScopes.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Generic;
using IdentityServer8.Models;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal class TestScopes
    {
        public static IEnumerable GetIdentity()
        {
            return new IdentityResource[]
            {
                new IdentityResources.OpenId(),
                new IdentityResources.Profile()
            };
        }

        public static IEnumerable GetApis()
        {
            return new ApiResource[]
            {
                new ApiResource
                {
                    Name = "api",
                    Scopes =  { "resource", "resource2" }
                }
            };
        }

        public static IEnumerable GetScopes()
        {
            return new ApiScope[]
            {
                new ApiScope
                {
                    Name = "resource",
                    Description = "resource scope"
                },
                new ApiScope
                {
                    Name = "resource2",
                    Description = "resource scope"
                }
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TestTokenValidator.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Validation;
using System.Threading.Tasks;

namespace IdentityServer.UnitTests.Validation.Setup
{
    class TestTokenValidator : ITokenValidator
    {
        private readonly TokenValidationResult _result;

        public TestTokenValidator(TokenValidationResult result)
        {
            _result = result;
        }

        public Task ValidateAccessTokenAsync(string token, string expectedScope = null)
        {
            return Task.FromResult(_result);
        }

        public Task ValidateIdentityTokenAsync(string token, string clientId = null, bool validateLifetime = true)
        {
            return Task.FromResult(_result);
        }

        public Task ValidateRefreshTokenAsync(string token, Client client = null)
        {
            return Task.FromResult(_result);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/TokenFactory.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Models;

namespace IdentityServer.UnitTests.Validation.Setup
{
    internal static class TokenFactory
    {
        public static Token CreateAccessToken(Client client, string subjectId, int lifetime, params string[] scopes)
        {
            var claims = new List 
            {
                new Claim("client_id", client.ClientId),
                new Claim("sub", subjectId)
            };

            scopes.ToList().ForEach(s => claims.Add(new Claim("scope", s)));

            var token = new Token(OidcConstants.TokenTypes.AccessToken)
            {
                CreationTime = DateTime.UtcNow,
                Audiences = { "https://idsvr.com/resources" },
                Issuer = "https://idsvr.com",
                Lifetime = lifetime,
                Claims = claims,
                ClientId = client.ClientId,
                AccessTokenType = client.AccessTokenType
            };

            return token;
        }

        public static Token CreateAccessTokenLong(Client client, string subjectId, int lifetime, int count, params string[] scopes)
        {
            var claims = new List
            {
                new Claim("client_id", client.ClientId),
                new Claim("sub", subjectId)
            };

            for (int i = 0; i < count; i++)
            {
                claims.Add(new Claim("junk", "x".Repeat(100)));
            }

            scopes.ToList().ForEach(s => claims.Add(new Claim("scope", s)));

            var token = new Token(OidcConstants.TokenTypes.AccessToken)
            {
                CreationTime = DateTime.UtcNow,
                Audiences = { "https://idsvr.com/resources" },
                Issuer = "https://idsvr.com",
                Lifetime = lifetime,
                Claims = claims,
                ClientId = client.ClientId,
                AccessTokenType = client.AccessTokenType
            };

            return token;
        }

        public static Token CreateIdentityToken(string clientId, string subjectId)
        {
            var clients = Factory.CreateClientStore();

            var claims = new List 
            {
                new Claim("sub", subjectId)
            };

            var token = new Token(OidcConstants.TokenTypes.IdentityToken)
            {
                CreationTime = DateTime.UtcNow,
                Audiences = { clientId },
                ClientId = clientId,
                Issuer = "https://idsvr.com",
                Lifetime = 600,
                Claims = claims
            };

            return token;
        }

        public static Token CreateIdentityTokenLong(string clientId, string subjectId, int count)
        {
            var clients = Factory.CreateClientStore();

            var claims = new List
            {
                new Claim("sub", subjectId)
            };

            for (int i = 0; i < count; i++)
            {
                claims.Add(new Claim("junk", "x".Repeat(100)));
            }

            var token = new Token(OidcConstants.TokenTypes.IdentityToken)
            {
                CreationTime = DateTime.UtcNow,
                Audiences = { clientId },
                ClientId = clientId,
                Issuer = "https://idsvr.com",
                Lifetime = 600,
                Claims = claims
            };

            return token;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/Setup/ValidationExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using IdentityServer8.Models;
using IdentityServer8.Validation;

namespace IdentityServer.UnitTests.Validation.Setup
{ 
    public static class ValidationExtensions
    {
        public static ClientSecretValidationResult ToValidationResult(this Client client, ParsedSecret secret = null)
        {
            return new ClientSecretValidationResult
            {
                Client = client,
                Secret = secret
            };
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/StrictRedirectUriValidatorAppAuthValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityServer.UnitTests.Common;
using IdentityServer8.Models;
using IdentityServer8.Validation;
using System.Collections.Generic;
using System.Threading.Tasks;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class StrictRedirectUriValidatorAppAuthValidation
    {
        private const string Category = "Strict Redirect Uri Validator AppAuth Validation Tests";

        private Client clientWithValidLoopbackRedirectUri = new Client
        {
            RequirePkce = true,
            RedirectUris = new List
            {
                "http://127.0.0.1"
            }
        };

        private Client clientWithNoRedirectUris = new Client
        {
            RequirePkce = true
        };

        [Theory]
        [Trait("Category", Category)]
        [InlineData("http://127.0.0.1")] // This is in the clients redirect URIs
        [InlineData("http://127.0.0.1:0")]
        [InlineData("http://127.0.0.1:80")]
        [InlineData("http://127.0.0.1:65535")]
        [InlineData("http://127.0.0.1:123/a/b")]
        [InlineData("http://127.0.0.1:123?q=123")]
        [InlineData("http://127.0.0.1:443/?q=123")]
        [InlineData("http://127.0.0.1:443/a/b?q=123")]
        [InlineData("http://127.0.0.1:443#abc")]
        [InlineData("http://127.0.0.1:443/a/b?q=123#abc")]
        public async Task Loopback_Redirect_URIs_Should_Be_AllowedAsync(string requestedUri)
        {
            var strictRedirectUriValidatorAppAuthValidator = new StrictRedirectUriValidatorAppAuth(TestLogger.Create());

            var result = await strictRedirectUriValidatorAppAuthValidator.IsRedirectUriValidAsync(requestedUri, clientWithValidLoopbackRedirectUri);

            result.Should().BeTrue();
        }

        [Theory]
        [Trait("Category", Category)]
        [InlineData(null)]
        [InlineData("")]
        [InlineData("http:")]
        [InlineData("127.0.0.1")]
        [InlineData("//127.0.0.1")]
        [InlineData("https://127.0.0.1:123")]
        [InlineData("http://127.0.0.1:")]
        [InlineData("http://127.0.0.1:-1")]
        [InlineData("http://127.0.0.2:65536")]
        [InlineData("http://127.0.0.1:443a")]
        [InlineData("http://127.0.0.1:a443")]
        [InlineData("http://127.0.0.1:443a/")]
        [InlineData("http://127.0.0.1:443a?")]
        [InlineData("http://127.0.0.2:443")]
        [InlineData("http://127.0.0.1#abc")]
        [InlineData("http://127.0.0.1:#abc")]
        public async Task Loopback_Redirect_URIs_Should_Not_Be_AllowedAsync(string requestedUri)
        {
            var strictRedirectUriValidatorAppAuthValidator = new StrictRedirectUriValidatorAppAuth(TestLogger.Create());

            var result = await strictRedirectUriValidatorAppAuthValidator.IsRedirectUriValidAsync(requestedUri, clientWithValidLoopbackRedirectUri);

            result.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_ClientCredentials_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Linq;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_ClientCredentials_Invalid
    {
        private const string Category = "TokenRequest Validation - ClientCredentials - Invalid";

        private IClientStore _clients = Factory.CreateClientStore();

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_GrantType_For_Client()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Request_should_succeed_even_with_allowed_identity_scopes_because_they_are_filtered_out()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials }
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.Count.Should().Be(1);
            result.ValidatedRequest.ValidatedResources.Resources.ApiResources.First().Name.Should().Be("api");

            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Count.Should().Be(2);
            result.ValidatedRequest.ValidatedResources.Resources.ApiScopes.Select(x=>x.Name).Should().BeEquivalentTo(new[] { "resource", "resource2" });
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Scope()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();
            
            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "unknown");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Scope_Multiple()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource unknown");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Scope()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client_restricted");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource2");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Scope_Multiple()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client_restricted");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource resource2");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Identity_scope_is_not_allowed_for_client_credentials_when_specified_explicitly()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials },
                { OidcConstants.TokenRequest.Scope, "openid" }
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Resource_and_Refresh_Token()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource offline_access");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_Code_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_Code_Invalid
    {
        private IClientStore _clients = Factory.CreateClientStore();
        private const string Category = "TokenRequest Validation - AuthorizationCode - Invalid";

        private ClaimsPrincipal _subject = new IdentityServerUser("bob").CreatePrincipal();

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_AuthorizationCode()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_AuthorizationCode()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, "invalid");
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task AuthorizationCodeTooLong()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();
            var options = new IdentityServerOptions();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);
            var longCode = "x".Repeat(options.InputLengthRestrictions.AuthorizationCode + 1);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, longCode);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task No_Scopes_for_AuthorizationCode()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            OidcConstants.TokenErrors.InvalidRequest.Should().Be(result.Error);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_Not_Authorized_For_AuthorizationCode_Flow()
        {
            var client = await _clients.FindEnabledClientByIdAsync("implicitclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_Trying_To_Request_Token_Using_Another_Clients_Code()
        {
            var client1 = await _clients.FindEnabledClientByIdAsync("codeclient");
            var client2 = await _clients.FindEnabledClientByIdAsync("codeclient_restricted");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client1.ClientId,
                Lifetime = client1.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client2.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_RedirectUri()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Different_RedirectUri_Between_Authorize_And_Token_Request()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server1/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server2/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Expired_AuthorizationCode()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                CreationTime = DateTime.UtcNow.AddSeconds(-100),
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Reused_AuthorizationCode()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            // request first time
            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();

            // request second time
            validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);
            
            result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Code_Request_with_disabled_User()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                RedirectUri = "https://server/cb",
                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store,
                profile: new TestProfileService(shouldBeActive: false));

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_DeviceCode_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_DeviceCode_Invalid
    {
        private const string Category = "TokenRequest Validation - DeviceCode - Invalid";

        private readonly IClientStore _clients = Factory.CreateClientStore();

        private readonly DeviceCode deviceCode = new DeviceCode
        {
            ClientId = "device_flow",
            IsAuthorized = true,
            Subject = new IdentityServerUser("bob").CreatePrincipal(),
            IsOpenId = true,
            Lifetime = 300,
            CreationTime = DateTime.UtcNow,
            AuthorizedScopes = new[] {"openid", "profile", "resource"}
        };

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_DeviceCode()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                {OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.DeviceCode}
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidRequest);
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCode_Too_Long()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");

            var longCode = "x".Repeat(new IdentityServerOptions().InputLengthRestrictions.AuthorizationCode + 1);
            
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                {OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.DeviceCode},
                {"device_code", longCode}
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Grant_For_Client()
        {
            var client = await _clients.FindClientByIdAsync("codeclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                {OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.DeviceCode},
                {"device_code", Guid.NewGuid().ToString()}
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());
            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task DeviceCodeValidator_Failure()
        {
            var client = await _clients.FindClientByIdAsync("device_flow");

            var validator = Factory.CreateTokenRequestValidator(deviceCodeValidator: new TestDeviceCodeValidator(true));

            var parameters = new NameValueCollection
            {
                {OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.DeviceCode},
                {"device_code", Guid.NewGuid().ToString()}
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());
            result.IsError.Should().BeTrue();
            result.Error.Should().NotBeNull();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_ExtensionGrants_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_ExtensionGrants_Invalid
    {
        private const string Category = "TokenRequest Validation - Extension Grants - Invalid";

        private IClientStore _clients = Factory.CreateClientStore();

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Extension_Grant_Type_For_Client_Credentials_Client()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, "customGrant" },
                { OidcConstants.TokenRequest.Scope, "resource" }
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Extension_Grant_Type()
        {
            var client = await _clients.FindEnabledClientByIdAsync("customgrantclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, "unknown_grant_type" },
                { OidcConstants.TokenRequest.Scope, "resource" }
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Customer_Error_and_Description_Extension_Grant_Type()
        {
            var client = await _clients.FindEnabledClientByIdAsync("customgrantclient");

            var validator = Factory.CreateTokenRequestValidator(extensionGrantValidators: new[] { new TestGrantValidator(isInvalid: true, errorDescription: "custom error description") });

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, "custom_grant" },
                { OidcConstants.TokenRequest.Scope, "resource" }
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
            result.ErrorDescription.Should().Be("custom error description");
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task inactive_user_should_fail()
        {
            var client = await _clients.FindEnabledClientByIdAsync("customgrantclient");

            var validator = Factory.CreateTokenRequestValidator(
                profile: new TestProfileService(shouldBeActive: false));

            var parameters = new NameValueCollection
            {
                { OidcConstants.TokenRequest.GrantType, "custom_grant" },
                { OidcConstants.TokenRequest.Scope, "resource" }
            };

            var result = await validator.ValidateRequestAsync(
                parameters, 
                client.ToValidationResult());

            result.IsError.Should().BeTrue();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_General_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_General_Invalid
    {
        private const string Category = "TokenRequest Validation - General - Invalid";

        private IClientStore _clients = new InMemoryClientStore(TestClients.Get());
        private ClaimsPrincipal _subject = new IdentityServerUser("bob").CreatePrincipal();

        [Fact]
        [Trait("Category", Category)]
        public void Parameters_Null()
        {
            var validator = Factory.CreateTokenRequestValidator();

            Func act = () => validator.ValidateRequestAsync(null, null);

            act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public void Client_Null()
        {
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, "valid");
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            Func act = () => validator.ValidateRequestAsync(parameters, null);

            act.Should().ThrowAsync();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Grant_Type()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "unknown");
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_Protocol_Type()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client.cred.wsfed");
            var codeStore = Factory.CreateAuthorizationCodeStore();

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore:codeStore);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "client_credentials");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_Grant_Type()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var store = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                IsOpenId = true,
                RedirectUri = "https://server/cb",
                Subject = _subject
            };

            var handle = await store.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: store);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_PKCE.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Text;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_PKCE
    {
        private const string Category = "TokenRequest Validation - PKCE";

        private IClientStore _clients = Factory.CreateClientStore();
        private InputLengthRestrictions lengths = new InputLengthRestrictions();

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task valid_pkce_token_request_with_plain_method_should_succeed(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();
            var verifier = "x".Repeat(lengths.CodeVerifierMinLength);

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("bob").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                CodeChallenge = verifier.Sha256(),
                CodeChallengeMethod = OidcConstants.CodeChallengeMethods.Plain,

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, verifier);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task valid_pkce_token_request_with_plain_method_should_succeed_hybrid()
        {
            var client = await _clients.FindEnabledClientByIdAsync("hybridclient.pkce");
            var grants = Factory.CreateAuthorizationCodeStore();
            var verifier = "x".Repeat(lengths.CodeVerifierMinLength);

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                CodeChallenge = verifier.Sha256(),
                CodeChallengeMethod = OidcConstants.CodeChallengeMethods.Plain,

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, verifier);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task valid_pkce_token_request_with_sha256_method_should_succeed(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();

            var verifier = "x".Repeat(lengths.CodeVerifierMinLength);
            var challenge = VerifierToSha256CodeChallenge(verifier);
            
            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                CodeChallenge = challenge.Sha256(),
                CodeChallengeMethod = OidcConstants.CodeChallengeMethods.Sha256,

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, verifier);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [Trait("Category", Category)]
        public async Task token_request_with_missing_code_challenge_and_verifier_should_fail(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task token_request_with_missing_code_challenge_should_fail(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, "x".Repeat(lengths.CodeVerifierMinLength));
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task token_request_with_invalid_verifier_plain_method_should_fail(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();
            var verifier = "x".Repeat(lengths.CodeVerifierMinLength);

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                CodeChallenge = verifier.Sha256(),
                CodeChallengeMethod = OidcConstants.CodeChallengeMethods.Plain,

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, verifier + "invalid");
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Theory]
        [InlineData("codeclient.pkce")]
        [InlineData("codeclient")]
        [Trait("Category", Category)]
        public async Task token_request_with_invalid_verifier_sha256_method_should_fail(string clientId)
        {
            var client = await _clients.FindEnabledClientByIdAsync(clientId);
            var grants = Factory.CreateAuthorizationCodeStore();

            var verifier = "x".Repeat(lengths.CodeVerifierMinLength);
            var challenge = VerifierToSha256CodeChallenge(verifier);

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                CodeChallenge = challenge.Sha256(),
                CodeChallengeMethod = OidcConstants.CodeChallengeMethods.Sha256,

                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.CodeVerifier, verifier + "invalid");
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        private static string VerifierToSha256CodeChallenge(string codeVerifier)
        {
            var codeVerifierBytes = Encoding.ASCII.GetBytes(codeVerifier);
            var hashedBytes = codeVerifierBytes.Sha256();
            var transformedCodeVerifier = Base64Url.Encode(hashedBytes);

            return transformedCodeVerifier;
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_RefreshToken_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Configuration;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_RefreshToken_Invalid
    {
        private const string Category = "TokenRequest Validation - RefreshToken - Invalid";

        private IClientStore _clients = Factory.CreateClientStore();

        [Fact]
        [Trait("Category", Category)]
        public async Task Non_existing_RefreshToken()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, "nonexistent");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task RefreshTokenTooLong()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var options = new IdentityServerOptions();

            var validator = Factory.CreateTokenRequestValidator();
            var longRefreshToken = "x".Repeat(options.InputLengthRestrictions.RefreshToken + 1);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, longRefreshToken);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Expired_RefreshToken()
        {
            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token") { ClientId = "roclient" },
                Lifetime = 10,
                CreationTime = DateTime.UtcNow.AddSeconds(-15)
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Wrong_Client_Binding_RefreshToken_Request()
        {
            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token")
                {
                    ClientId = "otherclient",
                    Lifetime = 600,
                    CreationTime = DateTime.UtcNow
                }
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Client_has_no_OfflineAccess_Scope_anymore_at_RefreshToken_Request()
        {
            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token")
                {
                    ClientId = "roclient_restricted"
                },
                Lifetime = 600,
                CreationTime = DateTime.UtcNow
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient_restricted");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task RefreshToken_Request_with_disabled_User()
        {
            var subjectClaim = new Claim(JwtClaimTypes.Subject, "foo");

            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token")
                {
                    Claims = new List { subjectClaim },
                    ClientId = "roclient"
                },
                Lifetime = 600,
                CreationTime = DateTime.UtcNow
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants,
                profile: new TestProfileService(shouldBeActive: false));

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_ResourceOwner_Invalid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System.Collections.Specialized;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Common;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_ResourceOwner_Invalid
    {
        private const string Category = "TokenRequest Validation - ResourceOwner - Invalid";

        private IClientStore _clients = Factory.CreateClientStore();

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_GrantType_For_Client()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnauthorizedClient);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Scope()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "unknown");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Unknown_Scope_Multiple()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource unknown");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Scope()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient_restricted");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource2");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Restricted_Scope_Multiple()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient_restricted");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource resource2");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidScope);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task No_ResourceOwnerCredentials()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_ResourceOwner_UserName()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Invalid_ResourceOwner_Credentials()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "notbob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
            result.ErrorDescription.Should().Be("invalid_username_or_password");
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_ResourceOwner_password_for_user_with_password_should_fail()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob_with_password");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Password_GrantType_Not_Supported()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator(resourceOwnerValidator: new NotSupportedResourceOwnerPasswordValidator(TestLogger.Create()));

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType);
            result.ErrorDescription.Should().BeNull();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Inactive_ResourceOwner()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator(profile: new TestProfileService(shouldBeActive: false));

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Password_GrantType_With_Custom_ErrorDescription()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator(resourceOwnerValidator: new TestResourceOwnerPasswordValidator(TokenRequestErrors.InvalidGrant, "custom error description"));

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "notbob");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.TokenErrors.InvalidGrant);
            result.ErrorDescription.Should().Be("custom error description");
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/TokenRequest Validation/TokenRequestValidation_Valid.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Security.Claims;
using System.Threading.Tasks;
using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8;
using IdentityServer8.Models;
using IdentityServer8.Stores;
using Xunit;

namespace IdentityServer.UnitTests.Validation.TokenRequest_Validation
{
    public class TokenRequestValidation_Valid
    {
        private const string Category = "TokenRequest Validation - General - Valid";

        private IClientStore _clients = Factory.CreateClientStore();

        [Fact]
        [Trait("Category", Category)]
        public async Task Missing_ResourceOwner_password_for_user_with_no_password_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");
            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob_no_password");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
            result.ValidatedRequest.UserName.Should().Be("bob_no_password");
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_code_request_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var grants = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                RedirectUri = "https://server/cb",
                RequestedScopes = new List
                {
                    "openid"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_code_request_with_refresh_token_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("codeclient");
            var grants = Factory.CreateAuthorizationCodeStore();

            var code = new AuthorizationCode
            {
                CreationTime = DateTime.UtcNow,
                ClientId = client.ClientId,
                Lifetime = client.AuthorizationCodeLifetime,
                Subject = new IdentityServerUser("123").CreatePrincipal(),
                RedirectUri = "https://server/cb",
                RequestedScopes = new List
                {
                    "openid",
                    "offline_access"
                }
            };

            var handle = await grants.StoreAuthorizationCodeAsync(code);

            var validator = Factory.CreateTokenRequestValidator(
                authorizationCodeStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.AuthorizationCode);
            parameters.Add(OidcConstants.TokenRequest.Code, handle);
            parameters.Add(OidcConstants.TokenRequest.RedirectUri, "https://server/cb");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_client_credentials_request_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_client_credentials_request_with_default_scopes_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client_restricted");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_client_credentials_request_for_implicit_and_client_credentials_client_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("implicit_and_client_creds_client");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_client_credentials_request_restricted_client_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("client_restricted");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.ClientCredentials);
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_resource_owner_request_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_resource_wwner_request_with_refresh_token_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource offline_access");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_resource_owner_request_restricted_client_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("roclient_restricted");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password);
            parameters.Add(OidcConstants.TokenRequest.UserName, "bob");
            parameters.Add(OidcConstants.TokenRequest.Password, "bob");
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task valid_extension_grant_request_should_succeed()
        {
            var client = await _clients.FindEnabledClientByIdAsync("customgrantclient");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "custom_grant");
            parameters.Add(OidcConstants.TokenRequest.Scope, "resource");

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_refresh_token_request_should_succeed()
        {
            var subjectClaim = new Claim(JwtClaimTypes.Subject, "foo");

            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token")
                {
                    Claims = new List { subjectClaim },
                    ClientId = "roclient"
                },
                Lifetime = 600,
                CreationTime = DateTime.UtcNow
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_refresh_token_request_using_restricted_client_should_succeed()
        {
            var subjectClaim = new Claim(JwtClaimTypes.Subject, "foo");

            var refreshToken = new RefreshToken
            {
                AccessToken = new Token("access_token")
                {
                    Claims = new List { subjectClaim },
                    ClientId = "roclient_restricted_refresh"
                },

                Lifetime = 600,
                CreationTime = DateTime.UtcNow
            };

            var grants = Factory.CreateRefreshTokenStore();
            var handle = await grants.StoreRefreshTokenAsync(refreshToken);

            var client = await _clients.FindEnabledClientByIdAsync("roclient_restricted_refresh");

            var validator = Factory.CreateTokenRequestValidator(
                refreshTokenStore: grants);

            var parameters = new NameValueCollection();
            parameters.Add(OidcConstants.TokenRequest.GrantType, "refresh_token");
            parameters.Add(OidcConstants.TokenRequest.RefreshToken, handle);

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());

            result.IsError.Should().BeFalse();
        }
        
        [Fact]
        [Trait("Category", Category)]
        public async Task Valid_device_code_request_should_succeed()
        {
            var deviceCode = new DeviceCode
            {
                ClientId = "device_flow",
                IsAuthorized = true,
                Subject = new IdentityServerUser("bob").CreatePrincipal(),
                IsOpenId = true,
                Lifetime = 300,
                CreationTime = DateTime.UtcNow,
                AuthorizedScopes = new[] { "openid", "profile", "resource" }
            };

            var client = await _clients.FindClientByIdAsync("device_flow");

            var validator = Factory.CreateTokenRequestValidator();

            var parameters = new NameValueCollection
            {
                {OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.DeviceCode},
                {"device_code", Guid.NewGuid().ToString()}
            };

            var result = await validator.ValidateRequestAsync(parameters, client.ToValidationResult());
            result.IsError.Should().BeFalse();
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/Validation/UserInfoRequestValidation.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using IdentityModel;
using IdentityServer.UnitTests.Validation.Setup;
using IdentityServer8.Stores;
using IdentityServer8.Validation;
using System.Collections.Generic;
using System.Security.Claims;
using System.Threading.Tasks;
using IdentityServer.UnitTests.Common;
using Xunit;

namespace IdentityServer.UnitTests.Validation
{
    public class UserInfoRequestValidation
    {
        private const string Category = "UserInfo Request Validation Tests";
        private IClientStore _clients = new InMemoryClientStore(TestClients.Get());

        [Fact]
        [Trait("Category", Category)]
        public async Task token_without_sub_should_fail()
        {
            var tokenResult = new TokenValidationResult
            {
                IsError = false,
                Client = await _clients.FindEnabledClientByIdAsync("codeclient"),
                Claims = new List()
            };

            var validator = new UserInfoRequestValidator(
                new TestTokenValidator(tokenResult),
                new TestProfileService(shouldBeActive: true),
                TestLogger.Create());

            var result = await validator.ValidateRequestAsync("token");

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task active_user_should_succeed()
        {
            var tokenResult = new TokenValidationResult
            {
                IsError = false,
                Client = await _clients.FindEnabledClientByIdAsync("codeclient"),
                Claims = new List
                {
                    new Claim("sub", "123")
                },
            };

            var validator = new UserInfoRequestValidator(
                new TestTokenValidator(tokenResult),
                new TestProfileService(shouldBeActive: true),
                TestLogger.Create());

            var result = await validator.ValidateRequestAsync("token");

            result.IsError.Should().BeFalse();
        }

        [Fact]
        [Trait("Category", Category)]
        public async Task inactive_user_should_fail()
        {
            var tokenResult = new TokenValidationResult
            {
                IsError = false,
                Client = await _clients.FindEnabledClientByIdAsync("codeclient"),
                Claims = new List
                {
                    new Claim("sub", "123")
                },
            };

            var validator = new UserInfoRequestValidator(
                new TestTokenValidator(tokenResult),
                new TestProfileService(shouldBeActive: false),
                TestLogger.Create());

            var result = await validator.ValidateRequestAsync("token");

            result.IsError.Should().BeTrue();
            result.Error.Should().Be(OidcConstants.ProtectedResourceErrors.InvalidToken);
        }
    }
}


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/identityserver_testing.cer
================================================
-----BEGIN CERTIFICATE-----
MIIDQTCCAimgAwIBAgIQO+9qzaJY9I5Ewq81kNEKWTANBgkqhkiG9w0BAQsFADAh
MR8wHQYDVQQDDBZpZGVudGl0eXNlcnZlcl90ZXN0aW5nMCAXDTIwMDEyMjIzMTYz
OFoYDzIxMDMwNTIyMjMyNjM5WjAhMR8wHQYDVQQDDBZpZGVudGl0eXNlcnZlcl90
ZXN0aW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuyZQvE+6gEoB
a+LV3dxjk/Xj4DRJ/tefQKR2AZoYAAfKN4ditFmEfRC1A6rckBpMVihTeb1kwwQT
7H4HTS6O/ERHVjOdghoOjEsVakWhAkvh8gphC4IU0upXlYqMh2WzgXEXwYRFB9Tk
7zoHb1/zjEEAhCf2Xbi6YslBoU71bFWyAaeOTl859wV6WaiBIK5L8nJUaIaq4zmC
k8caPZq5E867mZiMdL4TcW9/YoAAO96Wa/W9o6OiuZrP414TlEjVuccpLXvjk0hB
U5OZD2bTvD3MQZu1n1QMLwXfaOBrcv1/RqYJkK7vpP6Pp1YYlo7b2PBDVAIrRSVT
laViBP0owQIDAQABo3MwcTAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYB
BQUHAwIGCCsGAQUFBwMBMCEGA1UdEQQaMBiCFmlkZW50aXR5c2VydmVyX3Rlc3Rp
bmcwHQYDVR0OBBYEFCVXNpKp8QlHywXEBFfpXxWcOMcsMA0GCSqGSIb3DQEBCwUA
A4IBAQBsEAzwyN6V6N5ggN9G1O0ZpviSjixGkWtySNCBjbGXAhOvfW4M3ysNkDwZ
ltk/Q17ihZzw135MrDCmnr5pRiN4CbEGbe1qsb+Z0uCCn8/WcIVYYooW66H/Jez+
dg5RxUukA67ZDnjzRskIer7L2t1C4pDqpvPVcneUxkiYDSgcKpTuCVjkPNQKQTIw
Sm98NkQG8G8V8+ENIU837ytkiC5nqQa4zDRHexzWrYhiuayWWxJKcNRVF9YaE8ts
vp5N1ewmWbSgF8caJuKraVOISj9R4iqf0XuhfSpW/7eIWYmXfqy/UloeqlALfP5C
2d2FdDSfsQ4Jgc3ebrECAQaCC3Gq
-----END CERTIFICATE-----


================================================
FILE: src/IdentityServer8/test/IdentityServer.UnitTests/xunit.runner.json
================================================
{
  "methodDisplay":"classAndMethod"
}


================================================
FILE: src/IdentityServer8.sln
================================================
Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.8.34322.80
MinimumVisualStudioVersion = 10.0.40219.1
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{5461C61B-B06E-46BA-B206-925B660BE727}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{45C22EDD-91B1-4AEF-8620-77F4E3E7C544}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8", "IdentityServer8\src\IdentityServer8.csproj", "{407C030E-60E6-41F7-AF43-0AC48EDCC17D}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "IdentityServer8\host\Host.csproj", "{784B3C88-30FA-415D-B99E-584063064508}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer.UnitTests", "IdentityServer8\test\IdentityServer.UnitTests\IdentityServer.UnitTests.csproj", "{4291820C-735F-4776-8BC4-6527433BC683}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer.IntegrationTests", "IdentityServer8\test\IdentityServer.IntegrationTests\IdentityServer.IntegrationTests.csproj", "{94501373-478A-478D-8C17-6AC52E3438CF}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.Storage", "EntityFramework.Storage\src\IdentityServer8.EntityFramework.Storage.csproj", "{5302DAB3-1662-4956-97AA-5EA5E85B10F6}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.UnitTests", "EntityFramework.Storage\test\UnitTests\IdentityServer8.EntityFramework.UnitTests.csproj", "{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.IntegrationTests", "EntityFramework.Storage\test\IntegrationTests\IdentityServer8.EntityFramework.IntegrationTests.csproj", "{E90F7470-C7F8-464B-9C28-87C474085812}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "migrations", "migrations", "{E3EF31E0-6658-4899-8BDA-FF84355E2FDD}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "EntityFramework.Storage\migrations\SqlServer\SqlServer.csproj", "{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "host", "host", "{07C56E10-A807-4372-ACD9-ADED2D099BC8}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ConsoleHost", "EntityFramework.Storage\host\ConsoleHost\ConsoleHost.csproj", "{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "IdentityServer", "IdentityServer", "{37FCD1F7-B8CB-4D7B-A2E8-0AE458652314}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "EntityFramework.Storage", "EntityFramework.Storage", "{28C914A4-BC3B-4D55-8799-C8A4A6AD724E}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "IdentityServer", "IdentityServer", "{E5F41733-E9B8-4EA8-A5A3-620827B68340}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "EntityFramework.Storage", "EntityFramework.Storage", "{6F2785D9-4208-4A9F-85B0-674185D393C5}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Storage", "Storage", "{19B12297-DCC0-4529-A04C-5B0E2C0F01B9}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Storage", "Storage", "{6CB8A0D7-77D4-411B-953C-A4AB50F56205}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.Storage", "Storage\src\IdentityServer8.Storage.csproj", "{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.AspNetIdentity", "AspNetIdentity\src\IdentityServer8.AspNetIdentity.csproj", "{A2CDBE15-5898-4A04-94DC-133EE03A78B3}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "AspNetIdentity\host\Host.csproj", "{B7FBA07C-A462-4869-AF94-5E36DFC3742D}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "AspNetIdentity\migrations\SqlServer\SqlServer.csproj", "{DD44B9E9-C32E-4F89-92C9-25444A709BBB}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework", "EntityFramework\src\IdentityServer8.EntityFramework.csproj", "{AB83F911-8B78-4973-A3A9-2A2D85581F25}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SqlServer", "EntityFramework\migrations\SqlServer\SqlServer.csproj", "{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.EntityFramework.Tests", "EntityFramework\test\IdentityServer8.EntityFramework.Tests\IdentityServer8.EntityFramework.Tests.csproj", "{E3685B06-F135-4318-B841-889C35479D5C}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Files", "Solution Files", "{29DC1E06-3EC5-4F52-9EC1-0363BD571369}"
	ProjectSection(SolutionItems) = preProject
		..\.gitignore = ..\.gitignore
		..\Directory.Build.props = ..\Directory.Build.props
		..\Directory.Build.targets = ..\Directory.Build.targets
		Directory.BuildOld.targets = Directory.BuildOld.targets
		..\Directory.Packages.props = ..\Directory.Packages.props
		..\global.json = ..\global.json
		..\IdentityServer8.DotNet.ruleset = ..\IdentityServer8.DotNet.ruleset
		..\LICENSE = ..\LICENSE
		..\LicenseHeader.txt = ..\LicenseHeader.txt
		..\NuGet.config = ..\NuGet.config
		..\README.md = ..\README.md
		..\SECURITY.MD = ..\SECURITY.MD
		..\SPONSORS.md = ..\SPONSORS.md
		..\version.json = ..\version.json
	EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "AspNetIdentity", "AspNetIdentity", "{7849D7DE-FD6A-4A5B-A793-5DCFFCDDC944}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "EntityFramework", "EntityFramework", "{06FC2C45-FCD6-469C-8F2D-3E1A750D1EF9}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "EntityFramework", "EntityFramework", "{39F7E2E8-1EAB-4163-8E4D-43CBB23AB871}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = ".github", ".github", "{A7171FEC-FEC1-4AF0-9625-E69D93F08A42}"
	ProjectSection(SolutionItems) = preProject
		..\.github\CONTRIBUTING.md = ..\.github\CONTRIBUTING.md
		..\.github\dependabot.yml = ..\.github\dependabot.yml
		..\.github\FUNDING.yml = ..\.github\FUNDING.yml
		..\.github\PULL_REQUEST_TEMPLATE.md = ..\.github\PULL_REQUEST_TEMPLATE.md
	EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "issuetemplate", "issuetemplate", "{0BC5E76A-A280-49C8-8E96-A43FEA357A4B}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{C5474352-0715-41C0-92C2-BABA1A4103A0}"
	ProjectSection(SolutionItems) = preProject
		..\.github\workflows\codeql.yml = ..\.github\workflows\codeql.yml
		..\.github\workflows\develop.yml = ..\.github\workflows\develop.yml
		..\.github\workflows\master.yml = ..\.github\workflows\master.yml
		..\.github\workflows\pre-release.yml = ..\.github\workflows\pre-release.yml
		..\.github\workflows\release.yml = ..\.github\workflows\release.yml
	EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "docs", "docs", "{21B3EAAF-1A7D-4D46-AB3F-843296EDBDC2}"
	ProjectSection(SolutionItems) = preProject
		..\docs\CHANGELOG.md = ..\docs\CHANGELOG.md
	EndProjectSection
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Security", "Security", "{9B9C47C4-560E-4F2E-8F53-97F9FDE46008}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Security", "Security", "{19B652D0-0AA1-415C-AA62-065EE8C77182}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.Security", "Security\IdentityServer8.Security\IdentityServer8.Security.csproj", "{284DF9E0-8007-4E84-949D-5B610D76B1CF}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.Sanitizer.Tests", "Security\test\IdentityServer8.Santizer.Tests\IdentityServer8.Sanitizer.Tests.csproj", "{00BDF864-B06A-4A48-B8B4-85C219B33CD1}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Host", "EntityFramework\host\Host.csproj", "{C7939ADD-36C9-444F-A773-28EC81587831}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Release|Any CPU = Release|Any CPU
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D}.Release|Any CPU.Build.0 = Release|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{784B3C88-30FA-415D-B99E-584063064508}.Release|Any CPU.Build.0 = Release|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{4291820C-735F-4776-8BC4-6527433BC683}.Release|Any CPU.Build.0 = Release|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{94501373-478A-478D-8C17-6AC52E3438CF}.Release|Any CPU.Build.0 = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6}.Release|Any CPU.Build.0 = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC}.Release|Any CPU.Build.0 = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E90F7470-C7F8-464B-9C28-87C474085812}.Release|Any CPU.Build.0 = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3}.Release|Any CPU.Build.0 = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5}.Release|Any CPU.Build.0 = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|Any CPU.Build.0 = Release|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3}.Release|Any CPU.Build.0 = Release|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D}.Release|Any CPU.Build.0 = Release|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB}.Release|Any CPU.ActiveCfg = Release|Any CPU		
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{AB83F911-8B78-4973-A3A9-2A2D85581F25}.Release|Any CPU.Build.0 = Release|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69}.Release|Any CPU.Build.0 = Release|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{E3685B06-F135-4318-B841-889C35479D5C}.Release|Any CPU.Build.0 = Release|Any CPU
		{284DF9E0-8007-4E84-949D-5B610D76B1CF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{284DF9E0-8007-4E84-949D-5B610D76B1CF}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{284DF9E0-8007-4E84-949D-5B610D76B1CF}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{284DF9E0-8007-4E84-949D-5B610D76B1CF}.Release|Any CPU.Build.0 = Release|Any CPU
		{00BDF864-B06A-4A48-B8B4-85C219B33CD1}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{00BDF864-B06A-4A48-B8B4-85C219B33CD1}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{00BDF864-B06A-4A48-B8B4-85C219B33CD1}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{00BDF864-B06A-4A48-B8B4-85C219B33CD1}.Release|Any CPU.Build.0 = Release|Any CPU
		{C7939ADD-36C9-444F-A773-28EC81587831}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{C7939ADD-36C9-444F-A773-28EC81587831}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{C7939ADD-36C9-444F-A773-28EC81587831}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{C7939ADD-36C9-444F-A773-28EC81587831}.Release|Any CPU.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{407C030E-60E6-41F7-AF43-0AC48EDCC17D} = {E5F41733-E9B8-4EA8-A5A3-620827B68340}
		{784B3C88-30FA-415D-B99E-584063064508} = {E5F41733-E9B8-4EA8-A5A3-620827B68340}
		{4291820C-735F-4776-8BC4-6527433BC683} = {37FCD1F7-B8CB-4D7B-A2E8-0AE458652314}
		{94501373-478A-478D-8C17-6AC52E3438CF} = {37FCD1F7-B8CB-4D7B-A2E8-0AE458652314}
		{5302DAB3-1662-4956-97AA-5EA5E85B10F6} = {6F2785D9-4208-4A9F-85B0-674185D393C5}
		{8239FC82-46A3-4F21-8D05-1F0BE0B1B1FC} = {28C914A4-BC3B-4D55-8799-C8A4A6AD724E}
		{E90F7470-C7F8-464B-9C28-87C474085812} = {28C914A4-BC3B-4D55-8799-C8A4A6AD724E}
		{E3EF31E0-6658-4899-8BDA-FF84355E2FDD} = {6F2785D9-4208-4A9F-85B0-674185D393C5}
		{A93A59EC-D75D-44E1-9720-F75D9EF95BC3} = {E3EF31E0-6658-4899-8BDA-FF84355E2FDD}
		{07C56E10-A807-4372-ACD9-ADED2D099BC8} = {6F2785D9-4208-4A9F-85B0-674185D393C5}
		{2AA5AC6B-531B-426E-AD38-5B03F1949CF5} = {07C56E10-A807-4372-ACD9-ADED2D099BC8}
		{37FCD1F7-B8CB-4D7B-A2E8-0AE458652314} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{28C914A4-BC3B-4D55-8799-C8A4A6AD724E} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{E5F41733-E9B8-4EA8-A5A3-620827B68340} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{6F2785D9-4208-4A9F-85B0-674185D393C5} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{19B12297-DCC0-4529-A04C-5B0E2C0F01B9} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{6CB8A0D7-77D4-411B-953C-A4AB50F56205} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7} = {19B12297-DCC0-4529-A04C-5B0E2C0F01B9}
		{A2CDBE15-5898-4A04-94DC-133EE03A78B3} = {7849D7DE-FD6A-4A5B-A793-5DCFFCDDC944}
		{B7FBA07C-A462-4869-AF94-5E36DFC3742D} = {7849D7DE-FD6A-4A5B-A793-5DCFFCDDC944}
		{DD44B9E9-C32E-4F89-92C9-25444A709BBB} = {7849D7DE-FD6A-4A5B-A793-5DCFFCDDC944}
		{AB83F911-8B78-4973-A3A9-2A2D85581F25} = {06FC2C45-FCD6-469C-8F2D-3E1A750D1EF9}
		{D9FABEC8-09DC-4B0D-80D7-86FA6C5D9C69} = {06FC2C45-FCD6-469C-8F2D-3E1A750D1EF9}
		{E3685B06-F135-4318-B841-889C35479D5C} = {39F7E2E8-1EAB-4163-8E4D-43CBB23AB871}
		{7849D7DE-FD6A-4A5B-A793-5DCFFCDDC944} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{06FC2C45-FCD6-469C-8F2D-3E1A750D1EF9} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{39F7E2E8-1EAB-4163-8E4D-43CBB23AB871} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{A7171FEC-FEC1-4AF0-9625-E69D93F08A42} = {29DC1E06-3EC5-4F52-9EC1-0363BD571369}
		{0BC5E76A-A280-49C8-8E96-A43FEA357A4B} = {A7171FEC-FEC1-4AF0-9625-E69D93F08A42}
		{C5474352-0715-41C0-92C2-BABA1A4103A0} = {A7171FEC-FEC1-4AF0-9625-E69D93F08A42}
		{21B3EAAF-1A7D-4D46-AB3F-843296EDBDC2} = {29DC1E06-3EC5-4F52-9EC1-0363BD571369}
		{9B9C47C4-560E-4F2E-8F53-97F9FDE46008} = {5461C61B-B06E-46BA-B206-925B660BE727}
		{19B652D0-0AA1-415C-AA62-065EE8C77182} = {45C22EDD-91B1-4AEF-8620-77F4E3E7C544}
		{284DF9E0-8007-4E84-949D-5B610D76B1CF} = {9B9C47C4-560E-4F2E-8F53-97F9FDE46008}
		{00BDF864-B06A-4A48-B8B4-85C219B33CD1} = {19B652D0-0AA1-415C-AA62-065EE8C77182}
		{C7939ADD-36C9-444F-A773-28EC81587831} = {06FC2C45-FCD6-469C-8F2D-3E1A750D1EF9}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {176723F7-4A9B-4F05-A9F3-3BA715E4BDC3}
	EndGlobalSection
EndGlobal


================================================
FILE: src/IdentityServer8.sln.licenseheader
================================================
extensions: designer.cs generated.cs
extensions: .cs 
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/


================================================
FILE: src/Security/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/Security/IdentityServer8.Security/Extensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

public class Ioc
{
    static Ioc()
    {
        var services = new ServiceCollection();
        services.AddLogging();
        services.AddSanitizers();
        services.AddAllowAnyRedirectService();
        services.AddSingleton();
        ServiceProvider = services.BuildServiceProvider();
        var sanitizer = ServiceProvider.GetRequiredService();
        Sanitizer = sanitizer;
        var redirectService = ServiceProvider.GetRequiredService();
        RedirectService = redirectService;
    }

    public static ServiceProvider ServiceProvider { get; }
    public static ISanitizer Sanitizer { get; }
    public static IRedirectService RedirectService { get; }

}


================================================
FILE: src/Security/IdentityServer8.Security/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityServer8.Security;
global using Microsoft.AspNetCore.Http;
global using Microsoft.Extensions.DependencyInjection;
global using Microsoft.Extensions.Logging;
global using System.Net;
global using System.Web;


================================================
FILE: src/Security/IdentityServer8.Security/IdentityServer8.Security.csproj
================================================


    
        Security package for user input sanitzation IdentityServer8 services and packages.
        true
        true
        enable
        enable
    

    
        
        
        
        
        
        
    




================================================
FILE: src/Security/IdentityServer8.Security/RedirectService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Security;

public interface IRedirectService
{
    bool IsRedirectAllowed(string redirectUrl);
}


public class RuleMatcher
{
    public bool IsMatch(string url, RedirectRule rule)
    {
        throw new NotImplementedException();
    }
}
public class RedirectRule
{
    public static RedirectRule AllowAny
        => new RedirectRule();

    public RedirectRule()
    {
        AllowedFragment = Fragment.Any;
        AllowedPath = Path.Any;
        AllowedPort = Port.Any;
        AllowedQuery = Query.Any;
        AllowedScheme = Scheme.Any;
        AllowedHost = Host.Any;
    }
    public Scheme AllowedScheme { get; set; }
    public Host AllowedHost { get; set; }
    public Port AllowedPort { get; set; }
    public Path AllowedPath { get; set; }
    public Query AllowedQuery { get; set; }
    public Fragment AllowedFragment { get; set; }
}

public class Scheme
{
    public Scheme(string name) { Name = name; }
    public string Name { get; }

    public static readonly Scheme Http = new Scheme("http");
    public static readonly Scheme Https = new Scheme("https");
    public static readonly Scheme Any = new Scheme("*");

    public static Scheme Parse(string schemeName)
    {
        if (string.IsNullOrWhiteSpace(schemeName))
        {
            throw new ArgumentException("Scheme name cannot be null or empty");
        }
        else if (schemeName.Equals("http", StringComparison.OrdinalIgnoreCase))
        {
            return Http;
        }
        else if (schemeName.Equals("https", StringComparison.OrdinalIgnoreCase))
        {
            return Https;
        }
        else if (schemeName.Equals("*", StringComparison.OrdinalIgnoreCase))
        {
            return Any;
        }
        else
        {
            throw new ArgumentException("Invalid scheme name");
        }

    }

    public override string ToString()
    {
        return Name;
    }
}

public class Host
{
    public Host(string value)
    {
        Value = ((value ?? "").ToLower().Trim() ?? "");
        var domainParts = Value.Split('.');
        domainParts = domainParts.Where(x => !string.IsNullOrEmpty(x)).ToArray();
        HostParts = new List(domainParts);
    }
    public List HostParts;

    public string Value { get; }

    public static readonly Host Any = new Host("*");

    public static Host Create(string hostname) => new Host(hostname);

    public bool HasWildcard => Value.Contains("*.");
    public bool IsAny => Value == "*";
    public bool IsLocalhost => Value.Equals("localhost", StringComparison.OrdinalIgnoreCase) || Value.Equals("127.0.0.1");
    public bool IsIpAddress => Uri.CheckHostName(Value) == UriHostNameType.IPv4 || Uri.CheckHostName(Value) == UriHostNameType.IPv6;
    public bool IsLocalNetwork => IsLocalhost || IsIpAddress;
    public bool IsFullQualifiedDomainName => !IsLocalNetwork && !HasWildcard && !IsAny && Value.IndexOf('.') > -1;

}

public class Port
{
    public Port(int value) { Value = value; }
    public int Value { get; }

    public static readonly Port Any = new Port(-1); // Assuming -1 signifies any port

    public static Port Create(int portNumber) => new Port(portNumber);
}

public class Path
{
    public Path(string value) { Value = value; }
    public string Value { get; }

    public static readonly Path Any = new Path("*");

    public static Path Create(string path) => new Path(path);
}

public class Query
{
    public Query(string value) { Value = value; }
    public string Value { get; }

    public static readonly Query Any = new Query("*");

    public static Query Create(string query) => new Query(query);
}

public class Fragment
{
    public Fragment(string value) { Value = value; }
    public string Value { get; }

    public static readonly Fragment Any = new Fragment("*");

    public static Fragment Create(string fragment) => new Fragment(fragment);
}


public class RedirectValidition
{
    static RedirectValidition()
    {
        var provider = new ServiceCollection()
            .AddLogging()
            .AddSingleton()
            .AddSanitizers()
            .BuildServiceProvider();
        ServiceProvider = provider;

    }

    public static ServiceProvider ServiceProvider { get; }
}

public static class RedirectServiceExtensions
{

    public static IServiceCollection AddAllowAnyRedirectService(this IServiceCollection services)
    {
        services.AddSingleton();
        return services;
    }
}

public class AllowAnyRedirectService : RedirectService
{
    public AllowAnyRedirectService(ILogger logger, ISanitizer sanitizer) : base(logger, sanitizer)
    {
        AddRedirectRule(RedirectRule.AllowAny);
    }
}

public class RedirectService : IRedirectService
{
    public RedirectService(ILogger logger, ISanitizer sanitizer)
    {
        _logger = logger;
        _sanitizer = sanitizer;
    }
    private readonly List _rules = new List();
    private readonly ILogger _logger;
    private readonly ISanitizer _sanitizer;

    public IRedirectService AddRedirectRule(RedirectRule rule)
    {
        _rules.Add(rule);
        return this;
    }
    public IRedirectService ClearRules()
    {
        _rules.Clear();
        return this;
    }

    public IRedirectService AddRule(RedirectRule rule)
    {
        _rules.Add(rule);
        return this;
    }

    public IRedirectService RemoveRule(RedirectRule rule)
    {
        _rules.Remove(rule);
        return this;
    }
    public IRedirectService AddRules(IEnumerable rules)
    {
        _rules.AddRange(rules);
        return this;
    }
    public IRedirectService RemoveRules(IEnumerable rules)
    {
        foreach (var rule in rules)
        {
            RemoveRule(rule);
        }
        return this;
    }

    public virtual bool IsRedirectAllowed(string redirectUrl)
    {
        if (!Uri.TryCreate(redirectUrl, UriKind.RelativeOrAbsolute, out var uri))
        {
            _logger.LogWarning("Invalid URL: {redirectUrl}", redirectUrl.SanitizeForLog());
            return false;
        }

        // If the URL is relative, assume it's allowed, or handle according to your policy
        if (!uri.IsAbsoluteUri)
        {
            // Handle relative URLs based on your specific requirements.
            // For example, we might always allow them, check them against a specific set of rules,
            // or reject them outright.
            return HandleRelativeUrl(uri);
        }

        foreach (var rule in _rules)
        {
            if (IsRuleMatch(uri, rule))
            {
                return true;
            }
        }

        return false;
    }

    public bool HandleRelativeUrl(Uri uri)
    {
        // Implement logic for handling relative URLs on local server.
        // This is a placeholder as restricting redirect URLs on the local server is not a common scenario.
        // For now: return true to allow all relative URLs
        return true;
    }


    public bool IsRuleMatch(Uri uri, RedirectRule rule)
    {
        return IsSchemeMatch(uri, rule.AllowedScheme) &&
               IsHostMatch(uri, rule.AllowedHost) &&
               IsPortMatch(uri, rule.AllowedPort) &&
               IsPathMatch(uri, rule.AllowedPath) &&
               IsQueryMatch(uri, rule.AllowedQuery) &&
               IsFragmentMatch(uri, rule.AllowedFragment);
    }

    public bool IsSchemeMatch(Uri uri, Scheme allowedScheme)
    {
        return allowedScheme == Scheme.Any || uri.Scheme.Equals(allowedScheme.Name, StringComparison.OrdinalIgnoreCase);
    }

    public bool IsHostMatch(string url, Host allowedHost)
    {
        if (string.IsNullOrWhiteSpace(url))
        {
            return false;
        }

        if (allowedHost == Host.Any)
        {
            return true;
        }

        // Check if URL already has a valid scheme; if not, prepend "http://" as a default
        if (!url.StartsWith("http://", StringComparison.OrdinalIgnoreCase) &&
            !url.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
        {
            url = "http://" + url;
        }

        // Attempt to parse the URL into a Uri object
        if (Uri.TryCreate(url, UriKind.Absolute, out var uri))
        {
            // Delegate to the existing IsHostMatch method that takes a Uri object
            return IsHostMatch(uri, allowedHost);
        }
        else
        {
            // Log error or handle invalid URL format as needed
            return false;
        }
    }


    public bool IsHostMatch(Uri uri, Host allowedHost)
    {
        // Handle the case where any host is allowed
        if (allowedHost == Host.Any)
        {
            return true;
        }

        string uriHost = uri.Host;
        string allowedHostValue = allowedHost.Value;

        // Direct match or wildcard match
        if (uriHost.Equals(allowedHostValue, StringComparison.OrdinalIgnoreCase) ||
            allowedHostValue == "*")
        {
            return true;
        }

        // Check for wildcard subdomain match
        if (allowedHostValue.StartsWith("*."))
        {
            string allowedDomain = allowedHostValue.Substring(2);
            if (uriHost.EndsWith(allowedDomain, StringComparison.OrdinalIgnoreCase) &&
                // Additional check to ensure we're matching subdomains and not just any part of the host
                (uriHost.Count(c => c == '.') == allowedDomain.Count(c => c == '.') + 1))
            {
                return true;
            }
        }

        return false;
    }

    public bool IsPortMatch(Uri uri, Port allowedPort)
    {
        return allowedPort == Port.Any || uri.Port == allowedPort.Value;
    }

    public bool IsPathMatch(Uri uri, Path allowedPath)
    {
        return allowedPath == Path.Any || uri.AbsolutePath.Equals(allowedPath.Value, StringComparison.OrdinalIgnoreCase);
    }

    public bool IsQueryMatch(Uri uri, Query allowedQuery)
    {
        return allowedQuery == Query.Any || uri.Query.Equals(allowedQuery.Value, StringComparison.OrdinalIgnoreCase);
    }

    public bool IsFragmentMatch(Uri uri, Fragment allowedFragment)
    {
        return allowedFragment == Fragment.Any || uri.Fragment.Equals(allowedFragment.Value, StringComparison.OrdinalIgnoreCase);
    }

}


public class RedirectUrlValidator
{
    private readonly IRedirectService _redirectService;

    public RedirectUrlValidator(IRedirectService redirectService)
    {
        _redirectService = redirectService;
    }

    public bool IsRedirectUrlValid(string redirectUrl)
    {
        return _redirectService.IsRedirectAllowed(redirectUrl);
    }
}


================================================
FILE: src/Security/IdentityServer8.Security/RedirectUrlParser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Security;

public readonly ref struct RedirectUrlS
{
    private readonly ReadOnlySpan _input;

    public RedirectUrlS(string input)
    {
        _input = input.AsSpan();
    }

    //public RedirectUrlS Parse()
    //{
    //    // Default values representing wildcards
    //    var scheme = Scheme.Any;
    //    var host = Host.Any;
    //    var port = Port.Any;
    //    var path = Path.Any;
    //    var query = Query.Any;
    //    var fragment = Fragment.Any;
    //    int offset = 0;
    //    int schemeEnd = _input.IndexOf("://");
    //    if (schemeEnd != -1)
    //    {
    //        scheme = new Scheme(_input.Slice(0, schemeEnd).ToString());
    //        offset = schemeEnd + 3;
    //    }

    //    int pathStart = _input.IndexOf('/');
    //    int portEnd = _input.Slice(0, pathStart != -1 ? pathStart : _input.Length).IndexOf(':');

    //    if (portEnd != -1)
    //    {
    //        host = new Host(_input.Slice(0, portEnd).ToString());
    //        port = new Port(int.Parse(_input.Slice(portEnd + 1, pathStart - portEnd - 1).ToString()));
    //    }
    //    else if (pathStart != -1)
    //    {
    //        host = new Host(_input.Slice(0, pathStart).ToString());
    //    }
    //    else
    //    {
    //        host = new Host(_input.ToString());
    //    }

    //    if (pathStart != -1)
    //    {
    //        offset = pathStart;
    //        int queryStart = _input.IndexOf('?');
    //        int fragmentStart = _input.IndexOf('#');

    //        if (queryStart != -1)
    //        {
    //            path = new Path(_input.Slice(0, queryStart).ToString());
    //            offset = queryStart + 1;


    //            if (fragmentStart != -1)
    //            {
    //                query = new Query(_input.Slice(0, fragmentStart - queryStart - 1).ToString());
    //                fragment = new Fragment(_input.Slice(fragmentStart + 1).ToString());
    //            }
    //            else
    //            {
    //                query = new Query(_input.ToString());
    //            }
    //        }
    //        else if (fragmentStart != -1)
    //        {
    //            path = new Path(_input.Slice(0, fragmentStart).ToString());
    //            fragment = new Fragment(_input.Slice(fragmentStart + 1).ToString());
    //        }
    //        else
    //        {
    //            path = new Path(_input.ToString());
    //        }
    //    }

    //    return new RedirectUrl
    //    {
    //        Scheme = scheme,
    //        Host = host,
    //        Port = port,
    //        Path = path,
    //        Query = query,
    //        Fragment = fragment
    //    };
    //}
}

public class RedirectUrlParser
{
    public static UrlParts Parse(string redirectUrl)
    {
        // extract scheme, host, port, path, query, and fragment from the redirectUrl
        // and return a RedirectUrl object
        // expand: example.com to *://**.example.com:*/**?**#*
        // expand: example.com/path to *://**.example.com:*/path?**#*
        // expand: example.com/* to *://**.example.com:*/**?**#*
        // expand: example.com/path/* to *://**.example.com:*/path/*?**#*
        // expand: example.com/path/** to *://**.example.com:*/path/**?**#*
        // expand: example.com/path/1/* to *://**.example.com:*/path/1/*?query#fragment
        // expand: example.com/path/1/** to *://**.example.com:*/path/1/**?query#fragment
        // expand: example.com/path/** to *://**.example.com:*/path/**?**#*
        // expand: example.com/path/1/path/2?quru to *://**.example.com:*/path?query#fragment

        var schemeParts = redirectUrl.Split("://");
        var originalScheme = schemeParts.Length == 1 ? "" : schemeParts[0];
        var scheme = schemeParts.Length == 1 ? Scheme.Any : Scheme.Parse(schemeParts[0]);


        var tail = redirectUrl.Substring(schemeParts.Length == 1 ? 0 : schemeParts[0].Length + 3);
        var idx = tail.IndexOf("/");
        var hostAndPort = tail.Substring(0, idx);
        var portDelimiter = hostAndPort.IndexOf(":");
        var host = portDelimiter > 0 ? hostAndPort.Substring(0, portDelimiter) : hostAndPort;
        var port = portDelimiter > 0 ? hostAndPort.Substring(portDelimiter + 1) : "";
        int portNumber = 0;
        if(int.TryParse(port, out var parsedPort))
        {
            portNumber = parsedPort;
        }
        else
        {
            //TODO: Modify port to accept wildcards, multiple ports, and ranges
            //port = "";
        }
        var domainParts = host.Split(".");

        var absolutePath = idx > -1 ? tail.Substring(idx) : "";
        var pathParts = absolutePath.Split("?");
        var path = pathParts[0];
        var query = pathParts.Length == 1 ? "" : pathParts[1];
        var queryParts = query.Split("#");
        var queryString = queryParts[0];
        var queryStringParts = queryString.Split("&");

        var fragment = queryParts.Length == 1 ? "" : queryParts[1];
        var fragmentParts = fragment.Split("#");

        return new UrlParts
        {

            Scheme = scheme,
            Host = Host.Create(host),
            Port = Port.Create(portNumber),
            Path = Path.Create(path),
            Query = Query.Create(queryString),
            Fragment = Fragment.Create(fragment)
        };

    }

}
public class UrlParts
{
    public UrlParts()
    {
        Scheme= Scheme.Any;
        Host = Host.Any;
        Port = Port.Any;
        Path = Path.Any;
        Query = Query.Any;
        Fragment = Fragment.Any;

    }
    public UrlParts(Scheme scheme, Host host, Port port, Path path, Query query, Fragment fragment)
    {
        Scheme = scheme;
        Host = host;
        Port = port;
        Path = path;
        Query = query;
        Fragment = fragment;
    }
    public Scheme Scheme { get; set; }
    public Host Host { get; set; }
    public Port Port { get; set; }
    public Path Path { get; set; }
    public Query Query { get; set; }
    public Fragment Fragment { get; set; }
}


================================================
FILE: src/Security/IdentityServer8.Security/RedirectUrlServiceExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;

public static class RedirectUrlServiceExtensions
{
    public static bool IsAllowedRedirect(this string redirectUrl)
    {
        return Ioc.RedirectService.IsRedirectAllowed(redirectUrl);
    }
    public static bool IsAllowedRedirect(this Uri uri)
    {
        return Ioc.RedirectService.IsRedirectAllowed(uri.ToString());
    }

    public static void RedirectIfAllowed(this HttpResponse response, string url)
    {
        if (IsAllowedRedirect(url))
            response.Redirect(url.SanitizeForRedirect());
        else
            SetRedirectNotAllowed(response);
    }

    public static void SetRedirectNotAllowed(this HttpResponse response)
    {
        response.StatusCode = (int) HttpStatusCode.Forbidden;
    }

    public static void SetRedirectNotAllowed(this HttpContext ctx)
    {
        ctx.Response.SetRedirectNotAllowed();
    }

}


================================================
FILE: src/Security/IdentityServer8.Security/Sanitizer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Security;

public enum SanitizerType
{
    Unknown = 0,
    HtmlSanitizer,
    XmlSanitizer,
    JsonSanitizer,
    UrlSanitizer,
    CssSanitizer,
    ScriptSanitizer,
    StyleSanitizer,
    SqlSanitizer,
    LogSanitizer
}
public enum SanitizerMode
{
    Debug,
    Clean,
    Mask,
    Full
}
public interface IInputSanitizer
{
    public string? Sanitize(string? input, SanitizerMode mode = SanitizerMode.Clean);
}
public interface ISanitizerFactory
{
    TSanitizer Create()
        where TSanitizer : IInputSanitizer;

    IInputSanitizer Create(SanitizerType type);
}
public interface IHtmlSanitizer : IInputSanitizer
{
}
public interface IXmlSanitizer : IInputSanitizer
{
}
public interface IJsonSanitizer : IInputSanitizer
{
}
public interface IUrlSanitizer : IInputSanitizer
{
}
public interface ICssSanitizer : IInputSanitizer
{
}
public interface IScriptSanitizer : IInputSanitizer
{
}
public interface IStyleSanitizer : IInputSanitizer
{
}
public interface ISqlSanitizer : IInputSanitizer
{
}
public interface ILogSanitizer : IInputSanitizer
{
}

public interface ISanitizerService
{
    string? Sanitize(string? input, SanitizerType type, SanitizerMode mode);
}

public abstract class SanitizerServiceBase : ISanitizerService
{
    public abstract string? Sanitize(string? input, SanitizerType type, SanitizerMode mode);
}
public class SanitizerService : SanitizerServiceBase
{
    private readonly ISanitizerFactory _sanitizerFactory;

    public SanitizerService(ISanitizerFactory sanitizerFactory)
    {
        _sanitizerFactory = sanitizerFactory;
    }
    public override string? Sanitize(string? input, SanitizerType type, SanitizerMode mode)
    {
        var sanitizer = _sanitizerFactory.Create(type);
        return sanitizer.Sanitize(input, mode);
    }


}

public class SanitizerBase : IInputSanitizer
{
    private Func _sanitize;

    public SanitizerBase() : this(HttpUtility.HtmlEncode)
    {
    }

    public SanitizerBase(Func sanitizer)
    {
        _sanitize = sanitizer;
    }

    public virtual string? Sanitize(string? input, SanitizerMode mode = SanitizerMode.Debug)
    {
        switch (mode)
        {
            case SanitizerMode.Debug:
                return input;
            case SanitizerMode.Clean:
                return Clean(input);
            case SanitizerMode.Mask:
            case SanitizerMode.Full:
                var result = _sanitize(input) ?? "";
                switch (mode)
                {
                    case SanitizerMode.Mask:
                        return Mask(result);
                    case SanitizerMode.Full:
                        return result;
                    default:
                        throw new NotImplementedException();
                }
            default:
                throw new NotImplementedException();
        }
    }


    public string? Mask(string? input, int unmaskedChars = 4, bool unmaskFirst = false)
    {
        if (string.IsNullOrEmpty(input))
            return input;
        if (unmaskedChars == 0)
        {
            return "********";
        }

        input = Clean(input);
        if (input.Length <= unmaskedChars)
        {
            return new string('*', input.Length);
        }
        else if (unmaskFirst)
        {
            return input.Substring(0, unmaskedChars) + new string('*', input.Length - unmaskedChars);
        }
        else
        {
            return new string('*', input.Length - unmaskedChars) + input.Substring(input.Length - unmaskedChars);
        }
    }

    public string Clean(string? input)
    {
        input = input ?? string.Empty;
        input = input.Replace("\r", " ").Replace("\n", " ");
        var idx = input.IndexOf("  ");
        while (idx > -1)
        {
            input = input.Replace("  ", " ");
            idx = input.IndexOf("  ");
        }
        input = _sanitize(input) ?? "";

        //unescape ' and " and space
        input = input.Replace("'", "'");
        input = input.Replace(""", "\"");
        input = input.Replace("", " ");
        input = input.Replace("'", "'");
        input = input.Replace(""", "\"");
        input = input.Replace(" ", " ");



        return input.Trim() ?? "";
    }
}


public class HtmlSanitizer : SanitizerBase, IHtmlSanitizer
{
    public HtmlSanitizer() : base()
    {

    }
}
public class XmlSanitizer : SanitizerBase, IXmlSanitizer
{
    public XmlSanitizer() : base(HttpUtility.HtmlEncode)
    {

    }
}
public class JsonSanitizer : SanitizerBase, IJsonSanitizer
{
    public JsonSanitizer() : base(HttpUtility.JavaScriptStringEncode)
    {

    }

}
public class UrlSanitizer : SanitizerBase, IUrlSanitizer
{
    public UrlSanitizer() : base(x => Uri.EscapeUriString(x?.ToString() ?? ""))
    {

    }
}
public class CssSanitizer : SanitizerBase, ICssSanitizer
{
    public CssSanitizer() : base()
    {

    }
}
public class ScriptSanitizer : SanitizerBase, IScriptSanitizer
{
    public ScriptSanitizer() : base(x => Uri.EscapeDataString(x?.ToString() ?? ""))
    {

    }
}
public class StyleSanitizer : SanitizerBase, IStyleSanitizer
{
    public StyleSanitizer() : base()
    {

    }
}
public class SqlSanitizer : SanitizerBase, ISqlSanitizer
{
    public SqlSanitizer() : base()
    {

    }
}
public class LogSanitizer : SanitizerBase, ILogSanitizer
{
    public LogSanitizer() : base(HttpUtility.HtmlEncode)
    {

    }
    public override string? Sanitize(string? input, SanitizerMode mode)
    {
        if (input is null)
            return input;

        switch (mode)
        {
            case SanitizerMode.Debug:
                return base.Mask(input, input.Length);
            case SanitizerMode.Clean:
                return base.Clean(input);
            case SanitizerMode.Mask:
                return base.Mask(input);
            case SanitizerMode.Full:
                return base.Mask(input, 0);
            default:
                throw new NotImplementedException();
        }
    }
}
public class SanitizerFactory : ISanitizerFactory
{
    public TInputSanitizer Create() where TInputSanitizer : IInputSanitizer
    {

        var type = Enum.Parse(typeof(TInputSanitizer).Name.Substring(1));
        return (TInputSanitizer) Create(type);
    }

    public IInputSanitizer Create(SanitizerType type)
    {
        switch (type)
        {
            case SanitizerType.HtmlSanitizer:
                return new HtmlSanitizer();
            case SanitizerType.XmlSanitizer:
                return new XmlSanitizer();
            case SanitizerType.JsonSanitizer:
                return new JsonSanitizer();
            case SanitizerType.UrlSanitizer:
                return new UrlSanitizer();
            case SanitizerType.CssSanitizer:
                return new CssSanitizer();
            case SanitizerType.ScriptSanitizer:
                return new ScriptSanitizer();
            case SanitizerType.StyleSanitizer:
                return new StyleSanitizer();
            case SanitizerType.SqlSanitizer:
                return new SqlSanitizer();
            case SanitizerType.LogSanitizer:
                return new LogSanitizer();
            default:
                throw new NotImplementedException();
        }
    }
}

public interface ISanitizer
{
    public IHtmlSanitizer Html { get; }
    public IXmlSanitizer Xml { get; }
    public IJsonSanitizer Json { get; }
    public IUrlSanitizer Url { get; }
    public ICssSanitizer Css { get; }
    public IScriptSanitizer Script { get; }
    public IStyleSanitizer Style { get; }
    public ISqlSanitizer Sql { get; }
    public ILogSanitizer Log { get; }

}
public class Sanitizer : ISanitizer
{
    public Sanitizer(ISanitizerFactory sanitizerFactory)
    {
        Html = sanitizerFactory.Create();
        Xml = sanitizerFactory.Create();
        Json = sanitizerFactory.Create();
        Url = sanitizerFactory.Create();
        Css = sanitizerFactory.Create();
        Script = sanitizerFactory.Create();
        Style = sanitizerFactory.Create();
        Sql = sanitizerFactory.Create();
        Log = sanitizerFactory.Create();
    }


    public IHtmlSanitizer Html { get; }
    public IXmlSanitizer Xml { get; }
    public IJsonSanitizer Json { get; }
    public IUrlSanitizer Url { get; }
    public ICssSanitizer Css { get; }
    public IScriptSanitizer Script { get; }
    public IStyleSanitizer Style { get; }
    public ISqlSanitizer Sql { get; }
    public ILogSanitizer Log { get; }
}



================================================
FILE: src/Security/IdentityServer8.Security/SanitizerServiceExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace Microsoft.Extensions.DependencyInjection;
public static class SanitizerServiceExtensions
{
    public static IServiceCollection AddSanitizers(this IServiceCollection services)
    {
        var factory = new SanitizerFactory();
        services.AddSingleton(factory);
        services.AddSingleton(factory);
        services.AddSingleton();
        services.AddSingleton();

        var props = typeof(ISanitizer).GetProperties();
        foreach (var prop in props)
        {
            var type = Enum.Parse(prop.PropertyType.Name.Substring(1));
            var sanitizer = factory.Create(type);
            services.AddSingleton(prop.PropertyType, sanitizer);
            services.AddSingleton(sanitizer);
        }

        return services;
    }

    public static string? SanitizeForLog(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Log.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForHtml(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Html.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForXml(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Xml.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForJson(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Json.Sanitize(input?.ToString(), mode);
    }

    public static string SanitizeForRedirect(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        var rawUrl = input?.ToString() ?? "";
        if (string.IsNullOrEmpty(rawUrl))
            return rawUrl;
        else
        {
            if (Uri.TryCreate(rawUrl, UriKind.RelativeOrAbsolute, out var uri))
            {
                var parsedUrl = uri.ToString();
                if (parsedUrl == rawUrl.ToString())
                    return parsedUrl;
                else
                {
                    return uri.ToString().SanitizeForLog() ?? "";
                }

            }
            else
            {
                throw new ArgumentException("Invalid URL", nameof(input));
            }
        }

    }

    public static string? SanitizeForUrl(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Url.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForCss(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Css.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForScript(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Script.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForStyle(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Style.Sanitize(input?.ToString(), mode);
    }

    public static string? SanitizeForSql(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        return Ioc.Sanitizer.Sql.Sanitize(input?.ToString(), mode);
    }

    public static string? SantizeForRedirect(this object? input, SanitizerMode mode = SanitizerMode.Clean)
    {
        var decoded = Uri.UnescapeDataString(input?.ToString() ?? "");
        decoded.SanitizeForHtml();
        var escaped = Uri.EscapeDataString(decoded);
        return escaped;
    }

}


================================================
FILE: src/Security/test/IdentityServer8.Santizer.Tests/IdentityServer8.Sanitizer.Tests.csproj
================================================


  
    false
  

  
    
    
    
    
     
    
      runtime; build; native; contentfiles; analyzers; buildtransitive
      all
       
  

  
    
  
  
  




================================================
FILE: src/Security/test/IdentityServer8.Santizer.Tests/RedirectServiceTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using Microsoft.Extensions.DependencyInjection;
using Xunit;


namespace IdentityServer8.Security.Tests;

public class DependencyInjection
{
    static DependencyInjection()
    {
        var provider = new ServiceCollection()
            .AddLogging()
            .AddAllowAnyRedirectService()
            .AddSingleton()
            .AddSanitizers()
            .BuildServiceProvider();
        ServiceProvider = provider;

    }

    public static ServiceProvider ServiceProvider { get; }
}



public class AllowAnyTests 
{
    private readonly RedirectService _redirectService;

    public AllowAnyTests()
    {
        var redirectService = DependencyInjection.ServiceProvider.GetRequiredService();
        _redirectService = redirectService;
    }


    [Theory]
    [InlineData("http://example.com",  true)]
    [InlineData("http://a.example.com", true)]
    [InlineData("http://a.b.example.com", true)]
    [InlineData("https://example.com", true)]
    [InlineData("https://a.example.com", true)]
    [InlineData("https://a.b.example.com", true)]
    [InlineData("http://localhost", true)]
    [InlineData("https://localhost", true)]




    public void AllowAnyShouldReturnTrue(string uriString, bool expectedResult)
    {
        var result = _redirectService.IsRedirectAllowed(uriString);

        Assert.Equal(expectedResult, result);
    }
}
public class RedirectServiceTests
{
    private readonly RedirectService _redirectService;

    public RedirectServiceTests()
    {
        var redirectService = DependencyInjection.ServiceProvider.GetService();
        _redirectService = redirectService as RedirectService;
    }

    [Theory]
    [InlineData("http://example.com", "example.com", true)]
    [InlineData("http://example.com", "*", true)]
    [InlineData("http://example.com", "another.com", false)]
    [InlineData("example.com", "example.com", true)]
    [InlineData("example.com", "*", true)]
    [InlineData("example.com", "another.com", false)]
    [InlineData("*.example.com", "example.com", false)]
    [InlineData("*.example.com", "*", true)]
    [InlineData("*.example.com", "another.com", false)]
    public void IsHostMatch_ShouldCorrectlyMatchHost(string uriString, string allowedHostName, bool expectedResult)
    {

        var allowedHost = allowedHostName == "*" ? Host.Any : Host.Create(allowedHostName);

        // Assuming IsHostMatch is made internal for testing and accessible here
        var result = _redirectService.IsHostMatch(uriString, allowedHost);

        Assert.Equal(expectedResult, result);
    }

    [Fact()]
    public void RedirectServiceTest()
    {

    }

    [Fact()]
    public void AddARedirectRuleTest()
    {

    }

    [Fact()]
    public void IsRedirectAllowedTest()
    {

    }
}


================================================
FILE: src/Security/test/IdentityServer8.Santizer.Tests/Services/SanitizerTests.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

using FluentAssertions;
using Microsoft.Extensions.DependencyInjection;
using System.Diagnostics;
using System.Text.Json;
using Xunit;

namespace IdentityServer8.Security.Tests;


public class SanitizerTests
{
    public SanitizerTests()
    {

    }


    [Fact]
    public void SanitizerFactory()
    {
        var factory = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(factory);
    }

    [Fact]
    public void SanitizerService()
    {
        var service = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(service);
    }
    [Fact]
    public void Sanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);
    }


    [Fact]
    public void HtmlSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = "
    ";
        var output = sanitizer.Sanitize(input);
        var expected = "<div><script>alert('xss')</script></div>";

        Validate(expected, output);
    }
    [Fact]
    public void XmlSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = "
    ";
        var output = sanitizer.Sanitize(input);
        var expected = "<div><script>alert('xss')</script></div>";

        Validate(expected, output);
    }
    [Fact]
    public void JsonSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = JsonSerializer.Serialize(new { test = "test", value = "
    " });
        var output = sanitizer.Sanitize(input);
        var expected = @"{\""test\"":\""test\"",\""value\"":\""\\u003Cdiv\\u003E\\u003Cscript\\u003Ealert(\\u0027xss\\u0027)\\u003C/script\\u003E\\u003C/div\\u003E\""}";


        Validate(expected, output);
    }
    [Fact]
    public void UrlSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = "http://test.com?test=
    ";
        var output = sanitizer.Sanitize(input);
        var expected = "http://test.com?test=%3Cdiv%3E%3Cscript%3Ealert('xss')%3C/script%3E%3C/div%3E";

        Validate(expected, output);
    }
    [Fact]
    public void CssSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = "div { background-url('') }";
        var output = sanitizer.Sanitize(input);
        var expected = "div { background-url('<script>alert('xss')</script>') }";
        Validate(expected, output);
    }
    [Fact]
    public void ScriptSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = JsonSerializer.Serialize(new { test = "test", value = "
    " });
        var output = sanitizer.Sanitize(input);
        var expected = @"{\""test\"":\""test\"",\""value\"":\""\\u003Cdiv\\u003E\\u003Cscript\\u003Ealert(\\u0027xss\\u0027)\\u003C/script\\u003E\\u003C/div\\u003E\""}";


        Validate(expected, output);
    }
    [Fact]
    public void StyleSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);
        var input = "div { background-url('') }";
        var output = sanitizer.Sanitize(input);
        var expected = "div { background-url('<script>alert('xss')</script>') }";

        Validate(expected, output);
    }
    [Fact]
    public void SqlSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = "update table set value='' where 1=1;";
        var output = sanitizer.Sanitize(input);
        var expected = "update table set value='<script>alert('xss')</script>' where 1=1;";

        Validate(expected, output);
    }
    [Fact]
    public void LogSanitizer()
    {
        var sanitizer = Ioc.ServiceProvider.GetRequiredService();
        Assert.NotNull(sanitizer);

        var input = @"log
poisoning
test


";
        var output = sanitizer.Sanitize(input);


        var expected = "log poisoning test <script>alert('xss')</script>";
        Validate(expected, output);


        output = sanitizer.Sanitize("mypassword", SanitizerMode.Mask);
        expected = "******word";
        Validate(expected, output);


        output = sanitizer.Sanitize("mypassword", SanitizerMode.Full);
        expected = "********";
        Validate(expected, output);

    }

    void Validate(string expected, string output)
    {
        Console.WriteLine("Expected: " + expected);
        Console.WriteLine("Output: " + output);
        Debug.WriteLine("Expected: " + expected);
        Debug.WriteLine("Output: " + output);
        output.Should().Be(expected);
    }

    private void Log(string expected, string output)
    {
        Console.WriteLine("Expected: " + expected);
        Console.WriteLine("Output: " + output);
        Debug.WriteLine("Expected: " + expected);
        Debug.WriteLine("Output: " + output);
    }
}


================================================
FILE: src/Storage/Directory.Build.props
================================================

  
	 
  


================================================
FILE: src/Storage/IdentityServer8.Storage.sln
================================================

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio 15
VisualStudioVersion = 15.0.26124.0
MinimumVisualStudioVersion = 15.0.26124.0
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{2EEC146C-3C96-4871-BBAF-8341719BD533}"
EndProject
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "IdentityServer8.Storage", "src\IdentityServer8.Storage.csproj", "{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}"
EndProject
Global
	GlobalSection(SolutionConfigurationPlatforms) = preSolution
		Debug|Any CPU = Debug|Any CPU
		Debug|x64 = Debug|x64
		Debug|x86 = Debug|x86
		Release|Any CPU = Release|Any CPU
		Release|x64 = Release|x64
		Release|x86 = Release|x86
	EndGlobalSection
	GlobalSection(ProjectConfigurationPlatforms) = postSolution
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|Any CPU.Build.0 = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|x64.ActiveCfg = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|x64.Build.0 = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|x86.ActiveCfg = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Debug|x86.Build.0 = Debug|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|Any CPU.ActiveCfg = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|Any CPU.Build.0 = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|x64.ActiveCfg = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|x64.Build.0 = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|x86.ActiveCfg = Release|Any CPU
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7}.Release|x86.Build.0 = Release|Any CPU
	EndGlobalSection
	GlobalSection(SolutionProperties) = preSolution
		HideSolutionNode = FALSE
	EndGlobalSection
	GlobalSection(NestedProjects) = preSolution
		{A5E2B0DD-9C88-42B5-BCEC-7ED701504FF7} = {2EEC146C-3C96-4871-BBAF-8341719BD533}
	EndGlobalSection
	GlobalSection(ExtensibilityGlobals) = postSolution
		SolutionGuid = {AFF22F24-FEA5-4A1D-AFE6-942789486D59}
	EndGlobalSection
EndGlobal


================================================
FILE: src/Storage/README.md
================================================
# IdentityServer8.Storage

IdentityServer8.Storage contains all the models and storage interfaces for IdentityServer 4 configuration data.

================================================
FILE: src/Storage/build/Program.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace build
{
    partial class Program
    {
        private const string Prefix = "Storage";
    }
}


================================================
FILE: src/Storage/build/build.csproj
================================================


  
    Exe
  

  
    
  

  
    
    
  
  



================================================
FILE: src/Storage/build.cmd
================================================
@echo off
dotnet run --project build -- %*

================================================
FILE: src/Storage/build.ps1
================================================
$ErrorActionPreference = "Stop";
dotnet run --project build -- $args

================================================
FILE: src/Storage/build.sh
================================================
#!/usr/bin/env bash
set -euo pipefail
dotnet run --project build -- "$@"

================================================
FILE: src/Storage/src/Constants.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

internal static class Constants
{
    public const string IdentityServerName               = "IdentityServer8";
    public const string IdentityServerAuthenticationType = IdentityServerName;
}


================================================
FILE: src/Storage/src/Extensions/IEnumerableExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Extensions;

internal static class IEnumerableExtensions
{
    [DebuggerStepThrough]
    public static bool IsNullOrEmpty(this IEnumerable list)
    {
        if (list == null)
        {
            return true;
        }

        if (!list.Any())
        {
            return true;
        }

        return false;
    }
}


================================================
FILE: src/Storage/src/Extensions/PersistedGrantFilterExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

/// 
/// Extensions for PersistedGrantFilter.
/// 
public static class PersistedGrantFilterExtensions
{
    /// 
    /// Validates the PersistedGrantFilter and throws if invalid.
    /// 
    /// 
    public static void Validate(this PersistedGrantFilter filter)
    {
        if (filter == null) throw new ArgumentNullException(nameof(filter));

        if (String.IsNullOrWhiteSpace(filter.ClientId) &&
            String.IsNullOrWhiteSpace(filter.SessionId) &&
            String.IsNullOrWhiteSpace(filter.SubjectId) &&
            String.IsNullOrWhiteSpace(filter.Type))
        {
            throw new ArgumentException("No filter values set.", nameof(filter));
        }
    }
}


================================================
FILE: src/Storage/src/Extensions/StringsExtensions.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Extensions;

internal static class StringExtensions
{
    [DebuggerStepThrough]
    public static bool IsMissing(this string value)
    {
        return string.IsNullOrWhiteSpace(value);
    }

    [DebuggerStepThrough]
    public static bool IsPresent(this string value)
    {
        return !string.IsNullOrWhiteSpace(value);
    }
}


================================================
FILE: src/Storage/src/GlobalUsings.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

global using IdentityModel;
global using IdentityServer8.Extensions;
global using IdentityServer8.Models;
global using IdentityServer8.Stores;
global using Newtonsoft.Json;
global using Newtonsoft.Json.Serialization;
global using System.Collections;
global using System.Diagnostics;
global using System.Security.Claims;


================================================
FILE: src/Storage/src/IdentityServer8.Storage.csproj
================================================


    

        Storage interfaces and models for IdentityServer8
        true
        True
    

    
        True
        True

    

    
      
        True
        \
      
    


    
        
        
    



================================================
FILE: src/Storage/src/IdentityServerConstants.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8;

internal static class IdentityServerConstants
{
    public static class ProtocolTypes
    {
        public const string OpenIdConnect = "oidc";
    }

    public static class SecretTypes
    {
        public const string SharedSecret = "SharedSecret";
    }
}


================================================
FILE: src/Storage/src/IdentityServerUser.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8;

/// 
/// Model properties of an IdentityServer user
/// 
internal class IdentityServerUser
{
    /// 
    /// Subject ID (mandatory)
    /// 
    public string SubjectId { get; }

    /// 
    /// Display name (optional)
    /// 
    public string DisplayName { get; set; }

    /// 
    /// Identity provider (optional)
    /// 
    public string IdentityProvider { get; set; }

    /// 
    /// Authentication methods
    /// 
    public ICollection AuthenticationMethods { get; set; } = new HashSet();

    /// 
    /// Authentication time
    /// 
    public DateTime? AuthenticationTime { get; set; }

    /// 
    /// Additional claims
    /// 
    public ICollection AdditionalClaims { get; set; } = new HashSet(new ClaimComparer());

    /// 
    /// Initializes a user identity
    /// 
    /// The subject ID
    public IdentityServerUser(string subjectId)
    {
        if (subjectId.IsMissing()) throw new ArgumentException("SubjectId is mandatory", nameof(subjectId));

        SubjectId = subjectId;
    }

    /// 
    /// Creates an IdentityServer claims principal
    /// 
    /// 
    /// 
    public ClaimsPrincipal CreatePrincipal()
    {
        if (SubjectId.IsMissing()) throw new ArgumentException("SubjectId is mandatory", nameof(SubjectId));
        var claims = new List { new Claim(JwtClaimTypes.Subject, SubjectId) };

        if (DisplayName.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.Name, DisplayName));
        }

        if (IdentityProvider.IsPresent())
        {
            claims.Add(new Claim(JwtClaimTypes.IdentityProvider, IdentityProvider));
        }

        if (AuthenticationTime.HasValue)
        {
            claims.Add(new Claim(JwtClaimTypes.AuthenticationTime, new DateTimeOffset(AuthenticationTime.Value).ToUnixTimeSeconds().ToString()));
        }

        if (AuthenticationMethods.Any())
        {
            foreach (var amr in AuthenticationMethods)
            {
                claims.Add(new Claim(JwtClaimTypes.AuthenticationMethod, amr));
            }
        }

        claims.AddRange(AdditionalClaims);

        var id = new ClaimsIdentity(claims.Distinct(new ClaimComparer()), Constants.IdentityServerAuthenticationType, JwtClaimTypes.Name, JwtClaimTypes.Role);
        return new ClaimsPrincipal(id);
    }
}


================================================
FILE: src/Storage/src/Models/ApiResource.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a web API resource.
/// 
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
public class ApiResource : Resource
{
    private string DebuggerDisplay => Name ?? $"{{{typeof(ApiResource)}}}";
    
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public ApiResource()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    public ApiResource(string name)
        : this(name, name, null)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// The display name.
    public ApiResource(string name, string displayName)
        : this(name, displayName, null)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// List of associated user claims that should be included when this resource is requested.
    public ApiResource(string name, IEnumerable userClaims)
        : this(name, name, userClaims)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// The display name.
    /// List of associated user claims that should be included when this resource is requested.
    /// name
    public ApiResource(string name, string displayName, IEnumerable userClaims)
    {
        if (name.IsMissing()) throw new ArgumentNullException(nameof(name));

        Name = name;
        DisplayName = displayName;

        if (!userClaims.IsNullOrEmpty())
        {
            foreach (var type in userClaims)
            {
                UserClaims.Add(type);
            }
        }
    }

    /// 
    /// The API secret is used for the introspection endpoint. The API can authenticate with introspection using the API name and secret.
    /// 
    public ICollection ApiSecrets { get; set; } = new HashSet();

    /// 
    /// Models the scopes this API resource allows.
    /// 
    public ICollection Scopes { get; set; } = new HashSet();

    /// 
    /// Signing algorithm for access token. If empty, will use the server default signing algorithm.
    /// 
    public ICollection AllowedAccessTokenSigningAlgorithms { get; set; } = new HashSet();
}


================================================
FILE: src/Storage/src/Models/ApiScope.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models access to an API scope
/// 
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
public class ApiScope : Resource
{
    private string DebuggerDisplay => Name ?? $"{{{typeof(ApiScope)}}}";
    
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public ApiScope()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    public ApiScope(string name)
        : this(name, name, null)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// The display name.
    public ApiScope(string name, string displayName)
        : this(name, displayName, null)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// List of associated user claims that should be included when this resource is requested.
    public ApiScope(string name, IEnumerable userClaims)
        : this(name, name, userClaims)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// The display name.
    /// List of associated user claims that should be included when this resource is requested.
    /// name
    public ApiScope(string name, string displayName, IEnumerable userClaims)
    {
        if (name.IsMissing()) throw new ArgumentNullException(nameof(name));

        Name = name;
        DisplayName = displayName;

        if (!userClaims.IsNullOrEmpty())
        {
            foreach (var type in userClaims)
            {
                UserClaims.Add(type);
            }
        }
    }

    /// 
    /// Specifies whether the user can de-select the scope on the consent screen. Defaults to false.
    /// 
    public bool Required { get; set; } = false;

    /// 
    /// Specifies whether the consent screen will emphasize this scope. Use this setting for sensitive or important scopes. Defaults to false.
    /// 
    public bool Emphasize { get; set; } = false;
}


================================================
FILE: src/Storage/src/Models/AuthorizationCode.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models an authorization code.
/// 
public class AuthorizationCode
{
    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the life time in seconds.
    /// 
    /// 
    /// The life time.
    /// 
    public int Lifetime { get; set; }

    /// 
    /// Gets or sets the ID of the client.
    /// 
    /// 
    /// The ID of the client.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets a value indicating whether this code is an OpenID Connect code.
    /// 
    /// 
    /// true if this instance is open identifier; otherwise, false.
    /// 
    public bool IsOpenId { get; set; }
    
    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The requested scopes.
    /// 
    // todo: brock, change to parsed scopes
    public IEnumerable RequestedScopes { get; set; }

    /// 
    /// Gets or sets the redirect URI.
    /// 
    /// 
    /// The redirect URI.
    /// 
    public string RedirectUri { get; set; }

    /// 
    /// Gets or sets the nonce.
    /// 
    /// 
    /// The nonce.
    /// 
    public string Nonce { get; set; }

    /// 
    /// Gets or sets the hashed state (to output s_hash claim).
    /// 
    /// 
    /// The hashed state.
    /// 
    public string StateHash { get; set; }

    /// 
    /// Gets or sets a value indicating whether consent was shown.
    /// 
    /// 
    ///   true if consent was shown; otherwise, false.
    /// 
    public bool WasConsentShown { get; set; }

    /// 
    /// Gets or sets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId { get; set; }

    /// 
    /// Gets or sets the code challenge.
    /// 
    /// 
    /// The code challenge.
    /// 
    public string CodeChallenge { get; set; }

    /// 
    /// Gets or sets the code challenge method.
    /// 
    /// 
    /// The code challenge method
    /// 
    public string CodeChallengeMethod { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets properties
    /// 
    /// 
    /// The properties
    /// 
    public IDictionary Properties { get; set; } = new Dictionary();
}


================================================
FILE: src/Storage/src/Models/Client.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models an OpenID Connect or OAuth2 client
/// 
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
public class Client
{
    // setting grant types should be atomic
    private ICollection _allowedGrantTypes = new GrantTypeValidatingHashSet();

    private string DebuggerDisplay => ClientId ?? $"{{{typeof(Client)}}}";

    /// 
    /// Specifies if client is enabled (defaults to true)
    /// 
    public bool Enabled { get; set; } = true;

    /// 
    /// Unique ID of the client
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the protocol type.
    /// 
    /// 
    /// The protocol type.
    /// 
    public string ProtocolType { get; set; } = IdentityServerConstants.ProtocolTypes.OpenIdConnect;

    /// 
    /// Client secrets - only relevant for flows that require a secret
    /// 
    public ICollection ClientSecrets { get; set; } = new HashSet();

    /// 
    /// If set to false, no client secret is needed to request tokens at the token endpoint (defaults to true)
    /// 
    public bool RequireClientSecret { get; set; } = true;

    /// 
    /// Client display name (used for logging and consent screen)
    /// 
    public string ClientName { get; set; }

    /// 
    /// Description of the client.
    /// 
    public string Description { get; set; }

    /// 
    /// URI to further information about client (used on consent screen)
    /// 
    public string ClientUri { get; set; }

    /// 
    /// URI to client logo (used on consent screen)
    /// 
    public string LogoUri { get; set; }

    /// 
    /// Specifies whether a consent screen is required (defaults to false)
    /// 
    public bool RequireConsent { get; set; } = false;

    /// 
    /// Specifies whether user can choose to store consent decisions (defaults to true)
    /// 
    public bool AllowRememberConsent { get; set; } = true;

    /// 
    /// Specifies the allowed grant types (legal combinations of AuthorizationCode, Implicit, Hybrid, ResourceOwner, ClientCredentials).
    /// 
    public ICollection AllowedGrantTypes
    {
        get { return _allowedGrantTypes; }
        set
        {
            ValidateGrantTypes(value);
            _allowedGrantTypes = new GrantTypeValidatingHashSet(value);
        }
    }

    /// 
    /// Specifies whether a proof key is required for authorization code based token requests (defaults to true).
    /// 
    public bool RequirePkce { get; set; } = true;

    /// 
    /// Specifies whether a proof key can be sent using plain method (not recommended and defaults to false.)
    /// 
    public bool AllowPlainTextPkce { get; set; } = false;

    /// 
    /// Specifies whether the client must use a request object on authorize requests (defaults to false.)
    /// 
    public bool RequireRequestObject { get; set; } = false;
    
    /// 
    /// Controls whether access tokens are transmitted via the browser for this client (defaults to false).
    /// This can prevent accidental leakage of access tokens when multiple response types are allowed.
    /// 
    /// 
    /// true if access tokens can be transmitted via the browser; otherwise, false.
    /// 
    public bool AllowAccessTokensViaBrowser { get; set; } = false;

    /// 
    /// Specifies allowed URIs to return tokens or authorization codes to
    /// 
    public ICollection RedirectUris { get; set; } = new HashSet();

    /// 
    /// Specifies allowed URIs to redirect to after logout
    /// 
    public ICollection PostLogoutRedirectUris { get; set; } = new HashSet();

    /// 
    /// Specifies logout URI at client for HTTP front-channel based logout.
    /// 
    public string FrontChannelLogoutUri { get; set; }

    /// 
    /// Specifies if the user's session id should be sent to the FrontChannelLogoutUri. Defaults to true.
    /// 
    public bool FrontChannelLogoutSessionRequired { get; set; } = true;

    /// 
    /// Specifies logout URI at client for HTTP back-channel based logout.
    /// 
    public string BackChannelLogoutUri { get; set; }

    /// 
    /// Specifies if the user's session id should be sent to the BackChannelLogoutUri. Defaults to true.
    /// 
    public bool BackChannelLogoutSessionRequired { get; set; } = true;

    /// 
    /// Gets or sets a value indicating whether [allow offline access]. Defaults to false.
    /// 
    public bool AllowOfflineAccess { get; set; } = false;

    /// 
    /// Specifies the api scopes that the client is allowed to request. If empty, the client can't access any scope
    /// 
    public ICollection AllowedScopes { get; set; } = new HashSet();

    /// 
    /// When requesting both an id token and access token, should the user claims always be added to the id token instead of requiring the client to use the userinfo endpoint.
    /// Defaults to false.
    /// 
    public bool AlwaysIncludeUserClaimsInIdToken { get; set; } = false;

    /// 
    /// Lifetime of identity token in seconds (defaults to 300 seconds / 5 minutes)
    /// 
    public int IdentityTokenLifetime { get; set; } = 300;

    /// 
    /// Signing algorithm for identity token. If empty, will use the server default signing algorithm.
    /// 
    public ICollection AllowedIdentityTokenSigningAlgorithms { get; set; } = new HashSet();

    /// 
    /// Lifetime of access token in seconds (defaults to 3600 seconds / 1 hour)
    /// 
    public int AccessTokenLifetime { get; set; } = 3600;

    /// 
    /// Lifetime of authorization code in seconds (defaults to 300 seconds / 5 minutes)
    /// 
    public int AuthorizationCodeLifetime { get; set; } = 300;

    /// 
    /// Maximum lifetime of a refresh token in seconds. Defaults to 2592000 seconds / 30 days
    /// 
    public int AbsoluteRefreshTokenLifetime { get; set; } = 2592000;

    /// 
    /// Sliding lifetime of a refresh token in seconds. Defaults to 1296000 seconds / 15 days
    /// 
    public int SlidingRefreshTokenLifetime { get; set; } = 1296000;

    /// 
    /// Lifetime of a user consent in seconds. Defaults to null (no expiration)
    /// 
    public int? ConsentLifetime { get; set; } = null;

    /// 
    /// ReUse: the refresh token handle will stay the same when refreshing tokens
    /// OneTime: the refresh token handle will be updated when refreshing tokens
    /// 
    public TokenUsage RefreshTokenUsage { get; set; } = TokenUsage.OneTimeOnly;

    /// 
    /// Gets or sets a value indicating whether the access token (and its claims) should be updated on a refresh token request.
    /// Defaults to false.
    /// 
    /// 
    /// true if the token should be updated; otherwise, false.
    /// 
    public bool UpdateAccessTokenClaimsOnRefresh { get; set; } = false;

    /// 
    /// Absolute: the refresh token will expire on a fixed point in time (specified by the AbsoluteRefreshTokenLifetime)
    /// Sliding: when refreshing the token, the lifetime of the refresh token will be renewed (by the amount specified in SlidingRefreshTokenLifetime). The lifetime will not exceed AbsoluteRefreshTokenLifetime.
    ///         
    public TokenExpiration RefreshTokenExpiration { get; set; } = TokenExpiration.Absolute;

    /// 
    /// Specifies whether the access token is a reference token or a self contained JWT token (defaults to Jwt).
    /// 
    public AccessTokenType AccessTokenType { get; set; } = AccessTokenType.Jwt;

    /// 
    /// Gets or sets a value indicating whether the local login is allowed for this client. Defaults to true.
    /// 
    /// 
    ///   true if local logins are enabled; otherwise, false.
    /// 
    public bool EnableLocalLogin { get; set; } = true;

    /// 
    /// Specifies which external IdPs can be used with this client (if list is empty all IdPs are allowed). Defaults to empty.
    /// 
    public ICollection IdentityProviderRestrictions { get; set; } = new HashSet();

    /// 
    /// Gets or sets a value indicating whether JWT access tokens should include an identifier. Defaults to true.
    /// 
    /// 
    /// true to add an id; otherwise, false.
    /// 
    public bool IncludeJwtId { get; set; } = true;

    /// 
    /// Allows settings claims for the client (will be included in the access token).
    /// 
    /// 
    /// The claims.
    /// 
    public ICollection Claims { get; set; } = new HashSet();

    /// 
    /// Gets or sets a value indicating whether client claims should be always included in the access tokens - or only for client credentials flow.
    /// Defaults to false
    /// 
    /// 
    /// true if claims should always be sent; otherwise, false.
    /// 
    public bool AlwaysSendClientClaims { get; set; } = false;

    /// 
    /// Gets or sets a value to prefix it on client claim types. Defaults to client_.
    /// 
    /// 
    /// Any non empty string if claims should be prefixed with the value; otherwise, null.
    /// 
    public string ClientClaimsPrefix { get; set; } = "client_";

    /// 
    /// Gets or sets a salt value used in pair-wise subjectId generation for users of this client.
    /// 
    public string PairWiseSubjectSalt { get; set; }

    /// 
    /// The maximum duration (in seconds) since the last time the user authenticated.
    /// 
    public int? UserSsoLifetime { get; set; }

    /// 
    /// Gets or sets the type of the device flow user code.
    /// 
    /// 
    /// The type of the device flow user code.
    /// 
    public string UserCodeType { get; set; }

    /// 
    /// Gets or sets the device code lifetime.
    /// 
    /// 
    /// The device code lifetime.
    /// 
    public int DeviceCodeLifetime { get; set; } = 300;

    /// 
    /// Gets or sets the allowed CORS origins for JavaScript clients.
    /// 
    /// 
    /// The allowed CORS origins.
    /// 
    public ICollection AllowedCorsOrigins { get; set; } = new HashSet();

    /// 
    /// Gets or sets the custom properties for the client.
    /// 
    /// 
    /// The properties.
    /// 
    public IDictionary Properties { get; set; } = new Dictionary();

    /// 
    /// Validates the grant types.
    /// 
    /// The grant types.
    /// 
    /// Grant types list is empty
    /// or
    /// Grant types cannot contain spaces
    /// or
    /// Grant types list contains duplicate values
    /// 
    public static void ValidateGrantTypes(IEnumerable grantTypes)
    {
        if (grantTypes == null)
        {
            throw new ArgumentNullException(nameof(grantTypes));
        }

        // spaces are not allowed in grant types
        foreach (var type in grantTypes)
        {
            if (type.Contains(' '))
            {
                throw new InvalidOperationException("Grant types cannot contain spaces");
            }
        }

        // single grant type, seems to be fine
        if (grantTypes.Count() == 1) return;

        // don't allow duplicate grant types
        if (grantTypes.Count() != grantTypes.Distinct().Count())
        {
            throw new InvalidOperationException("Grant types list contains duplicate values");
        }

        // would allow response_type downgrade attack from code to token
        DisallowGrantTypeCombination(GrantType.Implicit, GrantType.AuthorizationCode, grantTypes);
        DisallowGrantTypeCombination(GrantType.Implicit, GrantType.Hybrid, grantTypes);

        DisallowGrantTypeCombination(GrantType.AuthorizationCode, GrantType.Hybrid, grantTypes);
    }

    private static void DisallowGrantTypeCombination(string value1, string value2, IEnumerable grantTypes)
    {
        if (grantTypes.Contains(value1, StringComparer.Ordinal) &&
            grantTypes.Contains(value2, StringComparer.Ordinal))
        {
            throw new InvalidOperationException($"Grant types list cannot contain both {value1} and {value2}");
        }
    }

    internal class GrantTypeValidatingHashSet : ICollection
    {
        private readonly ICollection _inner;

        public GrantTypeValidatingHashSet()
        {
            _inner = new HashSet();
        }

        public GrantTypeValidatingHashSet(IEnumerable values)
        {
            _inner = new HashSet(values);
        }

        private ICollection Clone()
        {
            return new HashSet(this);
        }

        private ICollection CloneWith(params string[] values)
        {
            var clone = Clone();
            foreach (var item in values) clone.Add(item);
            return clone;
        }

        public int Count => _inner.Count;

        public bool IsReadOnly => _inner.IsReadOnly;

        public void Add(string item)
        {
            ValidateGrantTypes(CloneWith(item));
            _inner.Add(item);
        }

        public void Clear()
        {
            _inner.Clear();
        }

        public bool Contains(string item)
        {
            return _inner.Contains(item);
        }

        public void CopyTo(string[] array, int arrayIndex)
        {
            _inner.CopyTo(array, arrayIndex);
        }

        public IEnumerator GetEnumerator()
        {
            return _inner.GetEnumerator();
        }

        public bool Remove(string item)
        {
            return _inner.Remove(item);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return _inner.GetEnumerator();
        }
    }
}


================================================
FILE: src/Storage/src/Models/ClientClaim.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// A client claim
/// 
public class ClientClaim
{
    /// 
    /// The claim type
    /// 
    public string Type { get; set; }
    
    /// 
    /// The claim value
    /// 
    public string Value { get; set; }

    /// 
    /// The claim value type
    /// 
    public string ValueType { get; set; } = ClaimValueTypes.String;

    /// 
    /// ctor
    /// 
    public ClientClaim()
    {
    }

    /// 
    /// ctor
    /// 
    /// 
    /// 
    public ClientClaim(string type, string value)
    {
        Type = type;
        Value = value;
    }

    /// 
    /// ctor
    /// 
    /// 
    /// 
    /// 
    public ClientClaim(string type, string value, string valueType)
    {
        Type = type;
        Value = value;
        ValueType = valueType;
    }

    /// 
    public override int GetHashCode()
    {
        unchecked 
        {
            int hash = 17;

            hash = hash * 23 + Value.GetHashCode();
            hash = hash * 23 + Type.GetHashCode();
            hash = hash * 23 + ValueType.GetHashCode();
            return hash;
        }
    }

    /// 
    public override bool Equals(object obj)
    {
        if (obj is null) return false;
        if (obj is ClientClaim c)
        {
            return (string.Equals(Type, c.Type, StringComparison.Ordinal) &&
                    string.Equals(Value, c.Value, StringComparison.Ordinal) &&
                    string.Equals(ValueType, c.ValueType, StringComparison.Ordinal));
        }

        return false;
    }
}


================================================
FILE: src/Storage/src/Models/Consent.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Represents the permissions (in terms of scopes) granted to a client by a subject
/// 
public class Consent
{
    /// 
    /// Gets or sets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }
    
    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }
    
    /// 
    /// Gets or sets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable Scopes { get; set; }

    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the expiration.
    /// 
    /// 
    /// The expiration.
    /// 
    public DateTime? Expiration { get; set; }
}


================================================
FILE: src/Storage/src/Models/DeviceCode.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Represents data needed for device flow.
/// 
public class DeviceCode
{
    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the lifetime.
    /// 
    /// 
    /// The lifetime.
    /// 
    public int Lifetime { get; set; }

    /// 
    /// Gets or sets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets a value indicating whether this instance is open identifier.
    /// 
    /// 
    ///   true if this instance is open identifier; otherwise, false.
    /// 
    public bool IsOpenId { get; set; }

    /// 
    /// Gets or sets a value indicating whether this instance is authorized.
    /// 
    /// 
    ///   true if this instance is authorized; otherwise, false.
    /// 
    public bool IsAuthorized { get; set; }

    /// 
    /// Gets or sets the requested scopes.
    /// 
    /// 
    /// The authorized scopes.
    /// 
    public IEnumerable RequestedScopes { get; set; }

    /// 
    /// Gets or sets the authorized scopes.
    /// 
    /// 
    /// The authorized scopes.
    /// 
    public IEnumerable AuthorizedScopes { get; set; }

    /// 
    /// Gets or sets the subject.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject { get; set; }

    /// 
    /// Gets or sets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId { get; set; }
}


================================================
FILE: src/Storage/src/Models/Enums.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// OpenID Connect subject types.
/// 
public enum SubjectTypes
{
    /// 
    /// global - use the native subject id
    /// 
    Global = 0,

    /// 
    /// ppid - scope the subject id to the client
    /// 
    Ppid = 1
}

/// 
/// Access token types.
/// 
public enum AccessTokenType
{
    /// 
    /// Self-contained Json Web Token
    /// 
    Jwt = 0,

    /// 
    /// Reference token
    /// 
    Reference = 1
}

/// 
/// Token usage types.
/// 
public enum TokenUsage
{
    /// 
    /// Re-use the refresh token handle
    /// 
    ReUse = 0,

    /// 
    /// Issue a new refresh token handle every time
    /// 
    OneTimeOnly = 1
}

/// 
/// Token expiration types.
/// 
public enum TokenExpiration
{
    /// 
    /// Sliding token expiration
    /// 
    Sliding = 0,

    /// 
    /// Absolute token expiration
    /// 
    Absolute = 1
}

/// 
/// Content Security Policy Level
/// 
public enum CspLevel
{
    /// 
    /// Level 1
    /// 
    One = 0,

    /// 
    /// Level 2
    /// 
    Two = 1
}


================================================
FILE: src/Storage/src/Models/GrantType.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Models;

public static class GrantType
{
    public const string Implicit = "implicit";
    public const string Hybrid = "hybrid";
    public const string AuthorizationCode = "authorization_code";
    public const string ClientCredentials = "client_credentials";
    public const string ResourceOwnerPassword = "password";
    public const string DeviceFlow = "urn:ietf:params:oauth:grant-type:device_code";
}


================================================
FILE: src/Storage/src/Models/IdentityResource.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a user identity resource.
/// 
[DebuggerDisplay("{" + nameof(DebuggerDisplay) + ",nq}")]
public class IdentityResource : Resource
{
    private string DebuggerDisplay => Name ?? $"{{{typeof(IdentityResource)}}}";
    
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public IdentityResource()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// List of associated user claims that should be included when this resource is requested.
    public IdentityResource(string name, IEnumerable userClaims)
        : this(name, name, userClaims)
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The name.
    /// The display name.
    /// List of associated user claims that should be included when this resource is requested.
    /// name
    /// Must provide at least one claim type - claimTypes
    public IdentityResource(string name, string displayName, IEnumerable userClaims)
    {
        if (name.IsMissing()) throw new ArgumentNullException(nameof(name));
        if (userClaims.IsNullOrEmpty()) throw new ArgumentException("Must provide at least one claim type", nameof(userClaims));

        Name = name;
        DisplayName = displayName;

        foreach(var type in userClaims)
        {
            UserClaims.Add(type);
        }
    }

    /// 
    /// Specifies whether the user can de-select the scope on the consent screen (if the consent screen wants to implement such a feature). Defaults to false.
    /// 
    public bool Required { get; set; } = false;

    /// 
    /// Specifies whether the consent screen will emphasize this scope (if the consent screen wants to implement such a feature). 
    /// Use this setting for sensitive or important scopes. Defaults to false.
    /// 
    public bool Emphasize { get; set; } = false;
}


================================================
FILE: src/Storage/src/Models/PersistedGrant.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// A model for a persisted grant
/// 
public class PersistedGrant
{
    /// 
    /// Gets or sets the key.
    /// 
    /// 
    /// The key.
    /// 
    public string Key { get; set; }

    /// 
    /// Gets the type.
    /// 
    /// 
    /// The type.
    /// 
    public string Type { get; set; }

    /// 
    /// Gets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId { get; set; }

    /// 
    /// Gets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId { get; set; }
    
    /// 
    /// Gets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the expiration.
    /// 
    /// 
    /// The expiration.
    /// 
    public DateTime? Expiration { get; set; }
    
    /// 
    /// Gets or sets the consumed time.
    /// 
    /// 
    /// The consumed time.
    /// 
    public DateTime? ConsumedTime { get; set; }

    /// 
    /// Gets or sets the data.
    /// 
    /// 
    /// The data.
    /// 
    public string Data { get; set; }
}


================================================
FILE: src/Storage/src/Models/RefreshToken.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a refresh token.
/// 
public class RefreshToken
{
    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }

    /// 
    /// Gets or sets the life time.
    /// 
    /// 
    /// The life time.
    /// 
    public int Lifetime { get; set; }

    /// 
    /// Gets or sets the consumed time.
    /// 
    /// 
    /// The consumed time.
    /// 
    public DateTime? ConsumedTime { get; set; }

    /// 
    /// Gets or sets the access token.
    /// 
    /// 
    /// The access token.
    /// 
    public Token AccessToken { get; set; }

    /// 
    /// Gets or sets the original subject that requiested the token.
    /// 
    /// 
    /// The subject.
    /// 
    public ClaimsPrincipal Subject
    {
        get
        {
            var user = new IdentityServerUser(SubjectId);
            if (AccessToken.Claims != null)
            {
                foreach (var claim in AccessToken.Claims)
                {
                    user.AdditionalClaims.Add(claim);
                }
            }
            return user.CreatePrincipal();
        }
    }

    /// 
    /// Gets or sets the version number.
    /// 
    /// 
    /// The version.
    /// 
    public int Version { get; set; } = 4;

    /// 
    /// Gets the client identifier.
    /// 
    /// 
    /// The client identifier.
    /// 
    public string ClientId => AccessToken.ClientId;

    /// 
    /// Gets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId => AccessToken.SubjectId;

    /// 
    /// Gets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId => AccessToken.SessionId;

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description => AccessToken.Description;

    /// 
    /// Gets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable Scopes => AccessToken.Scopes;
}


================================================
FILE: src/Storage/src/Models/Resource.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models the common data of API and identity resources.
/// 
[DebuggerDisplay("{DebuggerDisplay,nq}")]
public abstract class Resource
{
    private string DebuggerDisplay => Name ?? $"{{{typeof(Resource)}}}";

    /// 
    /// Indicates if this resource is enabled. Defaults to true.
    /// 
    public bool Enabled { get; set; } = true;

    /// 
    /// The unique name of the resource.
    /// 
    public string Name { get; set; }

    /// 
    /// Display name of the resource.
    /// 
    public string DisplayName { get; set; }
    
    /// 
    /// Description of the resource.
    /// 
    public string Description { get; set; }

    /// 
    /// Specifies whether this scope is shown in the discovery document. Defaults to true.
    /// 
    public bool ShowInDiscoveryDocument { get; set; } = true;

    /// 
    /// List of associated user claims that should be included when this resource is requested.
    /// 
    public ICollection UserClaims { get; set; } = new HashSet();

    /// 
    /// Gets or sets the custom properties for the resource.
    /// 
    /// 
    /// The properties.
    /// 
    public IDictionary Properties { get; set; } = new Dictionary();
}


================================================
FILE: src/Storage/src/Models/Resources.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a collection of identity and API resources.
/// 
public class Resources
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public Resources()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The other.
    public Resources(Resources other)
        : this(other.IdentityResources, other.ApiResources, other.ApiScopes)
    {
        OfflineAccess = other.OfflineAccess;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The identity resources.
    /// The API resources.
    /// The API scopes.
    public Resources(IEnumerable identityResources, IEnumerable apiResources, IEnumerable apiScopes)
    {
        if (identityResources?.Any() == true)
        {
            IdentityResources = new HashSet(identityResources.ToArray());
        }
        if (apiResources?.Any() == true)
        {
            ApiResources = new HashSet(apiResources.ToArray());
        }
        if (apiScopes?.Any() == true)
        {
            ApiScopes = new HashSet(apiScopes.ToArray());
        }
    }

    /// 
    /// Gets or sets a value indicating whether [offline access].
    /// 
    /// 
    ///   true if [offline access]; otherwise, false.
    /// 
    public bool OfflineAccess { get; set; }

    /// 
    /// Gets or sets the identity resources.
    /// 
    public ICollection IdentityResources { get; set; } = new HashSet();

    /// 
    /// Gets or sets the API resources.
    /// 
    public ICollection ApiResources { get; set; } = new HashSet();
    
    /// 
    /// Gets or sets the API scopes.
    /// 
    public ICollection ApiScopes { get; set; } = new HashSet();
}


================================================
FILE: src/Storage/src/Models/Secret.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a client secret with identifier and expiration
/// 
public class Secret
{
    /// 
    /// Gets or sets the description.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }

    /// 
    /// Gets or sets the value.
    /// 
    /// 
    /// The value.
    /// 
    public string Value { get; set; }

    /// 
    /// Gets or sets the expiration.
    /// 
    /// 
    /// The expiration.
    /// 
    public DateTime? Expiration { get; set; }

    /// 
    /// Gets or sets the type of the client secret.
    /// 
    /// 
    /// The type of the client secret.
    /// 
    public string Type { get; set; }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    public Secret()
    {
        Type = IdentityServerConstants.SecretTypes.SharedSecret;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The value.
    /// The expiration.
    public Secret(string value, DateTime? expiration = null)
        : this()
    {
        Value = value;
        Expiration = expiration;
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// The value.
    /// The description.
    /// The expiration.
    public Secret(string value, string description, DateTime? expiration = null)
        : this()
    {
        Description = description;
        Value = value;
        Expiration = expiration;
    }

    /// 
    /// Returns a hash code for this instance.
    /// 
    /// 
    /// A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
    /// 
    public override int GetHashCode()
    {
        unchecked
        {
            var hash = 17;
            hash = hash * 23 + (Value?.GetHashCode() ?? 0);
            hash = hash * 23 + (Type?.GetHashCode() ?? 0);

            return hash;
        }
    }

    /// 
    /// Determines whether the specified , is equal to this instance.
    /// 
    /// The  to compare with this instance.
    /// 
    ///   true if the specified  is equal to this instance; otherwise, false.
    /// 
    public override bool Equals(object obj)
    {
        if (obj == null) return false;
        var other = obj as Secret;
        if (other == null) return false;
        if (ReferenceEquals(other, this)) return true;

        return String.Equals(other.Type, Type, StringComparison.Ordinal) && 
            String.Equals(other.Value, Value, StringComparison.Ordinal);
    }
}


================================================
FILE: src/Storage/src/Models/Token.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Models;

/// 
/// Models a token.
/// 
public class Token
{
    /// 
    /// Initializes a new instance of the  class.
    /// 
    public Token()
    {
    }

    /// 
    /// Initializes a new instance of the  class.
    /// 
    /// Type of the token.
    public Token(string tokenType)
    {
        Type = tokenType;
    }

    /// 
    /// A list of allowed algorithm for signing the token. If null or empty, will use the default algorithm.
    /// 
    public ICollection AllowedSigningAlgorithms { get; set; } = new HashSet();

    /// 
    /// Specifies the confirmation method of the token. This value, if set, will become the cnf claim.
    /// 
    public string Confirmation { get; set; }

    /// 
    /// Gets or sets the audiences.
    /// 
    /// 
    /// The audiences.
    /// 
    public ICollection Audiences { get; set; } = new HashSet();
    
    /// 
    /// Gets or sets the issuer.
    /// 
    /// 
    /// The issuer.
    /// 
    public string Issuer { get; set; }
    
    /// 
    /// Gets or sets the creation time.
    /// 
    /// 
    /// The creation time.
    /// 
    public DateTime CreationTime { get; set; }
    
    /// 
    /// Gets or sets the lifetime.
    /// 
    /// 
    /// The lifetime.
    /// 
    public int Lifetime { get; set; }

    /// 
    /// Gets or sets the type.
    /// 
    /// 
    /// The type.
    /// 
    public string Type { get; set; } = OidcConstants.TokenTypes.AccessToken;

    /// 
    /// Gets or sets the ID of the client.
    /// 
    /// 
    /// The ID of the client.
    /// 
    public string ClientId { get; set; }

    /// 
    /// Gets or sets the type of access token of the client
    /// 
    /// 
    /// The access token type specified by the client.
    /// 
    public AccessTokenType AccessTokenType { get; set; }

    /// 
    /// Gets the description the user assigned to the device being authorized.
    /// 
    /// 
    /// The description.
    /// 
    public string Description { get; set; }
    
    /// 
    /// Gets or sets the claims.
    /// 
    /// 
    /// The claims.
    /// 
    public ICollection Claims { get; set; } = new HashSet(new ClaimComparer());

    /// 
    /// Gets or sets the version.
    /// 
    /// 
    /// The version.
    /// 
    public int Version { get; set; } = 4;

    /// 
    /// Gets the subject identifier.
    /// 
    /// 
    /// The subject identifier.
    /// 
    public string SubjectId => Claims.Where(x => x.Type == JwtClaimTypes.Subject).Select(x => x.Value).SingleOrDefault();

    /// 
    /// Gets the session identifier.
    /// 
    /// 
    /// The session identifier.
    /// 
    public string SessionId => Claims.Where(x => x.Type == JwtClaimTypes.SessionId).Select(x => x.Value).SingleOrDefault();

    /// 
    /// Gets the scopes.
    /// 
    /// 
    /// The scopes.
    /// 
    public IEnumerable Scopes => Claims.Where(x => x.Type == JwtClaimTypes.Scope).Select(x => x.Value);
}


================================================
FILE: src/Storage/src/Services/ICorsPolicyService.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Services;

/// 
/// Service that determines if CORS is allowed.
/// 
public interface ICorsPolicyService
{
    /// 
    /// Determines whether origin is allowed.
    /// 
    /// The origin.
    /// 
    Task IsOriginAllowedAsync(string origin);
}


================================================
FILE: src/Storage/src/Stores/IAuthorizationCodeStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for the authorization code store
/// 
public interface IAuthorizationCodeStore
{
    /// 
    /// Stores the authorization code.
    /// 
    /// The code.
    /// 
    Task StoreAuthorizationCodeAsync(AuthorizationCode code);

    /// 
    /// Gets the authorization code.
    /// 
    /// The code.
    /// 
    Task GetAuthorizationCodeAsync(string code);

    /// 
    /// Removes the authorization code.
    /// 
    /// The code.
    /// 
    Task RemoveAuthorizationCodeAsync(string code);
}


================================================
FILE: src/Storage/src/Stores/IClientStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Retrieval of client configuration
/// 
public interface IClientStore
{
    /// 
    /// Finds a client by id
    /// 
    /// The client id
    /// The client
    Task FindClientByIdAsync(string clientId);
}


================================================
FILE: src/Storage/src/Stores/IDeviceFlowStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for the device flow store
/// 
public interface IDeviceFlowStore
{
    /// 
    /// Stores the device authorization request.
    /// 
    /// The device code.
    /// The user code.
    /// The data.
    /// 
    Task StoreDeviceAuthorizationAsync(string deviceCode, string userCode, DeviceCode data);

    /// 
    /// Finds device authorization by user code.
    /// 
    /// The user code.
    /// 
    Task FindByUserCodeAsync(string userCode);

    /// 
    /// Finds device authorization by device code.
    /// 
    /// The device code.
    Task FindByDeviceCodeAsync(string deviceCode);

    /// 
    /// Updates device authorization, searching by user code.
    /// 
    /// The user code.
    /// The data.
    Task UpdateByUserCodeAsync(string userCode, DeviceCode data);

    /// 
    /// Removes the device authorization, searching by device code.
    /// 
    /// The device code.
    Task RemoveByDeviceCodeAsync(string deviceCode);
}


================================================
FILE: src/Storage/src/Stores/IPersistedGrantStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for persisting any type of grant.
/// 
public interface IPersistedGrantStore
{
    /// 
    /// Stores the grant.
    /// 
    /// The grant.
    /// 
    Task StoreAsync(PersistedGrant grant);

    /// 
    /// Gets the grant.
    /// 
    /// The key.
    /// 
    Task GetAsync(string key);

    /// 
    /// Gets all grants based on the filter.
    /// 
    /// The filter.
    /// 
    Task> GetAllAsync(PersistedGrantFilter filter);

    /// 
    /// Removes the grant by key.
    /// 
    /// The key.
    /// 
    Task RemoveAsync(string key);

    /// 
    /// Removes all grants based on the filter.
    /// 
    /// The filter.
    /// 
    Task RemoveAllAsync(PersistedGrantFilter filter);
}


================================================
FILE: src/Storage/src/Stores/IReferenceTokenStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for reference token storage
/// 
public interface IReferenceTokenStore
{
    /// 
    /// Stores the reference token.
    /// 
    /// The token.
    /// 
    Task StoreReferenceTokenAsync(Token token);

    /// 
    /// Gets the reference token.
    /// 
    /// The handle.
    /// 
    Task GetReferenceTokenAsync(string handle);

    /// 
    /// Removes the reference token.
    /// 
    /// The handle.
    /// 
    Task RemoveReferenceTokenAsync(string handle);

    /// 
    /// Removes the reference tokens.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    Task RemoveReferenceTokensAsync(string subjectId, string clientId);
}


================================================
FILE: src/Storage/src/Stores/IRefreshTokenStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for refresh token storage
/// 
public interface IRefreshTokenStore
{
    /// 
    /// Stores the refresh token.
    /// 
    /// The refresh token.
    /// 
    Task StoreRefreshTokenAsync(RefreshToken refreshToken);

    /// 
    /// Updates the refresh token.
    /// 
    /// The handle.
    /// The refresh token.
    /// 
    Task UpdateRefreshTokenAsync(string handle, RefreshToken refreshToken);

    /// 
    /// Gets the refresh token.
    /// 
    /// The refresh token handle.
    /// 
    Task GetRefreshTokenAsync(string refreshTokenHandle);

    /// 
    /// Removes the refresh token.
    /// 
    /// The refresh token handle.
    /// 
    Task RemoveRefreshTokenAsync(string refreshTokenHandle);

    /// 
    /// Removes the refresh tokens.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    Task RemoveRefreshTokensAsync(string subjectId, string clientId);
}


================================================
FILE: src/Storage/src/Stores/IResourceStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Resource retrieval
/// 
public interface IResourceStore
{
    /// 
    /// Gets identity resources by scope name.
    /// 
    Task> FindIdentityResourcesByScopeNameAsync(IEnumerable scopeNames);

    /// 
    /// Gets API scopes by scope name.
    /// 
    Task> FindApiScopesByNameAsync(IEnumerable scopeNames);
    
    /// 
    /// Gets API resources by scope name.
    /// 
    Task> FindApiResourcesByScopeNameAsync(IEnumerable scopeNames);

    /// 
    /// Gets API resources by API resource name.
    /// 
    Task> FindApiResourcesByNameAsync(IEnumerable apiResourceNames);

    /// 
    /// Gets all resources.
    /// 
    Task GetAllResourcesAsync();
}


================================================
FILE: src/Storage/src/Stores/IUserConsentStore.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Interface for user consent storage
/// 
public interface IUserConsentStore
{
    /// 
    /// Stores the user consent.
    /// 
    /// The consent.
    /// 
    Task StoreUserConsentAsync(Consent consent);

    /// 
    /// Gets the user consent.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    Task GetUserConsentAsync(string subjectId, string clientId);

    /// 
    /// Removes the user consent.
    /// 
    /// The subject identifier.
    /// The client identifier.
    /// 
    Task RemoveUserConsentAsync(string subjectId, string clientId);
}


================================================
FILE: src/Storage/src/Stores/PersistedGrantFilter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores;

/// 
/// Represents a filter used when accessing the persisted grants store. 
/// Setting multiple properties is interpreted as a logical 'AND' to further filter the query.
/// At least one value must be supplied.
/// 
public class PersistedGrantFilter
{
    /// 
    /// Subject id of the user.
    /// 
    public string SubjectId { get; set; }
    
    /// 
    /// Session id used for the grant.
    /// 
    public string SessionId { get; set; }
    
    /// 
    /// Client id the grant was issued to.
    /// 
    public string ClientId { get; set; }
    
    /// 
    /// The type of grant.
    /// 
    public string Type { get; set; }
}


================================================
FILE: src/Storage/src/Stores/Serialization/ClaimConverter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Stores.Serialization;

public class ClaimConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(Claim) == objectType;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var source = serializer.Deserialize(reader);
        var target = new Claim(source.Type, source.Value, source.ValueType);
        return target;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var source = (Claim)value;

        var target = new ClaimLite
        {
            Type = source.Type,
            Value = source.Value,
            ValueType = source.ValueType
        };

        serializer.Serialize(writer, target);
    }
}


================================================
FILE: src/Storage/src/Stores/Serialization/ClaimLite.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Stores.Serialization;

public class ClaimLite
{
    public string Type { get; set; }
    public string Value { get; set; }
    public string ValueType { get; set; }
}


================================================
FILE: src/Storage/src/Stores/Serialization/ClaimsPrincipalConverter.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Stores.Serialization;

public class ClaimsPrincipalConverter : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        return typeof(ClaimsPrincipal) == objectType;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var source = serializer.Deserialize(reader);
        if (source == null) return null;

        var claims = source.Claims.Select(x => new Claim(x.Type, x.Value, x.ValueType));
        var id = new ClaimsIdentity(claims, source.AuthenticationType, JwtClaimTypes.Name, JwtClaimTypes.Role);
        var target = new ClaimsPrincipal(id);
        return target;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        var source = (ClaimsPrincipal)value;

        var target = new ClaimsPrincipalLite
        {
            AuthenticationType = source.Identity.AuthenticationType,
            Claims = source.Claims.Select(x => new ClaimLite { Type = x.Type, Value = x.Value, ValueType = x.ValueType }).ToArray()
        };
        serializer.Serialize(writer, target);
    }
}


================================================
FILE: src/Storage/src/Stores/Serialization/ClaimsPrincipalLite.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Stores.Serialization;

public class ClaimsPrincipalLite
{
    public string AuthenticationType { get; set; }
    public ClaimLite[] Claims { get; set; }
}


================================================
FILE: src/Storage/src/Stores/Serialization/CustomContractResolver.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

#pragma warning disable 1591

namespace IdentityServer8.Stores.Serialization;

public class CustomContractResolver: DefaultContractResolver
{
    protected override IList CreateProperties(Type type, MemberSerialization memberSerialization)
    {
        var props = base.CreateProperties(type, memberSerialization);
        return props.Where(p => p.Writable).ToList();
    }
}


================================================
FILE: src/Storage/src/Stores/Serialization/IPersistentGrantSerializer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores.Serialization;

/// 
/// Interface for persisted grant serialization
/// 
public interface IPersistentGrantSerializer
{
    /// 
    /// Serializes the specified value.
    /// 
    /// 
    /// The value.
    /// 
    string Serialize(T value);

    /// 
    /// Deserializes the specified string.
    /// 
    /// 
    /// The json.
    /// 
    T Deserialize(string json);
}


================================================
FILE: src/Storage/src/Stores/Serialization/PersistentGrantSerializer.cs
================================================
/*
 Copyright (c) 2024 HigginsSoft, Alexander Higgins - https://github.com/alexhiggins732/ 

 Copyright (c) 2018, Brock Allen & Dominick Baier. All rights reserved.

 Licensed under the Apache License, Version 2.0. See LICENSE in the project root for license information. 
 Source code and license this software can be found 

 The above copyright notice and this permission notice shall be included in all
 copies or substantial portions of the Software.
*/

namespace IdentityServer8.Stores.Serialization;

/// 
/// JSON-based persisted grant serializer
/// 
/// 
public class PersistentGrantSerializer : IPersistentGrantSerializer
{
    private static readonly JsonSerializerSettings _settings;

    static PersistentGrantSerializer()
    {
        _settings = new JsonSerializerSettings
        {
            ContractResolver = new CustomContractResolver()
        };
        _settings.Converters.Add(new ClaimConverter());
        _settings.Converters.Add(new ClaimsPrincipalConverter());
    }

    /// 
    /// Serializes the specified value.
    /// 
    /// 
    /// The value.
    /// 
    public string Serialize(T value)
    {
        return JsonConvert.SerializeObject(value, _settings);
    }

    /// 
    /// Deserializes the specified string.
    /// 
    /// 
    /// The json.
    /// 
    public T Deserialize(string json)
    {
        return JsonConvert.DeserializeObject(json, _settings);
    }
}


================================================
FILE: version.json
================================================
{
  "$schema": "https://raw.githubusercontent.com/dotnet/Nerdbank.GitVersioning/main/src/NerdBank.GitVersioning/version.schema.json",
  "version": "8.0.4-beta.4",
  "nugetPackageVersion": {
    "semVer": 2, // optional. Set to either 1 or 2 to control how the NuGet package version string is generated. Default is 1.
    "precision": "revision"
  },
  "semVer1NumericIdentifierPadding": 4,
  "pathFilters": [
    // optional list of paths to consider when calculating version height.
    "!docs",
    "!.git",
    "!.vs",
    "!.config",
    "!.github",
    "!.config",
    "!Directory.Build.props",
    "!Directory.Build.targets",
    "!Directory.Packages.props",
    "docker-compose.yml",
    "docker-compose.override.yml",
    "docker-compose.vs.debug.yml",
    "docker-compose.vs.release.yml",
    "docker-compose.dcrpoj",
    "src/IdentityServer8.sln",
    "!global.json",
    "!IdentityServer8.DotNet.ruleset",
    "!LICENSCE",
    "!Nuget.config",
    "!SECURITY.md",
    "!SPONSORS.md",
    "!README.md",
    "!samples",
    "!nuget"
  ],
  "publicReleaseRefSpec": [
    "^refs/heads/master$", // we release out of master
    "^refs/tags/v\\d+\\.\\d+", // we also release tags starting with vN.N
    "^refs/heads/develop$", // we release alpha out of develop
    "^refs/heads/release/*" // we release beta out of release
  ],
  "cloudBuild": {
    "setVersionVariables": true,
    "buildNumber": {
      "enabled": true,
      "includeCommitId": {
        "when": "always",
        "where": "buildMetadata"
      }
    }
  },
  "release": {
    "tagName": "v{version}",
    "branchName": "v{version}",
    "versionIncrement": "minor",
    "firstUnstableTag": "alpha"
  }
}