From 97a5f5db462e4b19996c8c2080618665e8dec756 Mon Sep 17 00:00:00 2001 From: lumi2021 <94462076+lumi2021@users.noreply.github.com> Date: Fri, 9 Aug 2024 14:32:32 -0300 Subject: [PATCH] website, nuke build & publishing workflow --- .github/workflows/publish-site.yml | 60 +- .nuke/build.schema.json | 2 + build/nuke/Build.Core.cs | 2 +- build/nuke/Build.Website.cs | 120 + build/nuke/Build.cs | 8 +- build/nuke/nuke.generated.sln | 25 + package-lock.json | 6 + website/.gitignore | 20 + website/babel.config.js | 3 + website/blog/2024-02-14-test.md | 17 + website/docs/getStarted.md | 8 + website/docs/opengl/1-helloWindow.md | 194 + website/docs/opengl/2-helloQuad.md | 538 + website/docs/opengl/3-helloTexture.md | 462 + website/docs/opengl/_category_.json | 4 + .../1-helloWindow/cornflower-window.png | Bin 0 -> 11027 bytes .../assets/1-helloWindow/first-window.png | Bin 0 -> 12068 bytes .../1-helloWindow/loading-rendering.png | Bin 0 -> 2809 bytes .../assets/2-helloQuad/cornflower-window.png | Bin 0 -> 11027 bytes .../assets/2-helloQuad/final-result-t2.png | Bin 0 -> 11212 bytes .../2-helloQuad/vertex_attribute_pointer.png | Bin 0 -> 9997 bytes .../assets/2-helloQuad/wireframe-quad.png | Bin 0 -> 17787 bytes website/docusaurus.config.js | 131 + website/package-lock.json | 15225 ++++++++++++++++ website/package.json | 57 + website/sidebars.js | 26 + .../AllinOneSolution.module.scss | 40 + .../AllInOneSolution/AllinOneSolution.tsx | 33 + .../joinConversation.module.scss | 285 + .../JoinConversation/joinConversation.tsx | 80 + .../LightBalls/LightBalls.module.scss | 30 + .../mainPage/LightBalls/LightBalls.tsx | 53 + .../ReadyForAnything.module.scss | 138 + .../ReadyForAnything/ReadyForAnything.tsx | 89 + .../ReliableDepend/ReliableDepend.module.scss | 44 + .../ReliableDepend/ReliableDepend.tsx | 85 + .../SilkFeatures/SilkFeatures.module.scss | 69 + .../mainPage/SilkFeatures/SilkFeatures.tsx | 89 + .../mainPage/TryStride/TryStride.module.scss | 87 + .../mainPage/TryStride/TryStride.tsx | 37 + website/src/css/custom.css | 29 + website/src/pages/index.module.css | 250 + website/src/pages/index.tsx | 156 + website/static/.nojekyll | 0 website/static/img/apis/assimp.png | Bin 0 -> 45487 bytes website/static/img/apis/dx12ultimate.png | Bin 0 -> 88197 bytes website/static/img/apis/glfw.png | Bin 0 -> 22788 bytes website/static/img/apis/openal.png | Bin 0 -> 13852 bytes website/static/img/apis/opencl.svg | 64 + website/static/img/apis/opengl.jpg | Bin 0 -> 7073 bytes website/static/img/apis/opengles.png | Bin 0 -> 7588 bytes website/static/img/apis/openxr.svg | 63 + website/static/img/apis/sdl.png | Bin 0 -> 20932 bytes website/static/img/apis/vulkan.svg | 23 + website/static/img/dotnetfoundation.png | Bin 0 -> 322453 bytes website/static/img/favicon.ico | Bin 0 -> 3626 bytes .../static/img/others/discord-logo-white.svg | 1 + website/static/img/others/discord-logo.svg | 1 + website/static/img/others/discord-star.png | Bin 0 -> 12337 bytes website/static/img/others/github-logo.png | Bin 0 -> 8640 bytes website/static/img/silkdotnet_v3.svg | 1 + website/static/img/silkdotnet_v3_w.svg | 1 + website/static/img/stride.svg | 13 + website/static/img/wordmark.svg | 1 + website/static/img/wordmarkw.svg | 1 + website/static/img/xplatpromo.png | Bin 0 -> 9809 bytes website/tsconfig.json | 10 + 67 files changed, 18652 insertions(+), 29 deletions(-) create mode 100644 build/nuke/Build.Website.cs create mode 100644 build/nuke/nuke.generated.sln create mode 100644 package-lock.json create mode 100644 website/.gitignore create mode 100644 website/babel.config.js create mode 100644 website/blog/2024-02-14-test.md create mode 100644 website/docs/getStarted.md create mode 100644 website/docs/opengl/1-helloWindow.md create mode 100644 website/docs/opengl/2-helloQuad.md create mode 100644 website/docs/opengl/3-helloTexture.md create mode 100644 website/docs/opengl/_category_.json create mode 100644 website/docs/opengl/assets/1-helloWindow/cornflower-window.png create mode 100644 website/docs/opengl/assets/1-helloWindow/first-window.png create mode 100644 website/docs/opengl/assets/1-helloWindow/loading-rendering.png create mode 100644 website/docs/opengl/assets/2-helloQuad/cornflower-window.png create mode 100644 website/docs/opengl/assets/2-helloQuad/final-result-t2.png create mode 100644 website/docs/opengl/assets/2-helloQuad/vertex_attribute_pointer.png create mode 100644 website/docs/opengl/assets/2-helloQuad/wireframe-quad.png create mode 100644 website/docusaurus.config.js create mode 100644 website/package-lock.json create mode 100644 website/package.json create mode 100644 website/sidebars.js create mode 100644 website/src/components/mainPage/AllInOneSolution/AllinOneSolution.module.scss create mode 100644 website/src/components/mainPage/AllInOneSolution/AllinOneSolution.tsx create mode 100644 website/src/components/mainPage/JoinConversation/joinConversation.module.scss create mode 100644 website/src/components/mainPage/JoinConversation/joinConversation.tsx create mode 100644 website/src/components/mainPage/LightBalls/LightBalls.module.scss create mode 100644 website/src/components/mainPage/LightBalls/LightBalls.tsx create mode 100644 website/src/components/mainPage/ReadyForAnything/ReadyForAnything.module.scss create mode 100644 website/src/components/mainPage/ReadyForAnything/ReadyForAnything.tsx create mode 100644 website/src/components/mainPage/ReliableDepend/ReliableDepend.module.scss create mode 100644 website/src/components/mainPage/ReliableDepend/ReliableDepend.tsx create mode 100644 website/src/components/mainPage/SilkFeatures/SilkFeatures.module.scss create mode 100644 website/src/components/mainPage/SilkFeatures/SilkFeatures.tsx create mode 100644 website/src/components/mainPage/TryStride/TryStride.module.scss create mode 100644 website/src/components/mainPage/TryStride/TryStride.tsx create mode 100644 website/src/css/custom.css create mode 100644 website/src/pages/index.module.css create mode 100644 website/src/pages/index.tsx create mode 100644 website/static/.nojekyll create mode 100644 website/static/img/apis/assimp.png create mode 100644 website/static/img/apis/dx12ultimate.png create mode 100644 website/static/img/apis/glfw.png create mode 100644 website/static/img/apis/openal.png create mode 100644 website/static/img/apis/opencl.svg create mode 100644 website/static/img/apis/opengl.jpg create mode 100644 website/static/img/apis/opengles.png create mode 100644 website/static/img/apis/openxr.svg create mode 100644 website/static/img/apis/sdl.png create mode 100644 website/static/img/apis/vulkan.svg create mode 100644 website/static/img/dotnetfoundation.png create mode 100644 website/static/img/favicon.ico create mode 100644 website/static/img/others/discord-logo-white.svg create mode 100644 website/static/img/others/discord-logo.svg create mode 100644 website/static/img/others/discord-star.png create mode 100644 website/static/img/others/github-logo.png create mode 100644 website/static/img/silkdotnet_v3.svg create mode 100644 website/static/img/silkdotnet_v3_w.svg create mode 100644 website/static/img/stride.svg create mode 100644 website/static/img/wordmark.svg create mode 100644 website/static/img/wordmarkw.svg create mode 100644 website/static/img/xplatpromo.png create mode 100644 website/tsconfig.json diff --git a/.github/workflows/publish-site.yml b/.github/workflows/publish-site.yml index 5fc4b7a07c..5de600a8f7 100644 --- a/.github/workflows/publish-site.yml +++ b/.github/workflows/publish-site.yml @@ -3,40 +3,46 @@ on: push: branches: - 'main' + + workflow_dispatch: + permissions: contents: read pages: write id-token: write + +env: + NODE_OPTIONS: --max-old-space-size=6144 + jobs: - Build: - runs-on: ubuntu-latest - steps: - - uses: actions/checkout@v2 - - name: Setup .NET 5.0 - uses: actions/setup-dotnet@v1 - with: - dotnet-version: 5.0.401 - - name: Setup .NET 6.0 - uses: actions/setup-dotnet@v1 - with: - dotnet-version: 6.0.201 - - name: Setup .NET 7.0 - uses: actions/setup-dotnet@v1 - with: - dotnet-version: 7.0.102 - - name: Run Statiq - run: dotnet run -c Release --project src/Website/Silk.NET.Statiq/Silk.NET.Statiq.csproj -- -l debug --nocache - - name: Upload artifact - uses: actions/upload-pages-artifact@v1 - with: - path: "docs" - Deploy: + deploy: environment: name: github-pages url: ${{ steps.deployment.outputs.page_url }} + runs-on: ubuntu-latest - needs: Build steps: - - name: Deploy to GitHub Pages - id: deployment - uses: actions/deploy-pages@v1 + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up Node.js + uses: actions/setup-node@v3 + with: + node-version: 16.x + cache: yarn + + - name: Install dependencies + working-directory: ./website + run: yarn install --frozen-lockfile --non-interactive + + - name: Build + working-directory: ./website + run: yarn build + + - name: Setup Pages + uses: actions/configure-pages@v3 + + - name: Upload artifact + uses: actions/upload-pages-artifact@v2 + with: + path: build diff --git a/.nuke/build.schema.json b/.nuke/build.schema.json index 09c66fc913..892d3f7b03 100644 --- a/.nuke/build.schema.json +++ b/.nuke/build.schema.json @@ -172,6 +172,7 @@ "ValidateSolution", "Vkd3d", "VulkanLoader", + "Website", "Wgpu" ] } @@ -216,6 +217,7 @@ "ValidateSolution", "Vkd3d", "VulkanLoader", + "Website", "Wgpu" ] } diff --git a/build/nuke/Build.Core.cs b/build/nuke/Build.Core.cs index 0b47ac05f2..ef711ebc31 100644 --- a/build/nuke/Build.Core.cs +++ b/build/nuke/Build.Core.cs @@ -1,4 +1,4 @@ -// Licensed to the .NET Foundation under one or more agreements. +// Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. using System.IO; diff --git a/build/nuke/Build.Website.cs b/build/nuke/Build.Website.cs new file mode 100644 index 0000000000..471e426029 --- /dev/null +++ b/build/nuke/Build.Website.cs @@ -0,0 +1,120 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using System; +using System.IO; +using System.Runtime.InteropServices; +using Nuke.Common; +using Nuke.Common.ProjectModel; +using Nuke.Common.Utilities.Collections; +using Nuke.Common.Tools.Npm; + +partial class Build +{ + static string workingDirectory = "./website"; + + Target Website => _ => _ + .Executes(() => + { + Console.WriteLine("Verifying dependences:\n"); + + Assert.True(VerifyDependences()); + + if (Configuration == "Debug") + { + Console.WriteLine("Running website in debug mode (it may take a while)"); + NpmTasks.Npm("run docusaurus start", workingDirectory, null, null, false); + } + else + { + Console.WriteLine("Building website for production"); + NpmTasks.Npm("run docusaurus build", workingDirectory); + } + }); + + static bool VerifyDependences() + { + Console.Write("Node.js ... "); + + var nodePath = GetExecutablePath("node"); + if (string.IsNullOrEmpty(nodePath)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine("\rNode.js not found!\n"); + Console.ResetColor(); + Console.WriteLine("Please, make sure node.js is installed on your machine!"); + Console.WriteLine("Dowload node here => https://nodejs.org/en/download"); + Console.WriteLine(); + return false; + } + else + { + Console.ForegroundColor = ConsoleColor.Green; + Console.WriteLine("OK"); + Console.ResetColor(); + } + + Console.Write("Node Package Mananger ... "); + + var npmPath = GetExecutablePath("npm"); + if (string.IsNullOrEmpty(nodePath)) + { + Console.ForegroundColor = ConsoleColor.Red; + Console.WriteLine("\rNode Package Mananger not found!\n"); + Console.ResetColor(); + Console.WriteLine("Please, make sure node.js is working and updated on your machine!"); + Console.WriteLine(); + return false; + } + else + { + Console.ForegroundColor = ConsoleColor.Green; + Console.WriteLine("OK"); + Console.ResetColor(); + } + + Console.Write("Node Modules ... "); + + if (!Directory.Exists($"{workingDirectory}/node_modules")) + { + Console.ForegroundColor = ConsoleColor.Yellow; + Console.WriteLine("\rNode modules not found. Installing modules...\n"); + Console.ResetColor(); + + NpmTasks.Npm("install", workingDirectory); + + Console.Write("Node Modules ... "); + Console.ForegroundColor = ConsoleColor.Green; + Console.WriteLine("OK"); + Console.ResetColor(); + } + else + { + Console.ForegroundColor = ConsoleColor.Green; + Console.WriteLine("OK"); + Console.ResetColor(); + } + + return true; + } + + static string GetExecutablePath(string execName) + { + var paths = Environment.GetEnvironmentVariable("PATH").Split(Path.PathSeparator); + + string[] extensions = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) + ? Environment.GetEnvironmentVariable("PATHEXT").Split(';') + : [""]; + + foreach (var path in paths) + { + foreach (var ext in extensions) + { + var fullPath = Path.Combine(path, execName + ext.ToLower()); + if (File.Exists(fullPath)) return fullPath; + } + } + + return null; + } +} diff --git a/build/nuke/Build.cs b/build/nuke/Build.cs index 9d307cbe42..3117ca38bc 100644 --- a/build/nuke/Build.cs +++ b/build/nuke/Build.cs @@ -1,5 +1,7 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + using Nuke.Common; -using Nuke.Common.Execution; partial class Build : NukeBuild { @@ -24,6 +26,10 @@ partial class Build : NukeBuild // Deployment // ---------- // - Build.NuGet.cs - targets for pushing NuGet packages to the NuGet Gallery (or some other feed). + // ---------- + // Website + // ---------- + // - Build.Website.cs - targets for testing and building the docusaurus website. // ------------- // Miscellaneous // ------------- diff --git a/build/nuke/nuke.generated.sln b/build/nuke/nuke.generated.sln new file mode 100644 index 0000000000..34ed988dab --- /dev/null +++ b/build/nuke/nuke.generated.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.5.002.0 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Silk.NET.NUKE", "Silk.NET.NUKE.csproj", "{67DA7859-4BE8-425E-9C46-41842A134D0B}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {67DA7859-4BE8-425E-9C46-41842A134D0B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {67DA7859-4BE8-425E-9C46-41842A134D0B}.Debug|Any CPU.Build.0 = Debug|Any CPU + {67DA7859-4BE8-425E-9C46-41842A134D0B}.Release|Any CPU.ActiveCfg = Release|Any CPU + {67DA7859-4BE8-425E-9C46-41842A134D0B}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {5FF51335-FB2D-46BD-AE9C-ED3C6113B513} + EndGlobalSection +EndGlobal diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000000..4c18aedf4d --- /dev/null +++ b/package-lock.json @@ -0,0 +1,6 @@ +{ + "name": "Silk.NET", + "lockfileVersion": 3, + "requires": true, + "packages": {} +} diff --git a/website/.gitignore b/website/.gitignore new file mode 100644 index 0000000000..b2d6de3062 --- /dev/null +++ b/website/.gitignore @@ -0,0 +1,20 @@ +# Dependencies +/node_modules + +# Production +/build + +# Generated files +.docusaurus +.cache-loader + +# Misc +.DS_Store +.env.local +.env.development.local +.env.test.local +.env.production.local + +npm-debug.log* +yarn-debug.log* +yarn-error.log* diff --git a/website/babel.config.js b/website/babel.config.js new file mode 100644 index 0000000000..e00595dae7 --- /dev/null +++ b/website/babel.config.js @@ -0,0 +1,3 @@ +module.exports = { + presets: [require.resolve('@docusaurus/core/lib/babel/preset')], +}; diff --git a/website/blog/2024-02-14-test.md b/website/blog/2024-02-14-test.md new file mode 100644 index 0000000000..5e9609b414 --- /dev/null +++ b/website/blog/2024-02-14-test.md @@ -0,0 +1,17 @@ +--- +title: Still in development! +description: This is my first post on Docusaurus. +slug: welcome-docusaurus-v2 +authors: + - name: Lumi + url: https://github.com/lumi2021 + image_url: https://github.com/lumi2021.png + +tags: [test, Silk.NET, .NET] +image: https://i.imgur.com/mErPwqL.png +hide_table_of_contents: false +--- + +Blogs will still be reinplemented! sorry! + + diff --git a/website/docs/getStarted.md b/website/docs/getStarted.md new file mode 100644 index 0000000000..fd47a60031 --- /dev/null +++ b/website/docs/getStarted.md @@ -0,0 +1,8 @@ +--- +sidebar_position: 1 +--- + +# Get Started + +# Coming soon! :sweat_smile: +This tutorial is currently work-in-progress. \ No newline at end of file diff --git a/website/docs/opengl/1-helloWindow.md b/website/docs/opengl/1-helloWindow.md new file mode 100644 index 0000000000..e52f5139b8 --- /dev/null +++ b/website/docs/opengl/1-helloWindow.md @@ -0,0 +1,194 @@ +# 1.1 - Hello Window + +## Introduction +Welcome to your first Silk.NET tutorial! + +The first part of your journey will be learning how to create a window and accept some input. + +## A basic project +Okay, let's get started! + +The first thing we will need is a blank C# project. For this tutorial, we're going to be using .NET 6, however Silk works with any .NET Standard 2.0 platform. + +We're going to assume you know how to create projects with your chosen code editor, so create a blank console project. If you don't know how to do this, here are some good guides to get started: +* [Creating a basic project using the dotnet CLI](https://dotnet.microsoft.com/en-us/learn/dotnet/hello-world-tutorial/intro) +* [Using Visual Studio to create a .NET project](https://docs.microsoft.com/en-us/visualstudio/get-started/csharp/tutorial-console?view=vs-2022) +* [Creating and opening projects with Jetbrains Rider](https://www.jetbrains.com/help/rider/Creating_and_Opening_Projects_and_Solutions.html#trusted-and-untrusted-solutions) + +If you've used, or are using, an older version of .NET, you will be familliar with the standard C# entry point. .NET 6 and up changes this by default, however Silk works best using the old format. If you're using an older version of .NET, you can skip this bit. + +Add the following code to your file: + +```cs +// If you're using an earlier version of .NET which doesn't have file-scoped namespaces (.NET 5 or earlier), you'll need to encase your class inside the namespace. +namespace MySilkProgram; + +public class Program +{ + public static void Main(string[] args) { } +} +``` + +## Installing Silk.NET +Before you can get started using Silk.NET, you'll want to install Silk.NET. For the purposes of this tutorial, we're going to assume you're already familliar with creating a C# project, as well as how to install packages with your chosen editor. + +While there are many packages available, we'll only need three for this tutorial. +* [Silk.NET.Windowing](https://www.nuget.org/packages/Silk.NET.Windowing) +* [Silk.NET.Input](https://www.nuget.org/packages/Silk.NET.Input) +* [Silk.NET.OpenGL](https://www.nuget.org/packages/Silk.NET.OpenGL) + +We won't be using the `OpenGL` package in this tutorial, however we'll be using it in every other tutorial, so it's a good idea to install it now. + +Using the dotnet CLI, installing the packages is simple: + +``` +dotnet add package Silk.NET.Windowing +dotnet add package Silk.NET.Input +dotnet add package Silk.NET.OpenGL +``` + +Or, if you're using Visual Studio, you can use the NuGet Package Manager by right-clicking on your project in the solution explorer and selecting "Manage NuGet Packages...". + +## Creating a Window +The first thing we need before we can even think about rendering some graphics is a window to render to. + +In other languages & implementations, you will often have to write a ton of boilerplate code to create the window & render loop, and dealing with the OpenGL context. Fortunately for us, Silk.NET features a built-in easy windowing library that does all this for us! + +Add the following using directives to the top of your file: + +```cs +using Silk.NET.Input; +using Silk.NET.Maths; +using Silk.NET.Windowing; +``` + +### The Window Options +Before we can create a window, we need to tell it how to behave on startup. This is done with the [WindowOptions](https://github.com/dotnet/Silk.NET/blob/main/src/Windowing/Silk.NET.Windowing.Common/Structs/WindowOptions.cs) struct. + +Now, the window options struct contains *a lot* of parameters. Fortunately for us, we don't need to set all these, as the window options struct contains a `Default` property that sets these for us. + +In your `Main` method, add the following: + +```cs +WindowOptions options = WindowOptions.Default with +{ + Size = new Vector2D(800, 600), + Title = "My first Silk.NET application!" +}; +``` + +What these do should be fairly obvious but we'll go over them anyway: +* **Size** - The initial size in pixels (aka resolution) of the window. +* **Title** - The initial title (the text at the top) of the window. + +### Creating the window +In order for windows to work properly, we need to keep a **reference** to our window after we've created it. This is in the form of an `IWindow`. + +Add the following to the top of your class: + +```cs +private static IWindow _window; +``` + +Next, we need to create the window itself. This is done with the `Window.Create()` method. All we need to do is pass in our options and it will create a window for us. + +In your `Main` method, add the following underneath your window options code: + +```cs +_window = Window.Create(options); +``` + +Now, you may think we have got enough code to run a window, but if you run the program you'll see nothing will show up. That's because we're missing one more thing. + +The last thing we need to do is to tell the window to run. At the bottom of your `Main` method, add the following: + +```cs +_window.Run(); +``` + +And that's it! Run the program and you should hopefully see a window. + +![Window](assets/1-helloWindow/first-window.png) + +## Window Events +The window we've just created has several events we can subscribe to, such as loading and rendering, which are key for your program to work properly. + +For this tutorial, we'll be subscribing to three events: +* Load +* Update +* Render + +Add the following three methods to your class: + +```cs +private static void OnLoad() { } + +private static void OnUpdate(double deltaTime) { } + +private static void OnRender(double deltaTime) { } +``` + +These are the methods that will power our main application. For this tutorial, we'll only be using `OnLoad`, but it's helpful to have all three. + +:::note +The `deltaTime` parameter is the amount of time, in seconds, that has passed since the last frame. Using delta time is key for framerate-independent actions, such as movement. +::: + +Next, we need to subscribe to these events. Add the following code to your `Main` method, just after you call `Window.Create()`: + +```cs +_window.Load += OnLoad; +_window.Update += OnUpdate; +_window.Render += OnRender; +``` + +Launch your program again and you will see that... nothing has changed. Good! That means it's working correctly. Try adding some logs in the load, update, and render methods to see exactly when they are called. + +![Load, update, and render demo.](assets/1-helloWindow/loading-rendering.png) + +We're now ready to handle some input! + +## Handling Input +Input is a key part of any program. If the user can't input anything, it's not a very useful program. For this tutorial, we're simply going to close the program when the user presses the escape key. + +### Creating an input context +An input context is responsible for receiving user input, and handling input events. Creating one is simple, thanks to an extension method that `Silk.NET.Input` provides to the `IWindow`. + +In your `OnLoad` method, add the following: + +```cs +IInputContext input = _window.CreateInput(); +``` + +This will create our input context. To handle keyboard input, we need to subscribe to the `KeyDown` event. + +First, let's create the method that handles this event: + +```cs +private static void KeyDown(IKeyboard keyboard, Key key, int keyCode) { } +``` + +Now that we've done that, we can subscribe to it in our `OnLoad` method. Add the following after you create the input context: + +```cs +for (int i = 0; i < input.Keyboards.Count; i++) + input.Keyboards[i].KeyDown += KeyDown; +``` + +Sometimes, an input context supports multiple keyboards connected to the host device. In those cases, we want to handle when the escape key is pressed on any connected keyboard, so we subscribe to the event for every keyboard that is connected. + +We've now subcribed to the event, try adding some logs in your `KeyDown` method and see what results you get. + +### Exiting the program +The last thing we need to do is handle when the escape key is pressed, and exit the program. You may have noticed that the `KeyDown` event has three parameters. For most situations, you will usually only need the second parameter, `key`. This returns the actual key that has been pressed. + +Closing the window is very simple. Simply call `_window.Close()` and it will do what it says on the tin and gracefully close the window, as well as calling the `Closing` event (which we're not using in this tutorial). + +Knowing this, add the following inside your `KeyDown` method: + +```cs +if (key == Key.Escape) + _window.Close(); +``` + +And that's it! You should now be able to press the escape key and the window will close. diff --git a/website/docs/opengl/2-helloQuad.md b/website/docs/opengl/2-helloQuad.md new file mode 100644 index 0000000000..7983f4b769 --- /dev/null +++ b/website/docs/opengl/2-helloQuad.md @@ -0,0 +1,538 @@ +# 1.2 - Hello Quad + +Let's draw something on-screen! In this tutorial, you'll learn: + +* How to initialize OpenGL. +* How to clear the window. +* How the OpenGL pipeline works. +* What vertex array objects, vertex buffers, and element array buffers are, and how to use them. +* How to create and use shaders. +* How to draw to the screen. + +This tutorial will feature a lot of content and new info, so we'll take it slow and with lots of explanations. + +## Initializing OpenGL +The first thing we need to do before we can issue OpenGL commands, is to initialize it. Fortunately, Silk.NET windowing does most of the hard part for us, and we only have to get the GL api. + +Add the following using directive to the top of your file, you'll need this to use OpenGL: + +```cs +using Silk.NET.OpenGL; +``` + +Then, at the top of your class, add the following: + +```cs +private static GL _gl; +``` + +Finally, in your `OnLoad` method, add the following: + +```cs +_gl = _window.CreateOpenGL(); +``` + +What are we doing here? Silk.NET requires you to keep a **reference** to the OpenGL API. If you've used or seen OpenGL in C, you'll notice that this is different to the way that it is done there. This is done so that you can more easily keep track of multiple contexts. If you don't know what that is, don't worry about it for now, we won't be using it in these tutorials. + +:::note +If you take a look at the source in the Silk.NET samples repository, you will notice that it uses `_gl = GL.GetApi(_window)`. This is another way to get the GL API, however when using Silk.NET windowing, it's recommended that you use `_window.CreateOpenGL()` instead. +::: + +Now, run your application again. If all is good, you should see no change. Awesome! Let's do our first steps in OpenGL: Clearing the window. + +## Clearing the window +Before we start this, let's take a look at what makes up an OpenGL window. + +A window contains at least two **framebuffers**. A framebuffer is a set of textures that can be rendered to. An OpenGL window's framebuffer consists of the following textures: + +* Color texture +* Depth stencil texture + +:::note +The technical name for these textures is **buffers**. For simplicity reasons we will call them textures here, as to not confuse you with the buffers we use later in the tutorial. +::: + +On top of this, a window will contain at least two of these framebuffers. This is known as **double-buffering** and is imperative for rendering to work properly. One buffer is displayed, while another is rendered to. They are then swapped between once the GPU is ready. + +This is what makes up the **swapchain**, which, if you've ever looked into Direct3D, you should be familliar with. OpenGL does not use the term, nor does it allow you to manage this yourself, however it is still in the background, and it is helpful to know this. + +Now that we know this, we can get on with clearing the window. + +Add the following using directive to the top of your file: + +```cs +using System.Drawing; +``` + +Then, in your `OnLoad` method, add the following: + +```cs +_gl.ClearColor(Color.CornflowerBlue); +``` + +You may notice that this function contains various **overloads**, including ones for a `System.Numerics.Vector4`, and 4 floats. We'll be using the overload that takes `System.Drawing.Color`, because it is the easiest to use and understand. + +If you run your application now, you'll notice that the window is still black. That's because we've set the clear *color*, but not actually told OpenGL to clear the window. + +In your `OnRender` method, add the following: + +```cs +_gl.Clear(ClearBufferMask.ColorBufferBit); +``` + +Run your application again, and you should see a lovely sky blue window! + +![Sky blue window](assets/2-helloQuad/cornflower-window.png) + +Congrats! You've done your first thing in OpenGL! + +But - how does OpenGL know to color the window blue? Sure, we've told it we want blue - but we only did that once... How does it know to keep using blue? + +Well, this is because OpenGL is a **state machine**. + +## OpenGL: The state machine +Before we can continue further, you'll have to get used to the concept that OpenGL is a **state machine**. It's really hard to understand OpenGL if you don't understand this, so read closely. + +### What is a state machine? +At its core, a state machine holds... state. You set the state of something, and it retains that state until you change it. + +This is exactly how OpenGL works. Once you set something, it will remain set until you change it. This counts for everything in OpenGL. Clear color, binding objects, etc etc, everything goes through the state machine. You can *manipulate* the current state, however you have to be wary at all times of what part of the state you are changing. Change the wrong thing and suddenly you program might not work! + +So, this explains why clearing the window works. You set the clear color, and it remains *as* the clear color until you change it. + +Now that we've got that, let's move on! + +## Vertex Array Objects (VAOs) +A unique feature that modern OpenGL has is what is known as a Vertex Array Object, or VAO. It stores all the necessary information required to draw an object to the screen, such as the vertex data (which we'll get into in a minute), and also information on how to read this data. + +This is a required feature of modern OpenGL. You **must** have a VAO bound, otherwise your application won't work. + +Let's create the VAO! + +At the top of your class, add the following: + +```cs +private static uint _vao; +``` + +Then, in your `OnLoad` method, add: + +```cs +_vao = _gl.GenVertexArray(); +_gl.BindVertexArray(_vao); +``` + +What's going on here? First, we generate the VAO. Then, before we can use, or update it, we need to **bind** it. + +Binding is a term you will hear a lot with OpenGL, and in these tutorials too. Binding essentially means updating the current OpenGL state with the given object. So, in this example, when we bind the VAO, we update OpenGL's state so that the VAO in the state machine is now the VAO we have just created. If you don't bind an object before updating/using it, you will use or update the previously bound object instead, which can cause problems and headaches later. + +We're now ready to give the VAO some data. But first, we need a **vertex buffer**. + +## Vertex Buffer Objects (VBOs) +Here is the part where we actually give the GPU some data it can work with. For most graphics applications, a vertex buffer is **required** to display anything on screen. + +### What is a vertex buffer? +Before we can continue, it's handy to know what a vertex buffer is, and what it does. + +Let's define both vertex, and buffer. + +* Vertex - A point where two lines, or edges meet. +* Buffer - A region in memory that can be accessed to be written to, or read from. + +Knowing these definitions should give us a good idea of what a vertex buffer is. It's a region of memory, on the GPU, that stores points, which will get **rasterized** on-screen (usually in the form of triangles). + +### Vertex data +Let's create the data that we will fill the vertex buffer with! + +In your `OnLoad` function, just after you call `_gl.BindVertexArray()`, add the following: + +```cs +float[] vertices = +{ + 0.5f, 0.5f, 0.0f, + 0.5f, -0.5f, 0.0f, + -0.5f, -0.5f, 0.0f, + -0.5f, 0.5f, 0.0f +}; +``` + +### What makes up a quad? +In modern graphics programming, you are expected to use triangles, lines, or points. While you may see options for quads, these are obsolete. + +Therefore, a quad is made of two right-angle triangles. This can best be seen if we view the result in **wireframe** mode. + +![Wireframe quad](assets/2-helloQuad/wireframe-quad.png) + +In the image, you can also see where the four vertices go in relation to the quad. While you won't *usually* be defining vertices yourself, it's still handy to know how it works. + +### Creating the buffer +Now that we've got our vertex data, let's create the buffer! + +At the top of your class, add the following: + +```cs +private static uint _vbo; +``` + +Then, in your `OnLoad` method, under where the vertices are defined, add: + +``` +_vbo = _gl.GenBuffer(); +_gl.BindBuffer(BufferTargetARB.ArrayBuffer, _vbo); +``` + +Much like the VAO, we need to first generate the buffer, and then bind it. Unlike vertex arrays, however, buffers need to be bound to a **target**. This allows you to bind buffers to different targets at the same time. Some of the more common targets include: + +* `ArrayBuffer` - The vertex buffer target (which is what we're using here). +* `ElementArrayBuffer` - The element array buffer target (which you'll see later). +* `UniformBuffer` - A uniform buffer, not used in this tutorial, but we'll get to it in a later tutorial. + +In this case, we're binding to `ArrayBuffer` since we're creating a vertex buffer. + +### Filling our buffer with data +Let's fill our buffer with some data! Before we do that though, you need to be aware of `unsafe` in C#. + +#### Unsafe C# +Silk.NET heavily uses `unsafe` code. Don't worry, this won't make your computer explode, however it does exit out of the "memory safe" managed environment of C#, and enters a realm where undefined behavior, segmentation faults, and strange results are more likely to occur if you are not careful. Since we're working with low-level APIs, and OpenGL is defined in plain C, some unsafe code will be necessary in order for us to be able to communicate with it from C#. + +:::note +If you wish to use `Span` instead, and remain in `safe` mode, Silk.NET does support these too. However, I will be using `unsafe` in this tutorial instead, as this is both what I personally use, as well as what the samples use. +::: + +Unsafe mode is not enabled by default, so we need to enable it. To enable it: +- If you're on Visual Studio 2022, open your project properties and under Build --> General, make sure the box that says "Unsafe code" is checked. +- You can also edit your project's `.csproj` file manually, by adding an `true` inside the ``. + +This will now allow you to use the `unsafe` keyword, which allows a block of code to contain unsafe code. You now **MUST** add `unsafe` to your `OnLoad` and `OnRender` methods, like so: + +```cs +public static unsafe void OnLoad() { ... } +``` + +If you forget to do either of these, you'll get compile errors. While our `OnRender` method does not contain any unsafe code yet, it will when we draw to the screen later, so it's best just to do it now so you don't forget to do it later. + +Now let's fill the buffer! + +Add the following to your `OnLoad` method: + +```cs +fixed (float* buf = vertices) + _gl.BufferData(BufferTargetARB.ArrayBuffer, (nuint) (vertices.Length * sizeof(float)), buf, BufferUsageARB.StaticDraw); +``` + +Let's go over what's going on here. First, we `fix` the vertex data. This prevents the garbage collector from moving it around, so we can take a pointer to the data. We then call `_gl.BufferData` and tell it the target we want, `ArrayBuffer` in this case, give it the data length (measured in bytes), the buffer pointer, and we choose `StaticDraw` for our usage hint. + +What is a usage hint? A usage hint simply tells the GPU how we plan on using this data. These are some of the most common usage hints you'll use in an OpenGL application: + +* **StaticDraw** - Set the data once, and it can only be read from by the GPU (in this case for drawing) +* **DynamicDraw** - Similar to StaticDraw, however the data will be set & updated more than once. + +There are a lot more usage hints, including `StreamDraw` and variants of these hints with `XyzCopy` and `XyzRead`, but they are not as common in most OpenGL applications. On top of this, the usage hint is only a *hint*. Most OpenGL drivers interpret these hints the same way, and it is perfectly valid to set the data with a `StaticDraw` hint. However, you should still get into the practice of using the correct usage hint, as some APIs such as Direct3D *do* care about the hint you use. + +Now, run the program again, and if you get the same blue window, you've set the buffer data successfully! + +Now, let's create the **element buffer object**. + +## Element Buffer Objects (EBOs) +Unlike a vertex buffer, an element buffer is not *strictly* required to display something on screen, however not using it in some cases may require making your vertex buffer a lot larger, with a lot more duplicate data. + +For those familliar with Direct3D terms, EBOs are more commonly referred to as **index buffers**, which is what this tutorial will refer to them from now on. + +Take a look at the `vertices` array we defined earlier. You may have noticed that it only has four different points in it. Great! That's how you make a quad. But remember - that's not how this works. As mentioned earlier, a quad is made up of two triangles. But wait - that's six points... But we've only defined four. What's going on? + +Well, that's where index buffers come in! An index buffer simply tells the GPU which points in the vertex buffer to use for each triangle. + +Add the following to your `OnLoad` method: + +```cs +uint[] indices = +{ + 0u, 1u, 3u, + 1u, 2u, 3u +}; +``` + +Now, you may be looking at this thinking "what is this?". Don't worry, once you know what it's doing it's quite easy to wrap your head around. + +You'll notice that it contains 6 values. These values correspond to an index in our vertex buffer (notice how the maximum value is 3, which is the maximum index in our vertex buffer.) + +Take a look at the [image you saw earlier](#what-makes-up-a-quad). The points are representitive of a value in the vertex buffer. If you trace each point, you'll see it's in clockwise order (top left is the first point, bottom left is the last point). Assign each of these an incrementing value from 0-3. Then, trace out the indices we defined above. You may notice that you'll trace out two triangles, making up our quad. + +Great! Hopefully you now have a better understanding of how index buffers allow you to reduce the amount of duplicate data in the vertex buffer. If we didn't use an index buffer, we'd have to define the top left, and bottom left points twice! + +### Creating the buffer +Creating the EBO is very similar to creating a vertex buffer. + +First, we must create and bind the buffer itself. Add the following to your `OnLoad` method: + +```cs +_ebo = _gl.GenBuffer(); +_gl.BindBuffer(BufferTargetARB.ElementArrayBuffer, _ebo); +``` + +Then, we fill the buffer with data, much in the same way as we did with the vertex buffer. + +Again, add the following to your `OnLoad` method: + +```cs +fixed (uint* buf = indices) + _gl.BufferData(BufferTargetARB.ElementArrayBuffer, (nuint) (indices.Length * sizeof(uint)), buf, BufferUsageARB.StaticDraw); +``` + +And that's it! In OpenGL, this is the common way you'll **create** buffers, from VBOs, to EBOs, to UBOs. + +Run the program again, and if you still see the blue window, you've successfully created the EBO! + +Now we can move onto the **shader**. + +## Shaders +This tutorial won't go fully into detail about what shaders are and how they work, instead we'll leave that for a later tutorial, but in essence, a shader is a small program that runs on your GPU, that tells it how to process and display the data in our buffers. + +There are many different types of shaders: +* Vertex +* Fragment (or Pixel, as used by Direct3D) +* Geometry +* Compute +* Tessellation + +These shaders all serve different purposes, however the most commonly used shaders are the **vertex** and **fragment** shaders, and we will be using those in this tutorial. + +A vertex shader is run (invoked) for every vertex in the vertex buffer. The vertex buffer is where you perform transformations such as translating, rotating or scaling and object. Once the vertex shaders are done running, our vertices are arranged into **primitives** (in our case, triangles), and the on-screen pixels these triangles occupy are filled by fragment shaders. This process is called **rasterization**. + +The fragment shader is invoked for every fragment of every primitive on screen. A fragment is essentially a pixel, and Direct3D even calls them pixel shaders. As you may expect, these shaders are a lot more intensive than vertex shaders, and can often be the cause of GPU slowdowns, given that a single triangle may only invoke three vertex shaders, but can result in hundreds or thousands of fragment shader invocations! + +Fragment shaders is where you perform the stuff that gets displayed on screen, such as texturing and many forms of lighting. + +For the moment, this is all you need to know about shaders. You will learn more about shaders as we progress further in this tutorial, as knowing how shaders work and operate is a vital thing to know when it comes to modern graphics programming. The sky is the limit! (Or in our case, an endless cornflower blue void...) + +### The shader code +Before we can create our shader objects, we need some shader code. OpenGL uses **GLSL** (Open**GL** **S**hading **L**anguage). Syntactically, it is quite similar to C. Don't worry though, there are no pointers in sight. + +#### Creating the vertex shader + +Add the following to your `OnLoad` method: + +```cs +const string vertexCode = @" +#version 330 core + +layout (location = 0) in vec3 aPosition; + +void main() +{ + gl_Position = vec4(aPosition, 1.0); +}"; +``` + +This is our vertex shader! Let's go through it line-by-line. + +First, we must tell it which GLSL version we wish to use. Since OpenGL 3.3 (the version we are using), the GLSL version corresponds to the OpenGL version. We tell it we want `core`, as we are using Core OpenGL 3.3, rather than compatibility. + +Next, we define our **shader attributes**. In our example, we only have one, which is the position we defined in the vertex buffer. Remember - the vertex shader is executed *for each* vertex in the vertex buffer, which is why we only need one value at a time. We define it at a manual "location", 0. While this is not necessary, we will be using it in this tutorial, as certain drivers (such as intel) like to use random locations if you do not specify one, which can cause many problems if you are not careful. + +Much like C, we define our entry point, the `main` function. In it, we set the value of `gl_Position` to the vertex position. As we are not performing any transformations, we simply set the input value directly to the output value. `gl_Position`, which is a built-in shader variable, only accepts a `vec4` value though, so we must convert `aPosition` to `vec4` first. You may notice we use `1.0` for the W value instead of `0.0` though. While in this case it does not matter, it's a habit you should get into, as this will become very important when we start using matrices and transformations. + +#### Creating the fragment shader +Our fragment shader for this example is very simple. + +Add the following to your `OnLoad` method: + +```cs +const string fragmentCode = @" +#version 330 core + +out vec4 out_color; + +void main() +{ + out_color = vec4(1.0, 0.5, 0.2, 1.0); +}"; +``` + +In our fragment shader, we simply output a single color, in this case a reddish-orange. + +Because our fragment shader is so simple, we don't use any `in` attributes for this example. However, unlike a vertex shader, a fragment shader must **always** have at least one `out` attribute. This attribute is the output color of the fragment shader itself, and must always be assigned a value. (We'll get more into this in a later tutorial). The output color is in the RGBA format. In OpenGL, the output color in the fragment shader is a **normalized** 32-bit float. Therefore, each of the RGBA values must be between 0 and 1. This is also true for our clear color too, however Silk.NET handily accepts a `System.Drawing.Color`, which we are using in this tutorial. + +#### Creating the shader objects +Let's create the shader objects! + +Add the following to your `OnLoad` method: + +```cs +uint vertexShader = _gl.CreateShader(ShaderType.VertexShader); +_gl.ShaderSource(vertexShader, vertexCode); +``` + +First, we create the shader object itself. Each shader object must be assigned a **type**, in this case the vertex shader. Then we simply give the shader the code we defined earlier. + +Now we need to **compile** the shader. + +Add the following to your `OnLoad` method: + +```cs +_gl.CompileShader(vertexShader); + +_gl.GetShader(vertexShader, ShaderParameterName.CompileStatus, out int vStatus); +if (vStatus != (int) GLEnum.True) + throw new Exception("Vertex shader failed to compile: " + _gl.GetShaderInfoLog(vertexShader)); +``` + +First, we compile the shader. Then, we need to check to make sure it has compiled correctly, and if it hasn't, it needs to let us know what our error is. `glGetShader` can give us a lot of different parameters, some of which we'll be using in later tutorials. For now, we are just interested in the compile status. + +The compile status returns `1` if successful, and `0` if not. If it's not successful, we throw an exception. `glGetShaderInfoLog` gets the error string for the shader, and we output that in our exception. You don't *have* to throw an exception though, you can do whatever you wish with this result. Just don't try to continue further, as you will get a link error! (We'll get to this in a minute). + +We've now successfully created and compiled our vertex shader object. Creating the fragment shader object is almost exactly the same, with only a few parameters changed. + +Add the following to your `OnLoad` method: + +```cs +uint fragmentShader = _gl.CreateShader(ShaderType.FragmentShader); +_gl.ShaderSource(fragmentShader, fragmentCode); + +_gl.CompileShader(fragmentShader); + +_gl.GetShader(fragmentShader, ShaderParameterName.CompileStatus, out int fStatus); +if (fStatus != (int) GLEnum.True) + throw new Exception("Fragment shader failed to compile: " + _gl.GetShaderInfoLog(fragmentShader)); +``` + +And with that, we've created and compiled both of our shader objects! Now, we need to create the shader program. + +#### Creating the program +Finally, we can create the **shader program**. In OpenGL, shaders are stored in a single **program** object. + +First, add the following to the top of your file: + +```cs +private static uint _program; +``` + +Then, add the following to your `OnLoad` method: + +```cs +_program = _gl.CreateProgram(); +``` + +Now that we've created the program, we now need to attach the shaders to it and **link** them to the program. + +Add the following to your `OnLoad` method: + +```cs +_gl.AttachShader(_program, vertexShader); +_gl.AttachShader(_program, fragmentShader); + +_gl.LinkProgram(_program); + +_gl.GetProgram(_program, ProgramPropertyARB.LinkStatus, out int lStatus); +if (lStatus != (int) GLEnum.True) + throw new Exception("Program failed to link: " + _gl.GetProgramInfoLog(_program)); +``` + +Much like before, we must check to make sure that the program has linked correctly. Link errors are most often caused by things like a typo in an `in` or `out` variable name, or attempting to link with a shader that has failed to compile, which, assuming you implemented the checks earlier, should basically never happen. + +Now that we have linked the program, it can now function by itself, and we no longer need the shader objects. Therefore, we can **detach and delete** them, freeing a bit of GPU memory. + +Add the following to your `OnLoad` method: + +```cs +_gl.DetachShader(_program, vertexShader); +_gl.DetachShader(_program, fragmentShader); +_gl.DeleteShader(vertexShader); +_gl.DeleteShader(fragmentShader); +``` + +Now, run your program again. If you get no errors, this has all worked successfully! + +### Setting up the attributes +The last thing we need to do before we can begin drawing our quad to the screen is to set up the attributes. By default, OpenGL does not know how to send the data to our shader, so we must tell it. + +This is done with the **attribute setup**. This sets various parameters in the VAO, which tells OpenGL how to read the vertex data in the vertex buffer. As vertex buffers can contain more than just position data (it can contain almost anything you want), it is vital that OpenGL knows how to separate out the individual bits of data, so it can pass it to the shader correctly. + +:::warning +While fragment shaders (and other shaders) can have `in` attributes, the only ones you can directly set *outside* of a shader are the ones going into the vertex shader. The only way to set attributes in the fragment shader is to pass them through the vertex shader. Therefore, the attribute setup only affects the vertex shader and vertex buffer, not any other shader. +::: + +Add the following to your `OnLoad` method: + +```cs +const uint positionLoc = 0; +_gl.EnableVertexAttribArray(positionLoc); +_gl.VertexAttribPointer(positionLoc, 3, VertexAttribPointerType.Float, false, 3 * sizeof(float), (void*) 0); +``` + +Let's go over what is going on here. + +`positionLoc` simply refers to the `aPosition` attribute we defined in our vertex shader earlier. Since we explicitly stated we wanted it at position 0, we must also use that here. If you decided against explicitly giving a location in your shader, you can replace the `0` with `_gl.GetAttribLocation("aPosition");` (just remember to remove the `const` too...) + +Before we can use the attribute, we must first enable it. Then, we tell it what part of the data to look at. + +First, we tell it the size of the attribute's data type. Since we're using a `vec3`, we tell it that the size is 3. Next up, we tell it that we're using floats. This is the most common pointer type used. The `false` tells it we don't want to normalize the values. If we did normalize them, OpenGL would convert them to between 0 and 1. Finally, we have the **stride** and **offset**. + +The stride tells OpenGL the size (in bytes) of a *single* vertex. The offset tells OpenGL the offset *within* the stride of the attribute. + +This diagram gives a visual explanation of what stride and offset do (credit to LearnOpenGL): + +![stride and offset](assets/2-helloQuad/vertex_attribute_pointer.png) + +In our example, the only things we define per vertex is the position of the vertex itself, which is 3 values per vertex. Therefore, our stride is just `3 * sizeof(float)` (remember, stride is in **bytes**, so we must multiply by the size of the float primitive). Since we are only defining one attribute, we don't need to have any offset. Therefore, we can just use `0`. OpenGL expects a `void` pointer, so we must cast it to `void*`. + +### Cleaning up +We're nearly there. The last thing we should do is to unbind the various buffers. While you don't *need* to do this, it will help to reduce the risk of changing a value for the wrong buffer. + +Add the following code to your `OnLoad` method: + +``` +_gl.BindVertexArray(0); +_gl.BindBuffer(BufferTargetARB.ArrayBuffer, 0); +_gl.BindBuffer(BufferTargetARB.ElementArrayBuffer, 0); +``` + +Doing this means we've "un-bound" everything, so calling something like `BufferData` won't affect the buffers we've just created. + +:::warning +You **MUST** unbind the vertex array first, before unbinding the other buffers. If you forget to do it in this order, the buffer will be unbound from the vertex array, meaning you'll see incorrect results when you render the object. +::: + +If you want to see the resulting code so far, you can see it [here](../sources/1.2.7-finished-setup.html). + +## Drawing to the screen +It's finally time to draw to the screen! That was a lot of setup work we just did there. Fortunately, that was the hard part. Drawing our result to the screen is now very easy. + +Add the following to your `OnRender` method: + +```cs +_gl.BindVertexArray(_vao); +_gl.UseProgram(_program); +_gl.DrawElements(PrimitiveType.Triangles, 6, DrawElementsType.UnsignedInt, (void*) 0); +``` + +That's all we need to draw our quad to the screen! Yes, seriously. + +Let's explain what's going on here. + +First, we bind our vertex array. Before we can draw anything, we need to have a vertex array bound. The vertex array you bind will depend on what you want to draw. Next, we use the program object we created earlier. Again, we must have a program bound before we can draw. + +Finally, we tell the GPU to draw. We're using `glDrawElements` here, as we used an EBO. If we didn't use an EBO, we'd want to use `glDrawArrays` instead. + +The first parameter tells it that we're drawing triangles (triangle list to be precise, there are other triangle types we don't need to worry about for now.). + +The `6` is simply the number of elements in our EBO. Remember, a quad is two triangles, with three vertices per triangle, making six vertices total. + +We tell it we're using an unsigned int as the element type (you may have noticed earlier that `indices` was of type `uint[]`). The most commonly used values are `UnsignedInt` and `UnsignedShort`. Some older GPUs only supported `UnsignedShort`, however all modern GPUs can fully support `UnsignedInt`, so this isn't really something you need to worry about anymore. + +The last parameter is a pointer to the starting index of the indices. Since we want all the indices, we just set this value to `0`. Much like the offset in our vertex attributes, OpenGL expects a `void` pointer, so we must cast this to `void*`. + +And that's it! Run your program and you should see a lovely orange rectangle on a blue background. Exciting, isn't it... Right...? + +![Final result](assets/2-helloQuad/final-result-t2.png) + +While this may have seen like a lot of set up for a boring result, this code can render pretty much anything you want to the screen. It remains pretty much the same, whether you're rendering a basic quad like this, or a complex 3D model. All you need to change are the vertices & indices going in, and some more complex shader code to handle the transformations. + +Once you get the basics understood and you can confidently use it, creating more complex stuff becomes a lot easier. + +If you would like to view the full source code for the application, you can view it [here](../sources/1.2-final-result.html). + +## Cleaning up +When you're done with an OpenGL resource, you should delete it, to free GPU memory. For this though, it's not needed. The driver will automatically clean all created resources when your application closes. In fact, it's recommended that you *don't* manually delete resources when the application closes. The driver can free these objects a lot faster than manually removing them. If you have a lot of objects, manually deleting can cause the application to hang while the driver tries to free everything. + +You **MUST** remember to remove unused objects while your application is running, however, as forgetting to do so will use more and more of the GPU's memory, potentially causing it to run out of memory. OpenGL isn't garbage collected! It requires manual memory management, a lot like C. diff --git a/website/docs/opengl/3-helloTexture.md b/website/docs/opengl/3-helloTexture.md new file mode 100644 index 0000000000..3f28a3e8a2 --- /dev/null +++ b/website/docs/opengl/3-helloTexture.md @@ -0,0 +1,462 @@ +# 1.3 - Hello Texture + +:::note +You can view the source code for this tutorial [here](../sources/1.3-final-result.html). This tutorial builds on the previous tutorial. If you haven't read it, you can do so [here](1-hello-window.html). +::: + +In the previous tutorial, we've shown you how to open an OpenGL window and draw a colored quad. + +Another very important thing in graphics programming is the ability to draw images. In this tutorial, you'll learn: + +* What a texture is. +* How to send more data to shaders. +* How to use texture coordinates. +* How to import images as textures. +* How shaders handle images. +* How OpenGL handles transparency. +* How to use texture parameters. +* What are mipmaps and how to use them. + +## What a texture is +Textures are multidimensional objects that store color data. + +The most common type of texture is a 2D texture, which stores the 2D grid of pixels that makes up an image. This is just for comparison though, +as texture objects are a lot more complex than just 2D arrays! +This data is stored in GPU memory, and can be read by a shader. + +:::note +There are multiple different dimensions of texture from 1D through to 3D. For the purposes of this tutorial, we will be focusing on 2D. +::: + +Textures are quite finicky to setup, and need quite a bit of information in order to be drawn. +The most important piece of information that we need to send to the texture to see it on the screen are the texture coordinates. +The texture coordinates are the positions within the texture for a particular vertex. Below we will learn how to fill out this data and read it from a shader. + +## Sending more data to shaders +Texture coordinates are a type of data that can be manipulated by the vertex shader before it is used by the fragment shader. +This means that this data needs to be passed to the vertex shader which, as per the previous tutorials, is once again done using a vertex buffer. + +Let's go back to our `OnLoad` function and update our `vertices` array to the following: +```cs +// The quad vertices data. Now with Texture coordinates! +float[] vertices = +{ +// aPosition | aTexCoords + 0.5f, 0.5f, 0.0f, 1.0f, 1.0f, + 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, + -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, + -0.5f, 0.5f, 0.0f, 0.0f, 1.0f +}; +``` + +With how we have structured the data, both the vertex and texture coordinates can be stored in a single array. + +If we try to run our program now... + +![A really messed up quad!](./assets/1-helloWindow/cornflower-window.png) + +Well, that doesn't look like the quad we were expecting. This is because we have updated the vertex buffer we're passing to the vertex shader, +but haven't updated anything else such as our vertex layout definition. Luckily, it's very easy to modify the the example vertex layout +shown in the previous tutorial to work with our new texture coordinates. + +In our `VertexAttribPointer` calls, we declared an `aPosition` attribute with a size of 3 floats and a stride of 12 bytes (`3 * sizeof(float)` equals 12). +Because of this, our buffer is being read like this: + +![Buffer reading wrong data](./assets/1-helloWindow/cornflower-window.png) + +As you can see, the vertex buffer is being read as if the first vertex was composed of the first three floats in the buffer, then the second +vertex the next three floats, the third vertex the next three, and so on and so forth. However, this is now wrong! Since each +vertex has two UV floats after its three position floats, this means that the first vertex's U and V floats are being read as the second +vertex X and Y position floats! + + +To fix this, we just need to go back to our `VertexAttribPointer()`, which is below our shader compiling section, and +change it to: +```cs +// 3 floats for position + 2 floats for texture coordinates! \/ +_gl.VertexAttribPointer(positionLoc, 3, VertexAttribPointerType.Float, false, 5 * sizeof(float), (void*)0); +``` + +This will make the buffer be read like this (including the texture coordinate pointer, which we'll add into our code later): + +![Buffer reading right data](./assets/1-helloWindow/cornflower-window.png) + +Now the positions of each vertex are being read correctly! Each position is still three floats, but by skipping the two floats after each position, +we skip over the U and V floats in between each XYZ floats, thus reading them correctly. + +If we run the program now, we can see our quad again! + +## Using texture coordinates +Now, we just need to prepare the shader to receive the texture coordinate values. For that, we need to modify both our shaders. + +Vertex Shader: +``` +#version 330 core + +layout (location = 0) in vec3 aPosition; +// Add a new input attribute for the texture coordinates +layout (location = 1) in vec2 aTextureCoord; + +// Add an output variable to pass the texture coordinate to the fragment shader +// This variable stores the data that we want to be received by the fragment +out vec2 frag_texCoords; + +void main() +{ + gl_Position = vec4(aPosition, 1.0); + // Assigin the texture coordinates without any modification to be recived in the fragment + frag_texCoords = aTextureCoord; +}"; +``` +In this case, we are manually specifying the `location` of `aTextureCoord` as 1, because we already have an attribute in the location 0. + + +Fragment Shader: +``` +#version 330 core + +// Receive the input from the vertex shader in an attribute +in vec2 frag_texCoords; + +out vec4 out_color; + +void main() +{ + // This will allow us to see the texture coordinates in action! + out_color = vec4(frag_texCoords.x, frag_texCoords.y, 0.0, 1.0); +} +``` +As you already know, the Vertex Shader runs for every vertex of the mesh and the Fragment Shader runs for every pixel inside the mesh. +This conversion looks weird at first glance, but the data communication between vertex and fragment shader are surely possible because +OpenGL automatically interpolates the data outputted by the Vertex Shader when it's received by the Fragment Shader. + +Now we just need to assign the correct layout for `aTextureCoord`. You should add these lines below our first `VertexAttribPointer` call: + +```cs +const uint texCoordLoc = 1; +_gl.EnableVertexAttribArray(texCoordLoc); +_gl.VertexAttribPointer(texCoordLoc, 2, VertexAttribPointerType.Float, false, 5 * sizeof(float), (void*)(3 * sizeof(float))); +``` +Here we're specifying a new vertex attribute, which consists of two floats and repeats every 20 bytes (`5 * sizeof(float)` = 20, +that's the size of one vertex). + +Pay attention to the last parameter, the pointer! It represents the number of bytes by which the offset within the vertex buffer +should be incremented before reading the vertex attribute data. This means that for this attribute OpenGL will advance past first +3 floats (`3 * sizeof(float)`) worth of data (which are our vertex XYZ coordinates) and instead read the next 2 floats after that. + +If you do everything right, you will see this result! + +![Quad with UVs](./assets/1-helloWindow/cornflower-window.png) + +This gives us a nice visualisation of the texture coordinates, but it's not a textured quad. What exactly are we looking at? +What you are seeing is the texture coordinates we passed displayed as a color! + +The Red, Green and mix between these two colors you see are, respectively, the X and Y texture coordinate values of that pixel. +In the shader, the values are being read like this: + +![UV values](./assets/1-helloWindow/cornflower-window.png) + +As you can see, as the X/U coordinate increases so does the amount of red in the output pixel, and likewise as the Y/V coordinate increases so does the amount of green. +Even though we only specified UV values for each vertex, all pixels in the quad have UV values. That's because, as you read before, +the fragment shader interpolates the coordinates for us, saving us a lot of work on our end. +If we follow the diagonal from (0, 0) to (1, 1), the amount of red and green in the output color increases at the same rate, resulting in a yellow color. + +## Importing images as textures +Now for the fun part: rendering an image! + +To start this section, first download +[silk.png](https://github.com/dotnet/Silk.NET/blob/477154b99564aac9cf82426754857103fb88d2ea/examples/CSharp/OpenGL%20Tutorials/Tutorial%201.3%20-%20Textures/silk.png). +We will use this image in this tutorial! + +In most cases with OpenGL, textures are uploaded as a sequence of bytes, this is usually done with a layout of 4 bytes per pixel (Red, Green, Blue, and Alpha). +The hard part is: we can't just upload the bytes of a `.png` or `.jpg` file! These formats have a lot of unnecessary data, like headers and, most importantly, +they're compressed, which the GPU generally cannot understand. + +To load an image file as a byte array, we will first need an external library. In our case, we will use StbImageSharp. + +First of all, install the library using NuGet. To do so, you can use your IDE's NuGet package manager, +or you can run the following command inside your project folder: +``` +dotnet add package StbImageSharp +``` + +After installing, add the following reference on the top of your code file: +```cs +using StbImageSharp; +``` + +At the top of your class, declare a `uint` to store the ID of the OpenGL texture object: +```cs +private static uint _texture; +``` + +Returning to your `OnLoad` method, add these lines at the end of the method to create and bind the texture. +That `ActiveTexture` call is telling OpenGL that we are wanting to use the first texture unit. +```cs +_texture = _gl.GenTexture(); +_gl.ActiveTexture(TextureUnit.Texture0); +_gl.BindTexture(TextureTarget.Texture2D, _texture); +``` + +:::note +Texture units are locations in the OpenGL state where textures can be bound. Instead of textures being specified directly to shader samplers, +textures are bound to a texture unit, and the texture unit is then specified to the shader sampler. +::: + +After that, we need to load the image. You can do it with the following line: +```cs +// ImageResult.FromMemory reads the bytes of the .png file and returns all its information! +ImageResult result = ImageResult.FromMemory(File.ReadAllBytes("silk.png"), ColorComponents.RedGreenBlueAlpha); +``` + +Now, with the image in memory, we need to upload the data to the GPU texture. To do that, we need a pointer for our bytes, the width, and the height of +the texture. None of it is hardcoded, you get all this information inside `ImageResult`. +```cs +// Define a pointer to the image data +fixed (byte* ptr = result.Data) + // Here we use "result.Width" and "result.Height" to tell OpenGL about how big our texture is. + _gl.TexImage2D(TextureTarget.Texture2D, 0, InternalFormat.Rgba, (uint)result.Width, + (uint)result.Height, 0, PixelFormat.Rgba, PixelType.UnsignedByte, ptr); +``` + +Remember when we talked about the different types of textures (1D, 2D, 3D, etc)? Well, how does OpenGL know what type of texture we want when we call `GenTexture()`? +The answer is, _it does not!_ So the first thing this call does is tell OpenGL that our texture is a 2D texture (alternatively, if we'd have used TexImage1D or +TexImage3D, we'd have gotten a 1D or 3D texture respectively). + +Then we specify the format of our texture's pixels. Pixels can be represented in a variety of formats; we'll use RGB, but pixels can also be R (just red), +RG (red and green), or even floating point types! After that we specify the width and height of the 2D texture, and lastly we specify data to upload to the texture. + +`TexImage2D` allows us to not only set the texture's type, but also optionally upload its image data. `PixelFormat.Rgba` and `PixelType.UnsignedByte` indicate, +respectively, that we're uploading raw pixel data organized in RGBA format, with each pixel channel (R, G, B, and A) being an unsigned byte. If we wanted to create +the texture without setting any data, we would replace `ptr` with a null pointer, `(void*)0`. + +Now, with the texture data sent off to the GPU, we need to configure the texture parameters. This is one of the most important steps. It is with these +parameters that the shader knows how to sample colors from the texture using our provided texture coordinates. + +These will be explained in depth in [the following section on texture parameters](#texture-parameters). +Briefly, these affect how the texture is sampled when we use it in the shader. +```cs +_gl.TexParameterI(GLEnum.Texture2D, GLEnum.TextureWrapS, (int)TextureWrapMode.Repeat); +_gl.TexParameterI(GLEnum.Texture2D, GLEnum.TextureWrapT, (int)TextureWrapMode.Repeat); +_gl.TexParameterI(GLEnum.Texture2D, GLEnum.TextureMinFilter, (int)TextureMinFilter.Nearest); +_gl.TexParameterI(GLEnum.Texture2D, GLEnum.TextureMagFilter, (int)TextureMagFilter.Nearest); +``` + + +And now, just as we did with the other resources, let's unbind the texture to clean up. +```cs +_gl.BindTexture(TextureTarget.Texture2D, 0); +``` + +## Handling texture data in shader +Now, let's finally show it on the screen! + +In your fragment shader, add this `uniform` declaration: +``` +uniform sampler2D uTexture; +``` + +And change this line: +``` +void main() +{ +// -out_color = vec4(frag_texCoords.x, frag_texCoords.y, 0, 1.0); + out_color = texture(uTexture, frag_texCoords); +} +``` + +In GLSL, you usually don't work with textures directly. The most common way to access a texture is using a `sampler`. +In our case, we are using `sampler2D` for our 2D texture. +To read the texture data, the `texture` method is used. It samples the color of the texture at the +specified texture coordinates and uses the previously set parameters to interpolate that color. + +But pay attention! Notice that our texture coordinates are between the ranges of `0.0` to `1.0` This is because the `texture` method works +with normalized values! To better understand this, think about a 250x500 pixels image. If you want to get the pixel at the position +(250, 250), we need to send (250 / width, 250 / height), or (1, 0.5), as the texture coordinate. This way the size of the texture doesn't matter to the shader. + +:::note +You can use the equation ` 1/size * pixel_position ` to get the normalized coordinate for a particlar axis!" +::: + +After having configured our uniform `uTexture`, we need to bind our texture unit to it. To do so, we do it using the following lines: +```cs +int location = _gl.GetUniformLocation(_program, "uTexture"); +_gl.Uniform1(location, 0); +``` +The first line calls `GetUniformLocation` that return the numeric location of the requested uniform. In this case, `"uTexture"`. +Then, we call `Uniform1` to bind the texture unit 0 in the uniform. + +Now, if you run the program, you will see just a black quad. It's because we need to bind the texture before the draw call! +If you don't do it, the last applied texture will be used for this mesh, in our case, since we have no texture bound after the clean up, no texture is used. + +To solve it, go to your `OnRender` method and, below the `_gl.UseProgram()` call, first activate the texture unit that you will use: +```cs +_gl.ActiveTexture(TextureUnit.Texture0); +``` +Recall that a texture unit is a space in memory that refers to the texture object. We need to first set the texture unit we want to use as active before we can +bind our texture to it. We're using the first texture unit `Texture0` here. + +After that we bind the texture again. Doing it after activating the texture unit will automatically attatch the texture at the texture unit 0, as a 2D texture. +```cs +_gl.BindTexture(TextureTarget.Texture2D, _texture); +``` +With that, the texture in the texture unit 0 should be set for our sampler2D. + + +And now when you run it (drumroll...), you can see the image being drawn inside the quad! + +![Quad with texture](./assets/1-helloWindow/cornflower-window.png) + +## Transparency in OpenGL +Well, you must have noticed the black corners around the texture. If you use another program to check the texture, it's completely transparent! So why isn't it rendering like so? +So why our render are drawing it like it's not? + +Transparency is a really expensive task in computer graphics. This is not a reason for you to avoid this feature, but is a reason that OpenGL doesn't enable it +by default. OpenGL has various different ways to handle transparency and it's expected that the user configures them explicitly. + +First of all, we need to enable the blend capability. at the end of `onLoad` method, add the following line: +```cs +_gl.Enable(EnableCap.Blend); +``` +Enabling blending essentially tells OpenGL to select the output colors from the visible primitives according to some value. This is referred to as blending. +In our case, we want to blend based on the alpha value. +To configure this, we use the following line: +```cs +_gl.BlendFunc(BlendingFactor.SrcAlpha, BlendingFactor.OneMinusSrcAlpha); +``` + +The `BlendFunc` function configures the calculations that OpenGL does when blending output colors. In this case, we're telling it to use the alpha value of the sources +being rendered (`BlendingFactor.SrcAlpha`) as the factor and to subtract that value from 1 to get the output value. With this, in most cases transparency will work exactly +as you expect. + +If this isn't sufficient, there are a large amount of other blending function configurations you can use, which you can find in [the Khronos documentation](https://registry.khronos.org/OpenGL-Refpages/gl4/html/glBlendFunc.xhtml). + +And when you run the program now, the transparent pixels of the image will not be visible anymore: + +![Quad with texture and transparency](./assets/1-helloWindow/cornflower-window.png) + +you can see the code final result [clicking here](../sources/1.3-final-result.html). + +## Texture parameters +And now, some extra content to go with this tutorial! + +If you get curious about how the texture parameters work, let's learn it now! + +First, let's learn the structure of the command: +```cs +_gl.TexParameter( [Texture target] , [Parameter to change] , [New value for parameter] ); +// The suffix of TexParameter will vary depending on the type of the expected value for the parameter +``` + +The texture ID you already know. So let's learn what each parameter means! + +### `TextureWrapS` & `TextureWrapT`: +`TextureWrap` is the parameter that allows you to say what the `texture` method (in the fragment shader) should do with values lesser than 0 and +greater than 1. The `S` and `T` refer to X and Y respectively. + +Let's see the most common values for these parameters: + +#### `TextureWrapMode.Repeat`: +Just repeats the image without any change, turning any coordinates outside the [0, 1) range by taking the fractional part of said number. +![Repeat](./assets/1-helloWindow/cornflower-window.png) + +#### `TextureWrapMode.MirroredRepeat`: +Mirror the texture for each 1 texture coordinate unit. +![Mirrored](./assets/1-helloWindow/cornflower-window.png) + +#### `TextureWrapMode.ClampToEdge`: +Returns the pixel on the respective edge of the image. +![A weird border](./assets/1-helloWindow/cornflower-window.png) + +### `TextureMinFilter` & `TextureMagFilter`: +When we draw a texture, the area on the screen in which we're drawing the texture typically doesn't have the same size or shape as the texture. This means that during rendering we +usually have to either scale up or down the size of the texture! This process is called _filtering_. +The texture `min` (minifying) and `mag` (magnifying) filters are the filters used when the texture's final size is, respectively, lesser than or greater than the original size. +For now, we will show just the main two options and in the next section [(Mipmaps)](#mipmaps), some others will be shown. + + +#### `Texture(Min/Mag)Filter.Linear`: +The (bi)linear filter is the best for low-quality images. When the pixels are sampled from the texture, this filter will get the color of the nearest +pixels to the texture coordinates and will return a linear interpolation of them. + +This is an example from [Learn OpenGL](https://learnopengl.com/Getting-started/Textures). See how the neighbor colors are interpolated to return a different +color: + +![linear filter](./assets/1-helloWindow/cornflower-window.png) + + +#### `Texture(Min/Mag)Filter.Nearest`: +The nearest filter returns the color of the center of the nearest pixel, no interpolation is done. + +![Nearest filter](./assets/1-helloWindow/cornflower-window.png) + +:::note +As `TexParameter` functions don't accepts enuns, you will have to do a explicit convertion using `(int)` in a `TexParameterI`, for integer parameters. +::: + +## Mipmaps +Now for the last part of this tutorial. Mipmaps are an essential resource for making good renders. + +But first, what are Mipmaps? + +Mipmaps are a map of tiny versions of the texture. The following is an example of mipmap texture: +![An example of a Mipmap texture](./assets/1-helloWindow/cornflower-window.png) + +But what is this used for? + +At first look, mipmaps may seem very useless. But in reality, they are extremely important! Mipmaps are used when the texture is being rendered at a very low size, +which can cause some weird visual artifacts, even with the use of the linear filter. The most potent visual effect is something called the "moiré effect", which can +be tiring for the eyes, and generally look quite ugly. + +The purpose of a mipmap is to provide an alternative texture to the fragment shader, one with a more appropriate size for the geometry being drawn, almost completely +eliminating the moiré effect. + +An example from [Wikipedia](https://en.wikipedia.org/wiki/File:Mipmap_Aliasing_Comparison.png). It's possible to notice weird patterns +generated far away in the render without mipmaps: + +![Mipmap usage example](./assets/1-helloWindow/cornflower-window.png) + +But if you think that generating mipmaps by hand for all your textures is really hard work, don't worry! OpenGL provides a special method to +do this for you. + +Just after setting the texture parameters, add this line to your code: +```cs +_gl.GenerateMipmap(TextureTarget.Texture2D); +``` + +But this is not everything, we also need to set some parameters to tell the sampler to use the mipmaps: + +### `GL_NEAREST_MIPMAP_NEAREST`, `GL_LINEAR_MIPMAP_NEAREST`, `GL_NEAREST_MIPMAP_LINEAR` & `GL_LINEAR_MIPMAP_LINEAR`: +These parameters should be used as the texture min filter and only with textures that have mipmaps. All of these options can be categorized in two ways: +* How does it choose what mipmap level to sample from +* How does it sample color data from that mipmap +* +#### `TextureMinFilter.GL_NEAREST_MIPMAP_NEAREST`: +Will choose the mipmap with the closest size to the final image, then sample it with nearest sampling. + +#### `TextureMinFilter.GL_LINEAR_MIPMAP_NEAREST`: +Will choose the mipmap with the closest size to the final image, then sample it with linear sampling. + +#### `TextureMinFilter.GL_NEAREST_MIPMAP_LINEAR`: +Will sample the two mipmaps whose sizes are closest to the final image with nearest sampling, then linearly interpolate between those two values. + +#### `TextureMinFilter.GL_LINEAR_MIPMAP_LINEAR`: +Will sample the two mipmaps whose sizes are closest to the final image with linear sampling, then linearly interpolate between those two values. + +Knowing this, you can change the parameters for: +```cs +_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureWrapS, (int)TextureWrapMode.Repeat); +_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureWrapT, (int)TextureWrapMode.Repeat); +_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureMinFilter, (int)TextureMinFilter.NearestMipmapNearest); // <- change here! +_gl.TexParameter(GLEnum.Texture2D, GLEnum.TextureMagFilter, (int)TextureMagFilter.Nearest); +``` + +And now the mipmaps will be used. + +## Wrapping up +You've just completed another Silk.NET tutorial! Here are some next steps you can take: +* Move on to the [next tutorial](../../coming-soon.html), where we'll be abstracting away some of our code to make it easier to read. +* View the full tutorial source code on the [Silk.NET git repository](https://github.com/dotnet/Silk.NET/tree/main/examples/CSharp/OpenGL%20Tutorials/Tutorial%201.3%20-%20Textures). +* Join the [Discord server](https://discord.gg/DTHHXRt), where you can ask questions, show your stuff, and chat with everyone there. + +Something not right? [Compare your code with the final result.](../sources/1.3-final-result.html) \ No newline at end of file diff --git a/website/docs/opengl/_category_.json b/website/docs/opengl/_category_.json new file mode 100644 index 0000000000..20ca780553 --- /dev/null +++ b/website/docs/opengl/_category_.json @@ -0,0 +1,4 @@ +{ + "position" : 2, + "label" : "OpenGL" +} \ No newline at end of file diff --git a/website/docs/opengl/assets/1-helloWindow/cornflower-window.png b/website/docs/opengl/assets/1-helloWindow/cornflower-window.png new file mode 100644 index 0000000000000000000000000000000000000000..f79d9f3d402039d796196012021f897cafea236c GIT binary patch literal 11027 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 literal 0 HcmV?d00001 diff --git a/website/docs/opengl/assets/1-helloWindow/first-window.png b/website/docs/opengl/assets/1-helloWindow/first-window.png new file mode 100644 index 0000000000000000000000000000000000000000..e8e459d9e8ff605e757ea5388ff26e59f62ca735 GIT binary patch literal 12068 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 literal 0 HcmV?d00001 diff --git a/website/docs/opengl/assets/1-helloWindow/loading-rendering.png b/website/docs/opengl/assets/1-helloWindow/loading-rendering.png new file mode 100644 index 0000000000000000000000000000000000000000..dc4212231d9563646026431356c6044e91572b65 GIT binary patch literal 2809 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 literal 0 HcmV?d00001 diff --git a/website/docs/opengl/assets/2-helloQuad/final-result-t2.png b/website/docs/opengl/assets/2-helloQuad/final-result-t2.png new file mode 100644 index 0000000000000000000000000000000000000000..fc9df9e051eb892477a07ab4956d4763d153c0c2 GIT binary patch literal 11212 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 literal 0 HcmV?d00001 diff --git a/website/docs/opengl/assets/2-helloQuad/vertex_attribute_pointer.png b/website/docs/opengl/assets/2-helloQuad/vertex_attribute_pointer.png new file mode 100644 index 0000000000000000000000000000000000000000..2a2fcb56126be7d8dd46975e28ae2bc1ae8f36c0 GIT binary patch literal 9997 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 YjFeqw!5`wz5CH(7g8J)fIrGr}0I@M?aR2}S literal 0 HcmV?d00001 diff --git a/website/docs/opengl/assets/2-helloQuad/wireframe-quad.png b/website/docs/opengl/assets/2-helloQuad/wireframe-quad.png new file mode 100644 index 0000000000000000000000000000000000000000..25d474327e9668ab883675c84b05f5d87b3e9bd0 GIT binary patch literal 17787 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 C;*= 1 < 3" + } + }, + "node_modules/@algolia/autocomplete-preset-algolia": { + "version": "1.9.3", + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-shared": "1.9.3" + }, + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/autocomplete-shared": { + "version": "1.9.3", + "license": "MIT", + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/cache-browser-local-storage": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/cache-common": "4.23.3" + } + }, + "node_modules/@algolia/cache-common": { + "version": "4.23.3", + "license": "MIT" + }, + "node_modules/@algolia/cache-in-memory": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/cache-common": "4.23.3" + } + }, + "node_modules/@algolia/client-account": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/client-analytics": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/client-common": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/client-personalization": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/client-search": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/client-common": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/events": { + "version": "4.0.1", + "license": "MIT" + }, + "node_modules/@algolia/logger-common": { + "version": "4.23.3", + "license": "MIT" + }, + "node_modules/@algolia/logger-console": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/logger-common": "4.23.3" + } + }, + "node_modules/@algolia/recommend": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/@algolia/requester-browser-xhr": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/requester-common": "4.23.3" + } + }, + "node_modules/@algolia/requester-common": { + "version": "4.23.3", + "license": "MIT" + }, + "node_modules/@algolia/requester-node-http": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/requester-common": "4.23.3" + } + }, + "node_modules/@algolia/transporter": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/cache-common": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/requester-common": "4.23.3" + } + }, + "node_modules/@ampproject/remapping": { + "version": "2.3.0", + "license": "Apache-2.0", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.24.2", + "license": "MIT", + "dependencies": { + "@babel/highlight": "^7.24.2", + "picocolors": "^1.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/compat-data": { + "version": "7.24.4", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/core": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@ampproject/remapping": "^2.2.0", + "@babel/code-frame": "^7.24.2", + "@babel/generator": "^7.24.5", + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-module-transforms": "^7.24.5", + "@babel/helpers": "^7.24.5", + "@babel/parser": "^7.24.5", + "@babel/template": "^7.24.0", + "@babel/traverse": "^7.24.5", + "@babel/types": "^7.24.5", + "convert-source-map": "^2.0.0", + "debug": "^4.1.0", + "gensync": "^1.0.0-beta.2", + "json5": "^2.2.3", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/babel" + } + }, + "node_modules/@babel/core/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/generator": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.24.5", + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25", + "jsesc": "^2.5.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-annotate-as-pure": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-builder-binary-assignment-operator-visitor": { + "version": "7.22.15", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.15" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets": { + "version": "7.23.6", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.23.5", + "@babel/helper-validator-option": "^7.23.5", + "browserslist": "^4.22.2", + "lru-cache": "^5.1.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-compilation-targets/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-class-features-plugin": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-member-expression-to-functions": "^7.24.5", + "@babel/helper-optimise-call-expression": "^7.22.5", + "@babel/helper-replace-supers": "^7.24.1", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.24.5", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-class-features-plugin/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin": { + "version": "7.22.15", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "regexpu-core": "^5.3.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-create-regexp-features-plugin/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/helper-define-polyfill-provider": { + "version": "0.6.2", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.22.6", + "@babel/helper-plugin-utils": "^7.22.5", + "debug": "^4.1.1", + "lodash.debounce": "^4.0.8", + "resolve": "^1.14.2" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/helper-environment-visitor": { + "version": "7.22.20", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-function-name": { + "version": "7.23.0", + "license": "MIT", + "dependencies": { + "@babel/template": "^7.22.15", + "@babel/types": "^7.23.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-hoist-variables": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-member-expression-to-functions": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.24.3", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-transforms": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-module-imports": "^7.24.3", + "@babel/helper-simple-access": "^7.24.5", + "@babel/helper-split-export-declaration": "^7.24.5", + "@babel/helper-validator-identifier": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-optimise-call-expression": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-plugin-utils": { + "version": "7.24.5", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-remap-async-to-generator": { + "version": "7.22.20", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-wrap-function": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-replace-supers": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-member-expression-to-functions": "^7.23.0", + "@babel/helper-optimise-call-expression": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/helper-simple-access": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-skip-transparent-expression-wrappers": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-split-export-declaration": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.24.1", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.24.5", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-option": { + "version": "7.23.5", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-wrap-function": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-function-name": "^7.23.0", + "@babel/template": "^7.24.0", + "@babel/types": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helpers": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/template": "^7.24.0", + "@babel/traverse": "^7.24.5", + "@babel/types": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.24.5", + "chalk": "^2.4.2", + "js-tokens": "^4.0.0", + "picocolors": "^1.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/highlight/node_modules/ansi-styles": { + "version": "3.2.1", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/chalk": { + "version": "2.4.2", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/color-convert": { + "version": "1.9.3", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/@babel/highlight/node_modules/color-name": { + "version": "1.1.3", + "license": "MIT" + }, + "node_modules/@babel/highlight/node_modules/escape-string-regexp": { + "version": "1.0.5", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/@babel/highlight/node_modules/has-flag": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/highlight/node_modules/supports-color": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/@babel/parser": { + "version": "7.24.5", + "license": "MIT", + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-firefox-class-in-computed-class-key": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-transform-optional-chaining": "^7.24.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.13.0" + } + }, + "node_modules/@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-proposal-private-property-in-object": { + "version": "7.21.0-placeholder-for-preset-env.2", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-async-generators": { + "version": "7.8.4", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-properties": { + "version": "7.12.13", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.12.13" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-class-static-block": { + "version": "7.14.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-dynamic-import": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-export-namespace-from": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.3" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-assertions": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-attributes": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-import-meta": { + "version": "7.10.4", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-json-strings": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-jsx": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-logical-assignment-operators": { + "version": "7.10.4", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-nullish-coalescing-operator": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-numeric-separator": { + "version": "7.10.4", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.10.4" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-object-rest-spread": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-catch-binding": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-optional-chaining": { + "version": "7.8.3", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.8.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-private-property-in-object": { + "version": "7.14.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-top-level-await": { + "version": "7.14.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-typescript": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-syntax-unicode-sets-regex": { + "version": "7.18.6", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.18.6", + "@babel/helper-plugin-utils": "^7.18.6" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-arrow-functions": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-generator-functions": { + "version": "7.24.3", + "license": "MIT", + "dependencies": { + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-remap-async-to-generator": "^7.22.20", + "@babel/plugin-syntax-async-generators": "^7.8.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-async-to-generator": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.24.1", + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-remap-async-to-generator": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoped-functions": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-block-scoping": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-properties": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.24.1", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-class-static-block": { + "version": "7.24.4", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.24.4", + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-class-static-block": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0" + } + }, + "node_modules/@babel/plugin-transform-classes": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/helper-replace-supers": "^7.24.1", + "@babel/helper-split-export-declaration": "^7.24.5", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-computed-properties": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/template": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-destructuring": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dotall-regex": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-duplicate-keys": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-dynamic-import": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-dynamic-import": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-exponentiation-operator": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-builder-binary-assignment-operator-visitor": "^7.22.15", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-export-namespace-from": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-for-of": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-function-name": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-json-strings": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-json-strings": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-literals": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-logical-assignment-operators": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-member-expression-literals": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-amd": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-commonjs": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-simple-access": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-systemjs": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-validator-identifier": "^7.22.20" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-modules-umd": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-module-transforms": "^7.23.3", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-named-capturing-groups-regex": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.5", + "@babel/helper-plugin-utils": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/plugin-transform-new-target": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-nullish-coalescing-operator": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-numeric-separator": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-numeric-separator": "^7.10.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-rest-spread": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-transform-parameters": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-object-super": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-replace-supers": "^7.24.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-catch-binding": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-optional-chaining": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5", + "@babel/plugin-syntax-optional-chaining": "^7.8.3" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-parameters": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-methods": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-class-features-plugin": "^7.24.1", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-private-property-in-object": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.24.5", + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-property-literals": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-constant-elements": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-display-name": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx": { + "version": "7.23.4", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-module-imports": "^7.22.15", + "@babel/helper-plugin-utils": "^7.22.5", + "@babel/plugin-syntax-jsx": "^7.23.3", + "@babel/types": "^7.23.4" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-jsx-development": { + "version": "7.22.5", + "license": "MIT", + "dependencies": { + "@babel/plugin-transform-react-jsx": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-react-pure-annotations": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-regenerator": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "regenerator-transform": "^0.15.2" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-reserved-words": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-runtime": { + "version": "7.24.3", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.24.3", + "@babel/helper-plugin-utils": "^7.24.0", + "babel-plugin-polyfill-corejs2": "^0.4.10", + "babel-plugin-polyfill-corejs3": "^0.10.1", + "babel-plugin-polyfill-regenerator": "^0.6.1", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-runtime/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/plugin-transform-shorthand-properties": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-spread": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-skip-transparent-expression-wrappers": "^7.22.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-sticky-regex": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-template-literals": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typeof-symbol": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.5" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-typescript": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-annotate-as-pure": "^7.22.5", + "@babel/helper-create-class-features-plugin": "^7.24.5", + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/plugin-syntax-typescript": "^7.24.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-escapes": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-property-regex": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-regex": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/plugin-transform-unicode-sets-regex": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-create-regexp-features-plugin": "^7.22.15", + "@babel/helper-plugin-utils": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0" + } + }, + "node_modules/@babel/preset-env": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.24.4", + "@babel/helper-compilation-targets": "^7.23.6", + "@babel/helper-plugin-utils": "^7.24.5", + "@babel/helper-validator-option": "^7.23.5", + "@babel/plugin-bugfix-firefox-class-in-computed-class-key": "^7.24.5", + "@babel/plugin-bugfix-safari-id-destructuring-collision-in-function-expression": "^7.24.1", + "@babel/plugin-bugfix-v8-spread-parameters-in-optional-chaining": "^7.24.1", + "@babel/plugin-bugfix-v8-static-class-fields-redefine-readonly": "^7.24.1", + "@babel/plugin-proposal-private-property-in-object": "7.21.0-placeholder-for-preset-env.2", + "@babel/plugin-syntax-async-generators": "^7.8.4", + "@babel/plugin-syntax-class-properties": "^7.12.13", + "@babel/plugin-syntax-class-static-block": "^7.14.5", + "@babel/plugin-syntax-dynamic-import": "^7.8.3", + "@babel/plugin-syntax-export-namespace-from": "^7.8.3", + "@babel/plugin-syntax-import-assertions": "^7.24.1", + "@babel/plugin-syntax-import-attributes": "^7.24.1", + "@babel/plugin-syntax-import-meta": "^7.10.4", + "@babel/plugin-syntax-json-strings": "^7.8.3", + "@babel/plugin-syntax-logical-assignment-operators": "^7.10.4", + "@babel/plugin-syntax-nullish-coalescing-operator": "^7.8.3", + "@babel/plugin-syntax-numeric-separator": "^7.10.4", + "@babel/plugin-syntax-object-rest-spread": "^7.8.3", + "@babel/plugin-syntax-optional-catch-binding": "^7.8.3", + "@babel/plugin-syntax-optional-chaining": "^7.8.3", + "@babel/plugin-syntax-private-property-in-object": "^7.14.5", + "@babel/plugin-syntax-top-level-await": "^7.14.5", + "@babel/plugin-syntax-unicode-sets-regex": "^7.18.6", + "@babel/plugin-transform-arrow-functions": "^7.24.1", + "@babel/plugin-transform-async-generator-functions": "^7.24.3", + "@babel/plugin-transform-async-to-generator": "^7.24.1", + "@babel/plugin-transform-block-scoped-functions": "^7.24.1", + "@babel/plugin-transform-block-scoping": "^7.24.5", + "@babel/plugin-transform-class-properties": "^7.24.1", + "@babel/plugin-transform-class-static-block": "^7.24.4", + "@babel/plugin-transform-classes": "^7.24.5", + "@babel/plugin-transform-computed-properties": "^7.24.1", + "@babel/plugin-transform-destructuring": "^7.24.5", + "@babel/plugin-transform-dotall-regex": "^7.24.1", + "@babel/plugin-transform-duplicate-keys": "^7.24.1", + "@babel/plugin-transform-dynamic-import": "^7.24.1", + "@babel/plugin-transform-exponentiation-operator": "^7.24.1", + "@babel/plugin-transform-export-namespace-from": "^7.24.1", + "@babel/plugin-transform-for-of": "^7.24.1", + "@babel/plugin-transform-function-name": "^7.24.1", + "@babel/plugin-transform-json-strings": "^7.24.1", + "@babel/plugin-transform-literals": "^7.24.1", + "@babel/plugin-transform-logical-assignment-operators": "^7.24.1", + "@babel/plugin-transform-member-expression-literals": "^7.24.1", + "@babel/plugin-transform-modules-amd": "^7.24.1", + "@babel/plugin-transform-modules-commonjs": "^7.24.1", + "@babel/plugin-transform-modules-systemjs": "^7.24.1", + "@babel/plugin-transform-modules-umd": "^7.24.1", + "@babel/plugin-transform-named-capturing-groups-regex": "^7.22.5", + "@babel/plugin-transform-new-target": "^7.24.1", + "@babel/plugin-transform-nullish-coalescing-operator": "^7.24.1", + "@babel/plugin-transform-numeric-separator": "^7.24.1", + "@babel/plugin-transform-object-rest-spread": "^7.24.5", + "@babel/plugin-transform-object-super": "^7.24.1", + "@babel/plugin-transform-optional-catch-binding": "^7.24.1", + "@babel/plugin-transform-optional-chaining": "^7.24.5", + "@babel/plugin-transform-parameters": "^7.24.5", + "@babel/plugin-transform-private-methods": "^7.24.1", + "@babel/plugin-transform-private-property-in-object": "^7.24.5", + "@babel/plugin-transform-property-literals": "^7.24.1", + "@babel/plugin-transform-regenerator": "^7.24.1", + "@babel/plugin-transform-reserved-words": "^7.24.1", + "@babel/plugin-transform-shorthand-properties": "^7.24.1", + "@babel/plugin-transform-spread": "^7.24.1", + "@babel/plugin-transform-sticky-regex": "^7.24.1", + "@babel/plugin-transform-template-literals": "^7.24.1", + "@babel/plugin-transform-typeof-symbol": "^7.24.5", + "@babel/plugin-transform-unicode-escapes": "^7.24.1", + "@babel/plugin-transform-unicode-property-regex": "^7.24.1", + "@babel/plugin-transform-unicode-regex": "^7.24.1", + "@babel/plugin-transform-unicode-sets-regex": "^7.24.1", + "@babel/preset-modules": "0.1.6-no-external-plugins", + "babel-plugin-polyfill-corejs2": "^0.4.10", + "babel-plugin-polyfill-corejs3": "^0.10.4", + "babel-plugin-polyfill-regenerator": "^0.6.1", + "core-js-compat": "^3.31.0", + "semver": "^6.3.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-env/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/@babel/preset-modules": { + "version": "0.1.6-no-external-plugins", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.0.0", + "@babel/types": "^7.4.4", + "esutils": "^2.0.2" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/@babel/preset-react": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-validator-option": "^7.23.5", + "@babel/plugin-transform-react-display-name": "^7.24.1", + "@babel/plugin-transform-react-jsx": "^7.23.4", + "@babel/plugin-transform-react-jsx-development": "^7.22.5", + "@babel/plugin-transform-react-pure-annotations": "^7.24.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/preset-typescript": { + "version": "7.24.1", + "license": "MIT", + "dependencies": { + "@babel/helper-plugin-utils": "^7.24.0", + "@babel/helper-validator-option": "^7.23.5", + "@babel/plugin-syntax-jsx": "^7.24.1", + "@babel/plugin-transform-modules-commonjs": "^7.24.1", + "@babel/plugin-transform-typescript": "^7.24.1" + }, + "engines": { + "node": ">=6.9.0" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@babel/regjsgen": { + "version": "0.8.0", + "license": "MIT" + }, + "node_modules/@babel/runtime": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "regenerator-runtime": "^0.14.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/runtime-corejs3": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "core-js-pure": "^3.30.2", + "regenerator-runtime": "^0.14.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.24.0", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.23.5", + "@babel/parser": "^7.24.0", + "@babel/types": "^7.24.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.24.2", + "@babel/generator": "^7.24.5", + "@babel/helper-environment-visitor": "^7.22.20", + "@babel/helper-function-name": "^7.23.0", + "@babel/helper-hoist-variables": "^7.22.5", + "@babel/helper-split-export-declaration": "^7.24.5", + "@babel/parser": "^7.24.5", + "@babel/types": "^7.24.5", + "debug": "^4.3.1", + "globals": "^11.1.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.24.5", + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.24.1", + "@babel/helper-validator-identifier": "^7.24.5", + "to-fast-properties": "^2.0.0" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@colors/colors": { + "version": "1.5.0", + "license": "MIT", + "optional": true, + "engines": { + "node": ">=0.1.90" + } + }, + "node_modules/@discoveryjs/json-ext": { + "version": "0.5.7", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/@docsearch/css": { + "version": "3.6.0", + "license": "MIT" + }, + "node_modules/@docsearch/react": { + "version": "3.6.0", + "license": "MIT", + "dependencies": { + "@algolia/autocomplete-core": "1.9.3", + "@algolia/autocomplete-preset-algolia": "1.9.3", + "@docsearch/css": "3.6.0", + "algoliasearch": "^4.19.1" + }, + "peerDependencies": { + "@types/react": ">= 16.8.0 < 19.0.0", + "react": ">= 16.8.0 < 19.0.0", + "react-dom": ">= 16.8.0 < 19.0.0", + "search-insights": ">= 1 < 3" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "react": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "search-insights": { + "optional": true + } + } + }, + "node_modules/@docusaurus/core": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.23.3", + "@babel/generator": "^7.23.3", + "@babel/plugin-syntax-dynamic-import": "^7.8.3", + "@babel/plugin-transform-runtime": "^7.22.9", + "@babel/preset-env": "^7.22.9", + "@babel/preset-react": "^7.22.5", + "@babel/preset-typescript": "^7.22.5", + "@babel/runtime": "^7.22.6", + "@babel/runtime-corejs3": "^7.22.6", + "@babel/traverse": "^7.22.8", + "@docusaurus/cssnano-preset": "3.3.2", + "@docusaurus/logger": "3.3.2", + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "autoprefixer": "^10.4.14", + "babel-loader": "^9.1.3", + "babel-plugin-dynamic-import-node": "^2.3.3", + "boxen": "^6.2.1", + "chalk": "^4.1.2", + "chokidar": "^3.5.3", + "clean-css": "^5.3.2", + "cli-table3": "^0.6.3", + "combine-promises": "^1.1.0", + "commander": "^5.1.0", + "copy-webpack-plugin": "^11.0.0", + "core-js": "^3.31.1", + "css-loader": "^6.8.1", + "css-minimizer-webpack-plugin": "^5.0.1", + "cssnano": "^6.1.2", + "del": "^6.1.1", + "detect-port": "^1.5.1", + "escape-html": "^1.0.3", + "eta": "^2.2.0", + "eval": "^0.1.8", + "file-loader": "^6.2.0", + "fs-extra": "^11.1.1", + "html-minifier-terser": "^7.2.0", + "html-tags": "^3.3.1", + "html-webpack-plugin": "^5.5.3", + "leven": "^3.1.0", + "lodash": "^4.17.21", + "mini-css-extract-plugin": "^2.7.6", + "p-map": "^4.0.0", + "postcss": "^8.4.26", + "postcss-loader": "^7.3.3", + "prompts": "^2.4.2", + "react-dev-utils": "^12.0.1", + "react-helmet-async": "^1.3.0", + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0", + "react-loadable-ssr-addon-v5-slorber": "^1.0.1", + "react-router": "^5.3.4", + "react-router-config": "^5.1.1", + "react-router-dom": "^5.3.4", + "rtl-detect": "^1.0.4", + "semver": "^7.5.4", + "serve-handler": "^6.1.5", + "shelljs": "^0.8.5", + "terser-webpack-plugin": "^5.3.9", + "tslib": "^2.6.0", + "update-notifier": "^6.0.2", + "url-loader": "^4.1.1", + "webpack": "^5.88.1", + "webpack-bundle-analyzer": "^4.9.0", + "webpack-dev-server": "^4.15.1", + "webpack-merge": "^5.9.0", + "webpackbar": "^5.0.2" + }, + "bin": { + "docusaurus": "bin/docusaurus.mjs" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/cssnano-preset": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "cssnano-preset-advanced": "^6.1.2", + "postcss": "^8.4.38", + "postcss-sort-media-queries": "^5.2.0", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + } + }, + "node_modules/@docusaurus/logger": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "chalk": "^4.1.2", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + } + }, + "node_modules/@docusaurus/mdx-loader": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/logger": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "@mdx-js/mdx": "^3.0.0", + "@slorber/remark-comment": "^1.0.0", + "escape-html": "^1.0.3", + "estree-util-value-to-estree": "^3.0.1", + "file-loader": "^6.2.0", + "fs-extra": "^11.1.1", + "image-size": "^1.0.2", + "mdast-util-mdx": "^3.0.0", + "mdast-util-to-string": "^4.0.0", + "rehype-raw": "^7.0.0", + "remark-directive": "^3.0.0", + "remark-emoji": "^4.0.0", + "remark-frontmatter": "^5.0.0", + "remark-gfm": "^4.0.0", + "stringify-object": "^3.3.0", + "tslib": "^2.6.0", + "unified": "^11.0.3", + "unist-util-visit": "^5.0.0", + "url-loader": "^4.1.1", + "vfile": "^6.0.1", + "webpack": "^5.88.1" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/module-type-aliases": { + "version": "3.0.0", + "dev": true, + "license": "MIT", + "dependencies": { + "@docusaurus/react-loadable": "5.5.2", + "@docusaurus/types": "3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router-config": "*", + "@types/react-router-dom": "*", + "react-helmet-async": "*", + "react-loadable": "npm:@docusaurus/react-loadable@5.5.2" + }, + "peerDependencies": { + "react": "*", + "react-dom": "*" + } + }, + "node_modules/@docusaurus/module-type-aliases/node_modules/react-loadable": { + "name": "@docusaurus/react-loadable", + "version": "5.5.2", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/react": "*", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": "*" + } + }, + "node_modules/@docusaurus/plugin-content-blog": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/logger": "3.3.2", + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "cheerio": "^1.0.0-rc.12", + "feed": "^4.2.2", + "fs-extra": "^11.1.1", + "lodash": "^4.17.21", + "reading-time": "^1.5.0", + "srcset": "^4.0.0", + "tslib": "^2.6.0", + "unist-util-visit": "^5.0.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-content-blog/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-content-docs": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/logger": "3.3.2", + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/module-type-aliases": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "@types/react-router-config": "^5.0.7", + "combine-promises": "^1.1.0", + "fs-extra": "^11.1.1", + "js-yaml": "^4.1.0", + "lodash": "^4.17.21", + "tslib": "^2.6.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-content-docs/node_modules/@docusaurus/module-type-aliases": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/types": "3.3.2", + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router-config": "*", + "@types/react-router-dom": "*", + "react-helmet-async": "*", + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0" + }, + "peerDependencies": { + "react": "*", + "react-dom": "*" + } + }, + "node_modules/@docusaurus/plugin-content-docs/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-content-pages": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "fs-extra": "^11.1.1", + "tslib": "^2.6.0", + "webpack": "^5.88.1" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-content-pages/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-debug": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "fs-extra": "^11.1.1", + "react-json-view-lite": "^1.2.0", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-debug/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-analytics": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-analytics/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-gtag": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "@types/gtag.js": "^0.0.12", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-gtag/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-tag-manager": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-google-tag-manager/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-sitemap": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/logger": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "fs-extra": "^11.1.1", + "sitemap": "^7.1.1", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/plugin-sitemap/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/preset-classic": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/plugin-content-blog": "3.3.2", + "@docusaurus/plugin-content-docs": "3.3.2", + "@docusaurus/plugin-content-pages": "3.3.2", + "@docusaurus/plugin-debug": "3.3.2", + "@docusaurus/plugin-google-analytics": "3.3.2", + "@docusaurus/plugin-google-gtag": "3.3.2", + "@docusaurus/plugin-google-tag-manager": "3.3.2", + "@docusaurus/plugin-sitemap": "3.3.2", + "@docusaurus/theme-classic": "3.3.2", + "@docusaurus/theme-common": "3.3.2", + "@docusaurus/theme-search-algolia": "3.3.2", + "@docusaurus/types": "3.3.2" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/preset-classic/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/react-loadable": { + "version": "5.5.2", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/react": "*", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": "*" + } + }, + "node_modules/@docusaurus/theme-classic": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/module-type-aliases": "3.3.2", + "@docusaurus/plugin-content-blog": "3.3.2", + "@docusaurus/plugin-content-docs": "3.3.2", + "@docusaurus/plugin-content-pages": "3.3.2", + "@docusaurus/theme-common": "3.3.2", + "@docusaurus/theme-translations": "3.3.2", + "@docusaurus/types": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "@mdx-js/react": "^3.0.0", + "clsx": "^2.0.0", + "copy-text-to-clipboard": "^3.2.0", + "infima": "0.2.0-alpha.43", + "lodash": "^4.17.21", + "nprogress": "^0.2.0", + "postcss": "^8.4.26", + "prism-react-renderer": "^2.3.0", + "prismjs": "^1.29.0", + "react-router-dom": "^5.3.4", + "rtlcss": "^4.1.0", + "tslib": "^2.6.0", + "utility-types": "^3.10.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/theme-classic/node_modules/@docusaurus/module-type-aliases": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/types": "3.3.2", + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router-config": "*", + "@types/react-router-dom": "*", + "react-helmet-async": "*", + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0" + }, + "peerDependencies": { + "react": "*", + "react-dom": "*" + } + }, + "node_modules/@docusaurus/theme-classic/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/theme-classic/node_modules/clsx": { + "version": "2.1.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@docusaurus/theme-common": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/mdx-loader": "3.3.2", + "@docusaurus/module-type-aliases": "3.3.2", + "@docusaurus/plugin-content-blog": "3.3.2", + "@docusaurus/plugin-content-docs": "3.3.2", + "@docusaurus/plugin-content-pages": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router-config": "*", + "clsx": "^2.0.0", + "parse-numeric-range": "^1.3.0", + "prism-react-renderer": "^2.3.0", + "tslib": "^2.6.0", + "utility-types": "^3.10.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/theme-common/node_modules/@docusaurus/module-type-aliases": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/types": "3.3.2", + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router-config": "*", + "@types/react-router-dom": "*", + "react-helmet-async": "*", + "react-loadable": "npm:@docusaurus/react-loadable@6.0.0" + }, + "peerDependencies": { + "react": "*", + "react-dom": "*" + } + }, + "node_modules/@docusaurus/theme-common/node_modules/@docusaurus/types": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@mdx-js/mdx": "^3.0.0", + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/theme-common/node_modules/clsx": { + "version": "2.1.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@docusaurus/theme-search-algolia": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docsearch/react": "^3.5.2", + "@docusaurus/core": "3.3.2", + "@docusaurus/logger": "3.3.2", + "@docusaurus/plugin-content-docs": "3.3.2", + "@docusaurus/theme-common": "3.3.2", + "@docusaurus/theme-translations": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-validation": "3.3.2", + "algoliasearch": "^4.18.0", + "algoliasearch-helper": "^3.13.3", + "clsx": "^2.0.0", + "eta": "^2.2.0", + "fs-extra": "^11.1.1", + "lodash": "^4.17.21", + "tslib": "^2.6.0", + "utility-types": "^3.10.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/theme-search-algolia/node_modules/clsx": { + "version": "2.1.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@docusaurus/theme-translations": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "fs-extra": "^11.1.1", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + } + }, + "node_modules/@docusaurus/tsconfig": { + "version": "3.0.0", + "dev": true, + "license": "MIT" + }, + "node_modules/@docusaurus/types": { + "version": "3.0.0", + "devOptional": true, + "license": "MIT", + "dependencies": { + "@types/history": "^4.7.11", + "@types/react": "*", + "commander": "^5.1.0", + "joi": "^17.9.2", + "react-helmet-async": "^1.3.0", + "utility-types": "^3.10.0", + "webpack": "^5.88.1", + "webpack-merge": "^5.9.0" + }, + "peerDependencies": { + "react": "^18.0.0", + "react-dom": "^18.0.0" + } + }, + "node_modules/@docusaurus/utils": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/logger": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "@svgr/webpack": "^8.1.0", + "escape-string-regexp": "^4.0.0", + "file-loader": "^6.2.0", + "fs-extra": "^11.1.1", + "github-slugger": "^1.5.0", + "globby": "^11.1.0", + "gray-matter": "^4.0.3", + "jiti": "^1.20.0", + "js-yaml": "^4.1.0", + "lodash": "^4.17.21", + "micromatch": "^4.0.5", + "prompts": "^2.4.2", + "resolve-pathname": "^3.0.0", + "shelljs": "^0.8.5", + "tslib": "^2.6.0", + "url-loader": "^4.1.1", + "webpack": "^5.88.1" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "@docusaurus/types": "*" + }, + "peerDependenciesMeta": { + "@docusaurus/types": { + "optional": true + } + } + }, + "node_modules/@docusaurus/utils-common": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + }, + "peerDependencies": { + "@docusaurus/types": "*" + }, + "peerDependenciesMeta": { + "@docusaurus/types": { + "optional": true + } + } + }, + "node_modules/@docusaurus/utils-validation": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@docusaurus/logger": "3.3.2", + "@docusaurus/utils": "3.3.2", + "@docusaurus/utils-common": "3.3.2", + "joi": "^17.9.2", + "js-yaml": "^4.1.0", + "tslib": "^2.6.0" + }, + "engines": { + "node": ">=18.0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-add-jsx-attribute": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-remove-jsx-attribute": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-svg-dynamic-title": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-svg-em-dimensions": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-transform-react-native-svg": { + "version": "8.1.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-plugin-transform-svg-component": { + "version": "8.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/babel-preset": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "@svgr/babel-plugin-add-jsx-attribute": "8.0.0", + "@svgr/babel-plugin-remove-jsx-attribute": "8.0.0", + "@svgr/babel-plugin-remove-jsx-empty-expression": "8.0.0", + "@svgr/babel-plugin-replace-jsx-attribute-value": "8.0.0", + "@svgr/babel-plugin-svg-dynamic-title": "8.0.0", + "@svgr/babel-plugin-svg-em-dimensions": "8.0.0", + "@svgr/babel-plugin-transform-react-native-svg": "8.1.0", + "@svgr/babel-plugin-transform-svg-component": "8.0.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@babel/core": "^7.0.0-0" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/core": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.21.3", + "@svgr/babel-preset": "8.1.0", + "camelcase": "^6.2.0", + "cosmiconfig": "^8.1.3", + "snake-case": "^3.0.4" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/hast-util-to-babel-ast": { + "version": "8.0.0", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.21.3", + "entities": "^4.4.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/plugin-jsx": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.21.3", + "@svgr/babel-preset": "8.1.0", + "@svgr/hast-util-to-babel-ast": "8.0.0", + "svg-parser": "^2.0.4" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@svgr/core": "*" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/plugin-svgo": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "cosmiconfig": "^8.1.3", + "deepmerge": "^4.3.1", + "svgo": "^3.0.2" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + }, + "peerDependencies": { + "@svgr/core": "*" + } + }, + "node_modules/@docusaurus/utils/node_modules/@svgr/webpack": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.21.3", + "@babel/plugin-transform-react-constant-elements": "^7.21.3", + "@babel/preset-env": "^7.20.2", + "@babel/preset-react": "^7.18.6", + "@babel/preset-typescript": "^7.21.0", + "@svgr/core": "8.1.0", + "@svgr/plugin-jsx": "8.1.0", + "@svgr/plugin-svgo": "8.1.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@docusaurus/utils/node_modules/commander": { + "version": "7.2.0", + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/@docusaurus/utils/node_modules/cosmiconfig": { + "version": "8.3.6", + "license": "MIT", + "dependencies": { + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/d-fischer" + }, + "peerDependencies": { + "typescript": ">=4.9.5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/@docusaurus/utils/node_modules/css-tree": { + "version": "2.3.1", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.30", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/@docusaurus/utils/node_modules/csso": { + "version": "5.0.5", + "license": "MIT", + "dependencies": { + "css-tree": "~2.2.0" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/@docusaurus/utils/node_modules/csso/node_modules/css-tree": { + "version": "2.2.1", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.28", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/@docusaurus/utils/node_modules/csso/node_modules/mdn-data": { + "version": "2.0.28", + "license": "CC0-1.0" + }, + "node_modules/@docusaurus/utils/node_modules/mdn-data": { + "version": "2.0.30", + "license": "CC0-1.0" + }, + "node_modules/@docusaurus/utils/node_modules/svgo": { + "version": "3.2.0", + "license": "MIT", + "dependencies": { + "@trysound/sax": "0.2.0", + "commander": "^7.2.0", + "css-select": "^5.1.0", + "css-tree": "^2.3.1", + "css-what": "^6.1.0", + "csso": "^5.0.5", + "picocolors": "^1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/svgo" + } + }, + "node_modules/@fortawesome/fontawesome-common-types": { + "version": "6.5.2", + "hasInstallScript": true, + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/fontawesome-svg-core": { + "version": "6.5.2", + "hasInstallScript": true, + "license": "MIT", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.5.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-brands-svg-icons": { + "version": "6.5.2", + "hasInstallScript": true, + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.5.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-regular-svg-icons": { + "version": "6.5.2", + "hasInstallScript": true, + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.5.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/free-solid-svg-icons": { + "version": "6.5.2", + "hasInstallScript": true, + "license": "(CC-BY-4.0 AND MIT)", + "dependencies": { + "@fortawesome/fontawesome-common-types": "6.5.2" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/@fortawesome/react-fontawesome": { + "version": "0.2.0", + "license": "MIT", + "dependencies": { + "prop-types": "^15.8.1" + }, + "peerDependencies": { + "@fortawesome/fontawesome-svg-core": "~1 || ~6", + "react": ">=16.3" + } + }, + "node_modules/@hapi/hoek": { + "version": "9.3.0", + "license": "BSD-3-Clause" + }, + "node_modules/@hapi/topo": { + "version": "5.1.0", + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.0.0" + } + }, + "node_modules/@jest/schemas": { + "version": "29.6.3", + "license": "MIT", + "dependencies": { + "@sinclair/typebox": "^0.27.8" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jest/types": { + "version": "29.6.3", + "license": "MIT", + "dependencies": { + "@jest/schemas": "^29.6.3", + "@types/istanbul-lib-coverage": "^2.0.0", + "@types/istanbul-reports": "^3.0.0", + "@types/node": "*", + "@types/yargs": "^17.0.8", + "chalk": "^4.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.5", + "license": "MIT", + "dependencies": { + "@jridgewell/set-array": "^1.2.1", + "@jridgewell/sourcemap-codec": "^1.4.10", + "@jridgewell/trace-mapping": "^0.3.24" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/set-array": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/source-map": { + "version": "0.3.6", + "license": "MIT", + "dependencies": { + "@jridgewell/gen-mapping": "^0.3.5", + "@jridgewell/trace-mapping": "^0.3.25" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.4.15", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.25", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@leichtgewicht/ip-codec": { + "version": "2.0.5", + "license": "MIT" + }, + "node_modules/@mdx-js/mdx": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdx": "^2.0.0", + "collapse-white-space": "^2.0.0", + "devlop": "^1.0.0", + "estree-util-build-jsx": "^3.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "estree-util-to-js": "^2.0.0", + "estree-walker": "^3.0.0", + "hast-util-to-estree": "^3.0.0", + "hast-util-to-jsx-runtime": "^2.0.0", + "markdown-extensions": "^2.0.0", + "periscopic": "^3.0.0", + "remark-mdx": "^3.0.0", + "remark-parse": "^11.0.0", + "remark-rehype": "^11.0.0", + "source-map": "^0.7.0", + "unified": "^11.0.0", + "unist-util-position-from-estree": "^2.0.0", + "unist-util-stringify-position": "^4.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/@mdx-js/react": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "@types/mdx": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + }, + "peerDependencies": { + "@types/react": ">=16", + "react": ">=16" + } + }, + "node_modules/@nodelib/fs.scandir": { + "version": "2.1.5", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "2.0.5", + "run-parallel": "^1.1.9" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.stat": { + "version": "2.0.5", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/@nodelib/fs.walk": { + "version": "1.2.8", + "license": "MIT", + "dependencies": { + "@nodelib/fs.scandir": "2.1.5", + "fastq": "^1.6.0" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/@pnpm/config.env-replace": { + "version": "1.1.0", + "license": "MIT", + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "graceful-fs": "4.2.10" + }, + "engines": { + "node": ">=12.22.0" + } + }, + "node_modules/@pnpm/network.ca-file/node_modules/graceful-fs": { + "version": "4.2.10", + "license": "ISC" + }, + "node_modules/@pnpm/npm-conf": { + "version": "2.2.2", + "license": "MIT", + "dependencies": { + "@pnpm/config.env-replace": "^1.1.0", + "@pnpm/network.ca-file": "^1.0.1", + "config-chain": "^1.1.11" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/@polka/url": { + "version": "1.0.0-next.25", + "license": "MIT" + }, + "node_modules/@sideway/address": { + "version": "4.1.5", + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.0.0" + } + }, + "node_modules/@sideway/formula": { + "version": "3.0.1", + "license": "BSD-3-Clause" + }, + "node_modules/@sideway/pinpoint": { + "version": "2.0.0", + "license": "BSD-3-Clause" + }, + "node_modules/@sinclair/typebox": { + "version": "0.27.8", + "license": "MIT" + }, + "node_modules/@sindresorhus/is": { + "version": "4.6.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/@slorber/remark-comment": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^1.0.0", + "micromark-util-character": "^1.1.0", + "micromark-util-symbol": "^1.0.1" + } + }, + "node_modules/@svgr/babel-plugin-add-jsx-attribute": { + "version": "5.4.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-attribute": { + "version": "5.4.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-remove-jsx-empty-expression": { + "version": "5.0.1", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-replace-jsx-attribute-value": { + "version": "5.0.1", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-dynamic-title": { + "version": "5.4.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-svg-em-dimensions": { + "version": "5.4.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-react-native-svg": { + "version": "5.4.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-plugin-transform-svg-component": { + "version": "5.5.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/babel-preset": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "@svgr/babel-plugin-add-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-attribute": "^5.4.0", + "@svgr/babel-plugin-remove-jsx-empty-expression": "^5.0.1", + "@svgr/babel-plugin-replace-jsx-attribute-value": "^5.0.1", + "@svgr/babel-plugin-svg-dynamic-title": "^5.4.0", + "@svgr/babel-plugin-svg-em-dimensions": "^5.4.0", + "@svgr/babel-plugin-transform-react-native-svg": "^5.4.0", + "@svgr/babel-plugin-transform-svg-component": "^5.5.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/core": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "@svgr/plugin-jsx": "^5.5.0", + "camelcase": "^6.2.0", + "cosmiconfig": "^7.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/hast-util-to-babel-ast": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.12.6" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-jsx": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.12.3", + "@svgr/babel-preset": "^5.5.0", + "@svgr/hast-util-to-babel-ast": "^5.5.0", + "svg-parser": "^2.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/plugin-svgo": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "cosmiconfig": "^7.0.0", + "deepmerge": "^4.2.2", + "svgo": "^1.2.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@svgr/webpack": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "@babel/core": "^7.12.3", + "@babel/plugin-transform-react-constant-elements": "^7.12.1", + "@babel/preset-env": "^7.12.1", + "@babel/preset-react": "^7.12.5", + "@svgr/core": "^5.5.0", + "@svgr/plugin-jsx": "^5.5.0", + "@svgr/plugin-svgo": "^5.5.0", + "loader-utils": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/gregberge" + } + }, + "node_modules/@szmarczak/http-timer": { + "version": "5.0.1", + "license": "MIT", + "dependencies": { + "defer-to-connect": "^2.0.1" + }, + "engines": { + "node": ">=14.16" + } + }, + "node_modules/@trysound/sax": { + "version": "0.2.0", + "license": "ISC", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/@types/acorn": { + "version": "4.0.6", + "license": "MIT", + "dependencies": { + "@types/estree": "*" + } + }, + "node_modules/@types/body-parser": { + "version": "1.19.5", + "license": "MIT", + "dependencies": { + "@types/connect": "*", + "@types/node": "*" + } + }, + "node_modules/@types/bonjour": { + "version": "3.5.13", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect": { + "version": "3.4.38", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/connect-history-api-fallback": { + "version": "1.5.4", + "license": "MIT", + "dependencies": { + "@types/express-serve-static-core": "*", + "@types/node": "*" + } + }, + "node_modules/@types/debug": { + "version": "4.1.12", + "license": "MIT", + "dependencies": { + "@types/ms": "*" + } + }, + "node_modules/@types/eslint": { + "version": "8.56.10", + "license": "MIT", + "dependencies": { + "@types/estree": "*", + "@types/json-schema": "*" + } + }, + "node_modules/@types/eslint-scope": { + "version": "3.7.7", + "license": "MIT", + "dependencies": { + "@types/eslint": "*", + "@types/estree": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.5", + "license": "MIT" + }, + "node_modules/@types/estree-jsx": { + "version": "1.0.5", + "license": "MIT", + "dependencies": { + "@types/estree": "*" + } + }, + "node_modules/@types/express": { + "version": "4.17.21", + "license": "MIT", + "dependencies": { + "@types/body-parser": "*", + "@types/express-serve-static-core": "^4.17.33", + "@types/qs": "*", + "@types/serve-static": "*" + } + }, + "node_modules/@types/express-serve-static-core": { + "version": "4.19.0", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "@types/qs": "*", + "@types/range-parser": "*", + "@types/send": "*" + } + }, + "node_modules/@types/gtag.js": { + "version": "0.0.12", + "license": "MIT" + }, + "node_modules/@types/hast": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/history": { + "version": "4.7.11", + "license": "MIT" + }, + "node_modules/@types/html-minifier-terser": { + "version": "6.1.0", + "license": "MIT" + }, + "node_modules/@types/http-cache-semantics": { + "version": "4.0.4", + "license": "MIT" + }, + "node_modules/@types/http-errors": { + "version": "2.0.4", + "license": "MIT" + }, + "node_modules/@types/http-proxy": { + "version": "1.17.14", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/istanbul-lib-coverage": { + "version": "2.0.6", + "license": "MIT" + }, + "node_modules/@types/istanbul-lib-report": { + "version": "3.0.3", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-coverage": "*" + } + }, + "node_modules/@types/istanbul-reports": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "@types/istanbul-lib-report": "*" + } + }, + "node_modules/@types/json-schema": { + "version": "7.0.15", + "license": "MIT" + }, + "node_modules/@types/mdast": { + "version": "4.0.3", + "license": "MIT", + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mdx": { + "version": "2.0.13", + "license": "MIT" + }, + "node_modules/@types/mime": { + "version": "1.3.5", + "license": "MIT" + }, + "node_modules/@types/ms": { + "version": "0.7.34", + "license": "MIT" + }, + "node_modules/@types/node": { + "version": "20.12.8", + "license": "MIT", + "dependencies": { + "undici-types": "~5.26.4" + } + }, + "node_modules/@types/node-forge": { + "version": "1.3.11", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/parse-json": { + "version": "4.0.2", + "license": "MIT" + }, + "node_modules/@types/prismjs": { + "version": "1.26.3", + "license": "MIT" + }, + "node_modules/@types/prop-types": { + "version": "15.7.12", + "license": "MIT" + }, + "node_modules/@types/q": { + "version": "1.5.8", + "license": "MIT" + }, + "node_modules/@types/qs": { + "version": "6.9.15", + "license": "MIT" + }, + "node_modules/@types/range-parser": { + "version": "1.2.7", + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "18.3.1", + "license": "MIT", + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, + "node_modules/@types/react-helmet": { + "version": "6.1.11", + "dev": true, + "license": "MIT", + "dependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/react-router": { + "version": "5.1.20", + "license": "MIT", + "dependencies": { + "@types/history": "^4.7.11", + "@types/react": "*" + } + }, + "node_modules/@types/react-router-config": { + "version": "5.0.11", + "license": "MIT", + "dependencies": { + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router": "^5.1.0" + } + }, + "node_modules/@types/react-router-dom": { + "version": "5.3.3", + "license": "MIT", + "dependencies": { + "@types/history": "^4.7.11", + "@types/react": "*", + "@types/react-router": "*" + } + }, + "node_modules/@types/retry": { + "version": "0.12.0", + "license": "MIT" + }, + "node_modules/@types/sax": { + "version": "1.2.7", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/send": { + "version": "0.17.4", + "license": "MIT", + "dependencies": { + "@types/mime": "^1", + "@types/node": "*" + } + }, + "node_modules/@types/serve-index": { + "version": "1.9.4", + "license": "MIT", + "dependencies": { + "@types/express": "*" + } + }, + "node_modules/@types/serve-static": { + "version": "1.15.7", + "license": "MIT", + "dependencies": { + "@types/http-errors": "*", + "@types/node": "*", + "@types/send": "*" + } + }, + "node_modules/@types/sockjs": { + "version": "0.3.36", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/unist": { + "version": "3.0.2", + "license": "MIT" + }, + "node_modules/@types/ws": { + "version": "8.5.10", + "license": "MIT", + "dependencies": { + "@types/node": "*" + } + }, + "node_modules/@types/yargs": { + "version": "17.0.32", + "license": "MIT", + "dependencies": { + "@types/yargs-parser": "*" + } + }, + "node_modules/@types/yargs-parser": { + "version": "21.0.3", + "license": "MIT" + }, + "node_modules/@ungap/structured-clone": { + "version": "1.2.0", + "license": "ISC" + }, + "node_modules/@webassemblyjs/ast": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/helper-numbers": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6" + } + }, + "node_modules/@webassemblyjs/floating-point-hex-parser": { + "version": "1.11.6", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-api-error": { + "version": "1.11.6", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-buffer": { + "version": "1.12.1", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-numbers": { + "version": "1.11.6", + "license": "MIT", + "dependencies": { + "@webassemblyjs/floating-point-hex-parser": "1.11.6", + "@webassemblyjs/helper-api-error": "1.11.6", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/helper-wasm-bytecode": { + "version": "1.11.6", + "license": "MIT" + }, + "node_modules/@webassemblyjs/helper-wasm-section": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/wasm-gen": "1.12.1" + } + }, + "node_modules/@webassemblyjs/ieee754": { + "version": "1.11.6", + "license": "MIT", + "dependencies": { + "@xtuc/ieee754": "^1.2.0" + } + }, + "node_modules/@webassemblyjs/leb128": { + "version": "1.11.6", + "license": "Apache-2.0", + "dependencies": { + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@webassemblyjs/utf8": { + "version": "1.11.6", + "license": "MIT" + }, + "node_modules/@webassemblyjs/wasm-edit": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/helper-wasm-section": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-opt": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1", + "@webassemblyjs/wast-printer": "1.12.1" + } + }, + "node_modules/@webassemblyjs/wasm-gen": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "node_modules/@webassemblyjs/wasm-opt": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-buffer": "1.12.1", + "@webassemblyjs/wasm-gen": "1.12.1", + "@webassemblyjs/wasm-parser": "1.12.1" + } + }, + "node_modules/@webassemblyjs/wasm-parser": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@webassemblyjs/helper-api-error": "1.11.6", + "@webassemblyjs/helper-wasm-bytecode": "1.11.6", + "@webassemblyjs/ieee754": "1.11.6", + "@webassemblyjs/leb128": "1.11.6", + "@webassemblyjs/utf8": "1.11.6" + } + }, + "node_modules/@webassemblyjs/wast-printer": { + "version": "1.12.1", + "license": "MIT", + "dependencies": { + "@webassemblyjs/ast": "1.12.1", + "@xtuc/long": "4.2.2" + } + }, + "node_modules/@xtuc/ieee754": { + "version": "1.2.0", + "license": "BSD-3-Clause" + }, + "node_modules/@xtuc/long": { + "version": "4.2.2", + "license": "Apache-2.0" + }, + "node_modules/accepts": { + "version": "1.3.8", + "license": "MIT", + "dependencies": { + "mime-types": "~2.1.34", + "negotiator": "0.6.3" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/accepts/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/accepts/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/acorn": { + "version": "8.11.3", + "license": "MIT", + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/acorn-import-assertions": { + "version": "1.9.0", + "license": "MIT", + "peerDependencies": { + "acorn": "^8" + } + }, + "node_modules/acorn-jsx": { + "version": "5.3.2", + "license": "MIT", + "peerDependencies": { + "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" + } + }, + "node_modules/acorn-walk": { + "version": "8.3.2", + "license": "MIT", + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/address": { + "version": "1.2.2", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/aggregate-error": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "clean-stack": "^2.0.0", + "indent-string": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ajv": { + "version": "8.13.0", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "json-schema-traverse": "^1.0.0", + "require-from-string": "^2.0.2", + "uri-js": "^4.4.1" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/ajv-formats": { + "version": "2.1.1", + "license": "MIT", + "dependencies": { + "ajv": "^8.0.0" + }, + "peerDependencies": { + "ajv": "^8.0.0" + }, + "peerDependenciesMeta": { + "ajv": { + "optional": true + } + } + }, + "node_modules/ajv-keywords": { + "version": "5.1.0", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3" + }, + "peerDependencies": { + "ajv": "^8.8.2" + } + }, + "node_modules/algoliasearch": { + "version": "4.23.3", + "license": "MIT", + "dependencies": { + "@algolia/cache-browser-local-storage": "4.23.3", + "@algolia/cache-common": "4.23.3", + "@algolia/cache-in-memory": "4.23.3", + "@algolia/client-account": "4.23.3", + "@algolia/client-analytics": "4.23.3", + "@algolia/client-common": "4.23.3", + "@algolia/client-personalization": "4.23.3", + "@algolia/client-search": "4.23.3", + "@algolia/logger-common": "4.23.3", + "@algolia/logger-console": "4.23.3", + "@algolia/recommend": "4.23.3", + "@algolia/requester-browser-xhr": "4.23.3", + "@algolia/requester-common": "4.23.3", + "@algolia/requester-node-http": "4.23.3", + "@algolia/transporter": "4.23.3" + } + }, + "node_modules/algoliasearch-helper": { + "version": "3.19.0", + "license": "MIT", + "dependencies": { + "@algolia/events": "^4.0.1" + }, + "peerDependencies": { + "algoliasearch": ">= 3.1 < 6" + } + }, + "node_modules/ansi-align": { + "version": "3.0.1", + "license": "ISC", + "dependencies": { + "string-width": "^4.1.0" + } + }, + "node_modules/ansi-align/node_modules/emoji-regex": { + "version": "8.0.0", + "license": "MIT" + }, + "node_modules/ansi-align/node_modules/string-width": { + "version": "4.2.3", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-html-community": { + "version": "0.0.8", + "engines": [ + "node >= 0.8.0" + ], + "license": "Apache-2.0", + "bin": { + "ansi-html": "bin/ansi-html" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "license": "MIT", + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/anymatch": { + "version": "3.1.3", + "license": "ISC", + "dependencies": { + "normalize-path": "^3.0.0", + "picomatch": "^2.0.4" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/arg": { + "version": "5.0.2", + "license": "MIT" + }, + "node_modules/argparse": { + "version": "2.0.1", + "license": "Python-2.0" + }, + "node_modules/array-buffer-byte-length": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.5", + "is-array-buffer": "^3.0.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/array-flatten": { + "version": "1.1.1", + "license": "MIT" + }, + "node_modules/array-union": { + "version": "2.1.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/array.prototype.reduce": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-array-method-boxes-properly": "^1.0.0", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "is-string": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/arraybuffer.prototype.slice": { + "version": "1.0.3", + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", + "es-abstract": "^1.22.3", + "es-errors": "^1.2.1", + "get-intrinsic": "^1.2.3", + "is-array-buffer": "^3.0.4", + "is-shared-array-buffer": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/astring": { + "version": "1.8.6", + "license": "MIT", + "bin": { + "astring": "bin/astring" + } + }, + "node_modules/at-least-node": { + "version": "1.0.0", + "license": "ISC", + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/autoprefixer": { + "version": "10.4.19", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/autoprefixer" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "caniuse-lite": "^1.0.30001599", + "fraction.js": "^4.3.7", + "normalize-range": "^0.1.2", + "picocolors": "^1.0.0", + "postcss-value-parser": "^4.2.0" + }, + "bin": { + "autoprefixer": "bin/autoprefixer" + }, + "engines": { + "node": "^10 || ^12 || >=14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/available-typed-arrays": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/babel-loader": { + "version": "9.1.3", + "license": "MIT", + "dependencies": { + "find-cache-dir": "^4.0.0", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 14.15.0" + }, + "peerDependencies": { + "@babel/core": "^7.12.0", + "webpack": ">=5" + } + }, + "node_modules/babel-plugin-dynamic-import-node": { + "version": "2.3.3", + "license": "MIT", + "dependencies": { + "object.assign": "^4.1.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2": { + "version": "0.4.11", + "license": "MIT", + "dependencies": { + "@babel/compat-data": "^7.22.6", + "@babel/helper-define-polyfill-provider": "^0.6.2", + "semver": "^6.3.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-corejs2/node_modules/semver": { + "version": "6.3.1", + "license": "ISC", + "bin": { + "semver": "bin/semver.js" + } + }, + "node_modules/babel-plugin-polyfill-corejs3": { + "version": "0.10.4", + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.1", + "core-js-compat": "^3.36.1" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/babel-plugin-polyfill-regenerator": { + "version": "0.6.2", + "license": "MIT", + "dependencies": { + "@babel/helper-define-polyfill-provider": "^0.6.2" + }, + "peerDependencies": { + "@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0" + } + }, + "node_modules/bail": { + "version": "2.0.2", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/balanced-match": { + "version": "1.0.2", + "license": "MIT" + }, + "node_modules/batch": { + "version": "0.6.1", + "license": "MIT" + }, + "node_modules/big.js": { + "version": "5.2.2", + "license": "MIT", + "engines": { + "node": "*" + } + }, + "node_modules/binary-extensions": { + "version": "2.3.0", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/body-parser": { + "version": "1.20.2", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "content-type": "~1.0.5", + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "on-finished": "2.4.1", + "qs": "6.11.0", + "raw-body": "2.5.2", + "type-is": "~1.6.18", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/body-parser/node_modules/bytes": { + "version": "3.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/body-parser/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/body-parser/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/bonjour-service": { + "version": "1.2.1", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.3", + "multicast-dns": "^7.2.5" + } + }, + "node_modules/boolbase": { + "version": "1.0.0", + "license": "ISC" + }, + "node_modules/boxen": { + "version": "6.2.1", + "license": "MIT", + "dependencies": { + "ansi-align": "^3.0.1", + "camelcase": "^6.2.0", + "chalk": "^4.1.2", + "cli-boxes": "^3.0.0", + "string-width": "^5.0.1", + "type-fest": "^2.5.0", + "widest-line": "^4.0.1", + "wrap-ansi": "^8.0.1" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/brace-expansion": { + "version": "1.1.11", + "license": "MIT", + "dependencies": { + "balanced-match": "^1.0.0", + "concat-map": "0.0.1" + } + }, + "node_modules/braces": { + "version": "3.0.2", + "license": "MIT", + "dependencies": { + "fill-range": "^7.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/browserslist": { + "version": "4.23.0", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "caniuse-lite": "^1.0.30001587", + "electron-to-chromium": "^1.4.668", + "node-releases": "^2.0.14", + "update-browserslist-db": "^1.0.13" + }, + "bin": { + "browserslist": "cli.js" + }, + "engines": { + "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7" + } + }, + "node_modules/buffer-from": { + "version": "1.1.2", + "license": "MIT" + }, + "node_modules/bytes": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/cacheable-lookup": { + "version": "7.0.0", + "license": "MIT", + "engines": { + "node": ">=14.16" + } + }, + "node_modules/cacheable-request": { + "version": "10.2.14", + "license": "MIT", + "dependencies": { + "@types/http-cache-semantics": "^4.0.2", + "get-stream": "^6.0.1", + "http-cache-semantics": "^4.1.1", + "keyv": "^4.5.3", + "mimic-response": "^4.0.0", + "normalize-url": "^8.0.0", + "responselike": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + } + }, + "node_modules/call-bind": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "set-function-length": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/camel-case": { + "version": "4.1.2", + "license": "MIT", + "dependencies": { + "pascal-case": "^3.1.2", + "tslib": "^2.0.3" + } + }, + "node_modules/camelcase": { + "version": "6.3.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/caniuse-api": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.0.0", + "caniuse-lite": "^1.0.0", + "lodash.memoize": "^4.1.2", + "lodash.uniq": "^4.5.0" + } + }, + "node_modules/caniuse-lite": { + "version": "1.0.30001615", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/caniuse-lite" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "CC-BY-4.0" + }, + "node_modules/ccount": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "license": "MIT", + "dependencies": { + "ansi-styles": "^4.1.0", + "supports-color": "^7.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/char-regex": { + "version": "1.0.2", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/character-entities": { + "version": "2.0.2", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-html4": { + "version": "2.1.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-legacy": { + "version": "3.0.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-reference-invalid": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/cheerio": { + "version": "1.0.0-rc.12", + "license": "MIT", + "dependencies": { + "cheerio-select": "^2.1.0", + "dom-serializer": "^2.0.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "htmlparser2": "^8.0.1", + "parse5": "^7.0.0", + "parse5-htmlparser2-tree-adapter": "^7.0.0" + }, + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/cheeriojs/cheerio?sponsor=1" + } + }, + "node_modules/cheerio-select": { + "version": "2.1.0", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-select": "^5.1.0", + "css-what": "^6.1.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/chokidar": { + "version": "3.6.0", + "license": "MIT", + "dependencies": { + "anymatch": "~3.1.2", + "braces": "~3.0.2", + "glob-parent": "~5.1.2", + "is-binary-path": "~2.1.0", + "is-glob": "~4.0.1", + "normalize-path": "~3.0.0", + "readdirp": "~3.6.0" + }, + "engines": { + "node": ">= 8.10.0" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + }, + "optionalDependencies": { + "fsevents": "~2.3.2" + } + }, + "node_modules/chrome-trace-event": { + "version": "1.0.3", + "license": "MIT", + "engines": { + "node": ">=6.0" + } + }, + "node_modules/ci-info": { + "version": "3.9.0", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/sibiraj-s" + } + ], + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/clean-css": { + "version": "5.3.3", + "license": "MIT", + "dependencies": { + "source-map": "~0.6.0" + }, + "engines": { + "node": ">= 10.0" + } + }, + "node_modules/clean-css/node_modules/source-map": { + "version": "0.6.1", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/clean-stack": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/cli-boxes": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-table3": { + "version": "0.6.4", + "license": "MIT", + "dependencies": { + "string-width": "^4.2.0" + }, + "engines": { + "node": "10.* || >= 12.*" + }, + "optionalDependencies": { + "@colors/colors": "1.5.0" + } + }, + "node_modules/cli-table3/node_modules/emoji-regex": { + "version": "8.0.0", + "license": "MIT" + }, + "node_modules/cli-table3/node_modules/string-width": { + "version": "4.2.3", + "license": "MIT", + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/clone-deep": { + "version": "4.0.1", + "license": "MIT", + "dependencies": { + "is-plain-object": "^2.0.4", + "kind-of": "^6.0.2", + "shallow-clone": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/clsx": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/coa": { + "version": "2.0.2", + "license": "MIT", + "dependencies": { + "@types/q": "^1.5.1", + "chalk": "^2.4.1", + "q": "^1.1.2" + }, + "engines": { + "node": ">= 4.0" + } + }, + "node_modules/coa/node_modules/ansi-styles": { + "version": "3.2.1", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/chalk": { + "version": "2.4.2", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/color-convert": { + "version": "1.9.3", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/coa/node_modules/color-name": { + "version": "1.1.3", + "license": "MIT" + }, + "node_modules/coa/node_modules/escape-string-regexp": { + "version": "1.0.5", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/coa/node_modules/has-flag": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/coa/node_modules/supports-color": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/collapse-white-space": { + "version": "2.1.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "license": "MIT" + }, + "node_modules/colord": { + "version": "2.9.3", + "license": "MIT" + }, + "node_modules/colorette": { + "version": "2.0.20", + "license": "MIT" + }, + "node_modules/combine-promises": { + "version": "1.2.0", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/comma-separated-tokens": { + "version": "2.0.3", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/commander": { + "version": "5.1.0", + "license": "MIT", + "engines": { + "node": ">= 6" + } + }, + "node_modules/common-path-prefix": { + "version": "3.0.0", + "license": "ISC" + }, + "node_modules/compressible": { + "version": "2.0.18", + "license": "MIT", + "dependencies": { + "mime-db": ">= 1.43.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/compressible/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/compression": { + "version": "1.7.4", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.5", + "bytes": "3.0.0", + "compressible": "~2.0.16", + "debug": "2.6.9", + "on-headers": "~1.0.2", + "safe-buffer": "5.1.2", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/compression/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/compression/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/compression/node_modules/safe-buffer": { + "version": "5.1.2", + "license": "MIT" + }, + "node_modules/concat-map": { + "version": "0.0.1", + "license": "MIT" + }, + "node_modules/config-chain": { + "version": "1.1.13", + "license": "MIT", + "dependencies": { + "ini": "^1.3.4", + "proto-list": "~1.2.1" + } + }, + "node_modules/configstore": { + "version": "6.0.0", + "license": "BSD-2-Clause", + "dependencies": { + "dot-prop": "^6.0.1", + "graceful-fs": "^4.2.6", + "unique-string": "^3.0.0", + "write-file-atomic": "^3.0.3", + "xdg-basedir": "^5.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/yeoman/configstore?sponsor=1" + } + }, + "node_modules/connect-history-api-fallback": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=0.8" + } + }, + "node_modules/consola": { + "version": "2.15.3", + "license": "MIT" + }, + "node_modules/content-disposition": { + "version": "0.5.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/content-type": { + "version": "1.0.5", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/convert-source-map": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/cookie": { + "version": "0.6.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/cookie-signature": { + "version": "1.0.6", + "license": "MIT" + }, + "node_modules/copy-text-to-clipboard": { + "version": "3.2.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/copy-webpack-plugin": { + "version": "11.0.0", + "license": "MIT", + "dependencies": { + "fast-glob": "^3.2.11", + "glob-parent": "^6.0.1", + "globby": "^13.1.1", + "normalize-path": "^3.0.0", + "schema-utils": "^4.0.0", + "serialize-javascript": "^6.0.0" + }, + "engines": { + "node": ">= 14.15.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + } + }, + "node_modules/copy-webpack-plugin/node_modules/glob-parent": { + "version": "6.0.2", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.3" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/copy-webpack-plugin/node_modules/globby": { + "version": "13.2.2", + "license": "MIT", + "dependencies": { + "dir-glob": "^3.0.1", + "fast-glob": "^3.3.0", + "ignore": "^5.2.4", + "merge2": "^1.4.1", + "slash": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/copy-webpack-plugin/node_modules/slash": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/core-js": { + "version": "3.37.0", + "hasInstallScript": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-js-compat": { + "version": "3.37.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-js-pure": { + "version": "3.37.0", + "hasInstallScript": true, + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/core-js" + } + }, + "node_modules/core-util-is": { + "version": "1.0.3", + "license": "MIT" + }, + "node_modules/cosmiconfig": { + "version": "7.1.0", + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.2.1", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.10.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/cross-spawn": { + "version": "7.0.3", + "license": "MIT", + "dependencies": { + "path-key": "^3.1.0", + "shebang-command": "^2.0.0", + "which": "^2.0.1" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/crypto-random-string": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "type-fest": "^1.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/crypto-random-string/node_modules/type-fest": { + "version": "1.4.0", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/css-declaration-sorter": { + "version": "7.2.0", + "license": "ISC", + "engines": { + "node": "^14 || ^16 || >=18" + }, + "peerDependencies": { + "postcss": "^8.0.9" + } + }, + "node_modules/css-loader": { + "version": "6.11.0", + "license": "MIT", + "dependencies": { + "icss-utils": "^5.1.0", + "postcss": "^8.4.33", + "postcss-modules-extract-imports": "^3.1.0", + "postcss-modules-local-by-default": "^4.0.5", + "postcss-modules-scope": "^3.2.0", + "postcss-modules-values": "^4.0.0", + "postcss-value-parser": "^4.2.0", + "semver": "^7.5.4" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "@rspack/core": "0.x || 1.x", + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "@rspack/core": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "node_modules/css-minimizer-webpack-plugin": { + "version": "5.0.1", + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.18", + "cssnano": "^6.0.1", + "jest-worker": "^29.4.3", + "postcss": "^8.4.24", + "schema-utils": "^4.0.1", + "serialize-javascript": "^6.0.1" + }, + "engines": { + "node": ">= 14.15.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + }, + "peerDependenciesMeta": { + "@parcel/css": { + "optional": true + }, + "@swc/css": { + "optional": true + }, + "clean-css": { + "optional": true + }, + "csso": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "lightningcss": { + "optional": true + } + } + }, + "node_modules/css-select": { + "version": "5.1.0", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.1.0", + "domhandler": "^5.0.2", + "domutils": "^3.0.1", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/css-select-base-adapter": { + "version": "0.1.1", + "license": "MIT" + }, + "node_modules/css-tree": { + "version": "1.0.0-alpha.37", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.4", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/css-tree/node_modules/source-map": { + "version": "0.6.1", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/css-what": { + "version": "6.1.0", + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/cssesc": { + "version": "3.0.0", + "license": "MIT", + "bin": { + "cssesc": "bin/cssesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/cssnano": { + "version": "6.1.2", + "license": "MIT", + "dependencies": { + "cssnano-preset-default": "^6.1.2", + "lilconfig": "^3.1.1" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/cssnano" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-preset-advanced": { + "version": "6.1.2", + "license": "MIT", + "dependencies": { + "autoprefixer": "^10.4.19", + "browserslist": "^4.23.0", + "cssnano-preset-default": "^6.1.2", + "postcss-discard-unused": "^6.0.5", + "postcss-merge-idents": "^6.0.3", + "postcss-reduce-idents": "^6.0.3", + "postcss-zindex": "^6.0.2" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-preset-default": { + "version": "6.1.2", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "css-declaration-sorter": "^7.2.0", + "cssnano-utils": "^4.0.2", + "postcss-calc": "^9.0.1", + "postcss-colormin": "^6.1.0", + "postcss-convert-values": "^6.1.0", + "postcss-discard-comments": "^6.0.2", + "postcss-discard-duplicates": "^6.0.3", + "postcss-discard-empty": "^6.0.3", + "postcss-discard-overridden": "^6.0.2", + "postcss-merge-longhand": "^6.0.5", + "postcss-merge-rules": "^6.1.1", + "postcss-minify-font-values": "^6.1.0", + "postcss-minify-gradients": "^6.0.3", + "postcss-minify-params": "^6.1.0", + "postcss-minify-selectors": "^6.0.4", + "postcss-normalize-charset": "^6.0.2", + "postcss-normalize-display-values": "^6.0.2", + "postcss-normalize-positions": "^6.0.2", + "postcss-normalize-repeat-style": "^6.0.2", + "postcss-normalize-string": "^6.0.2", + "postcss-normalize-timing-functions": "^6.0.2", + "postcss-normalize-unicode": "^6.1.0", + "postcss-normalize-url": "^6.0.2", + "postcss-normalize-whitespace": "^6.0.2", + "postcss-ordered-values": "^6.0.2", + "postcss-reduce-initial": "^6.1.0", + "postcss-reduce-transforms": "^6.0.2", + "postcss-svgo": "^6.0.3", + "postcss-unique-selectors": "^6.0.4" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/cssnano-utils": { + "version": "4.0.2", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/csso": { + "version": "4.2.0", + "license": "MIT", + "dependencies": { + "css-tree": "^1.1.2" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/css-tree": { + "version": "1.1.3", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.14", + "source-map": "^0.6.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/csso/node_modules/mdn-data": { + "version": "2.0.14", + "license": "CC0-1.0" + }, + "node_modules/csso/node_modules/source-map": { + "version": "0.6.1", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/csstype": { + "version": "3.1.3", + "license": "MIT" + }, + "node_modules/data-view-buffer": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-length": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/data-view-byte-offset": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", + "is-data-view": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/debounce": { + "version": "1.2.1", + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.3.4", + "license": "MIT", + "dependencies": { + "ms": "2.1.2" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/decode-named-character-reference": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "character-entities": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/decompress-response": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "mimic-response": "^3.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/decompress-response/node_modules/mimic-response": { + "version": "3.1.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/deep-extend": { + "version": "0.6.0", + "license": "MIT", + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/deepmerge": { + "version": "4.3.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/default-gateway": { + "version": "6.0.3", + "license": "BSD-2-Clause", + "dependencies": { + "execa": "^5.0.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/defer-to-connect": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/define-data-property": { + "version": "1.1.4", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/define-lazy-prop": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/define-properties": { + "version": "1.2.1", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.0.1", + "has-property-descriptors": "^1.0.0", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/del": { + "version": "6.1.1", + "license": "MIT", + "dependencies": { + "globby": "^11.0.1", + "graceful-fs": "^4.2.4", + "is-glob": "^4.0.1", + "is-path-cwd": "^2.2.0", + "is-path-inside": "^3.0.2", + "p-map": "^4.0.0", + "rimraf": "^3.0.2", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/depd": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/dequal": { + "version": "2.0.3", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/destroy": { + "version": "1.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.8", + "npm": "1.2.8000 || >= 1.4.16" + } + }, + "node_modules/detect-node": { + "version": "2.1.0", + "license": "MIT" + }, + "node_modules/detect-port": { + "version": "1.5.1", + "license": "MIT", + "dependencies": { + "address": "^1.0.1", + "debug": "4" + }, + "bin": { + "detect": "bin/detect-port.js", + "detect-port": "bin/detect-port.js" + } + }, + "node_modules/detect-port-alt": { + "version": "1.1.6", + "license": "MIT", + "dependencies": { + "address": "^1.0.1", + "debug": "^2.6.0" + }, + "bin": { + "detect": "bin/detect-port", + "detect-port": "bin/detect-port" + }, + "engines": { + "node": ">= 4.2.1" + } + }, + "node_modules/detect-port-alt/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/detect-port-alt/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/devlop": { + "version": "1.1.0", + "license": "MIT", + "dependencies": { + "dequal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/dir-glob": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/dns-packet": { + "version": "5.6.1", + "license": "MIT", + "dependencies": { + "@leichtgewicht/ip-codec": "^2.0.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/docusaurus-plugin-sass": { + "version": "0.2.5", + "resolved": "https://registry.npmjs.org/docusaurus-plugin-sass/-/docusaurus-plugin-sass-0.2.5.tgz", + "integrity": "sha512-Z+D0fLFUKcFpM+bqSUmqKIU+vO+YF1xoEQh5hoFreg2eMf722+siwXDD+sqtwU8E4MvVpuvsQfaHwODNlxJAEg==", + "dependencies": { + "sass-loader": "^10.1.1" + }, + "peerDependencies": { + "@docusaurus/core": "^2.0.0-beta || ^3.0.0-alpha", + "sass": "^1.30.0" + } + }, + "node_modules/dom-converter": { + "version": "0.2.0", + "license": "MIT", + "dependencies": { + "utila": "~0.4" + } + }, + "node_modules/dom-helpers": { + "version": "5.2.1", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.7", + "csstype": "^3.0.2" + } + }, + "node_modules/dom-serializer": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.2", + "entities": "^4.2.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/domelementtype": { + "version": "2.3.0", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "BSD-2-Clause" + }, + "node_modules/domhandler": { + "version": "5.0.3", + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.3.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/domutils": { + "version": "3.1.0", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^2.0.0", + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/dot-case": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/dot-prop": { + "version": "6.0.1", + "license": "MIT", + "dependencies": { + "is-obj": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/dot-prop/node_modules/is-obj": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/duplexer": { + "version": "0.1.2", + "license": "MIT" + }, + "node_modules/eastasianwidth": { + "version": "0.2.0", + "license": "MIT" + }, + "node_modules/ee-first": { + "version": "1.1.1", + "license": "MIT" + }, + "node_modules/electron-to-chromium": { + "version": "1.4.756", + "license": "ISC" + }, + "node_modules/emoji-regex": { + "version": "9.2.2", + "license": "MIT" + }, + "node_modules/emojilib": { + "version": "2.4.0", + "license": "MIT" + }, + "node_modules/emojis-list": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/emoticon": { + "version": "4.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/encodeurl": { + "version": "1.0.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/enhanced-resolve": { + "version": "5.16.0", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.4", + "tapable": "^2.2.0" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/entities": { + "version": "4.5.0", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/error-ex": { + "version": "1.3.2", + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/es-abstract": { + "version": "1.23.3", + "license": "MIT", + "dependencies": { + "array-buffer-byte-length": "^1.0.1", + "arraybuffer.prototype.slice": "^1.0.3", + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "data-view-buffer": "^1.0.1", + "data-view-byte-length": "^1.0.1", + "data-view-byte-offset": "^1.0.0", + "es-define-property": "^1.0.0", + "es-errors": "^1.3.0", + "es-object-atoms": "^1.0.0", + "es-set-tostringtag": "^2.0.3", + "es-to-primitive": "^1.2.1", + "function.prototype.name": "^1.1.6", + "get-intrinsic": "^1.2.4", + "get-symbol-description": "^1.0.2", + "globalthis": "^1.0.3", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2", + "has-proto": "^1.0.3", + "has-symbols": "^1.0.3", + "hasown": "^2.0.2", + "internal-slot": "^1.0.7", + "is-array-buffer": "^3.0.4", + "is-callable": "^1.2.7", + "is-data-view": "^1.0.1", + "is-negative-zero": "^2.0.3", + "is-regex": "^1.1.4", + "is-shared-array-buffer": "^1.0.3", + "is-string": "^1.0.7", + "is-typed-array": "^1.1.13", + "is-weakref": "^1.0.2", + "object-inspect": "^1.13.1", + "object-keys": "^1.1.1", + "object.assign": "^4.1.5", + "regexp.prototype.flags": "^1.5.2", + "safe-array-concat": "^1.1.2", + "safe-regex-test": "^1.0.3", + "string.prototype.trim": "^1.2.9", + "string.prototype.trimend": "^1.0.8", + "string.prototype.trimstart": "^1.0.8", + "typed-array-buffer": "^1.0.2", + "typed-array-byte-length": "^1.0.1", + "typed-array-byte-offset": "^1.0.2", + "typed-array-length": "^1.0.6", + "unbox-primitive": "^1.0.2", + "which-typed-array": "^1.1.15" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/es-array-method-boxes-properly": { + "version": "1.0.0", + "license": "MIT" + }, + "node_modules/es-define-property": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-module-lexer": { + "version": "1.5.2", + "license": "MIT" + }, + "node_modules/es-object-atoms": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-set-tostringtag": { + "version": "2.0.3", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.2.4", + "has-tostringtag": "^1.0.2", + "hasown": "^2.0.1" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/es-to-primitive": { + "version": "1.2.1", + "license": "MIT", + "dependencies": { + "is-callable": "^1.1.4", + "is-date-object": "^1.0.1", + "is-symbol": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/escalade": { + "version": "3.1.2", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/escape-goat": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/escape-html": { + "version": "1.0.3", + "license": "MIT" + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/eslint-scope": { + "version": "5.1.1", + "license": "BSD-2-Clause", + "dependencies": { + "esrecurse": "^4.3.0", + "estraverse": "^4.1.1" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/esprima": { + "version": "4.0.1", + "license": "BSD-2-Clause", + "bin": { + "esparse": "bin/esparse.js", + "esvalidate": "bin/esvalidate.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/esrecurse": { + "version": "4.3.0", + "license": "BSD-2-Clause", + "dependencies": { + "estraverse": "^5.2.0" + }, + "engines": { + "node": ">=4.0" + } + }, + "node_modules/esrecurse/node_modules/estraverse": { + "version": "5.3.0", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estraverse": { + "version": "4.3.0", + "license": "BSD-2-Clause", + "engines": { + "node": ">=4.0" + } + }, + "node_modules/estree-util-attach-comments": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-util-build-jsx": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "devlop": "^1.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "estree-walker": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-util-is-identifier-name": { + "version": "3.0.0", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-util-to-js": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "astring": "^1.8.0", + "source-map": "^0.7.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-util-value-to-estree": { + "version": "3.1.1", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "is-plain-obj": "^4.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/remcohaszing" + } + }, + "node_modules/estree-util-visit": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/estree-walker": { + "version": "3.0.3", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0" + } + }, + "node_modules/esutils": { + "version": "2.0.3", + "license": "BSD-2-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/eta": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + }, + "funding": { + "url": "https://github.com/eta-dev/eta?sponsor=1" + } + }, + "node_modules/etag": { + "version": "1.8.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/eval": { + "version": "0.1.8", + "dependencies": { + "@types/node": "*", + "require-like": ">= 0.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/eventemitter3": { + "version": "4.0.7", + "license": "MIT" + }, + "node_modules/events": { + "version": "3.3.0", + "license": "MIT", + "engines": { + "node": ">=0.8.x" + } + }, + "node_modules/execa": { + "version": "5.1.1", + "license": "MIT", + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^6.0.0", + "human-signals": "^2.1.0", + "is-stream": "^2.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^4.0.1", + "onetime": "^5.1.2", + "signal-exit": "^3.0.3", + "strip-final-newline": "^2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/express": { + "version": "4.19.2", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.8", + "array-flatten": "1.1.1", + "body-parser": "1.20.2", + "content-disposition": "0.5.4", + "content-type": "~1.0.4", + "cookie": "0.6.0", + "cookie-signature": "1.0.6", + "debug": "2.6.9", + "depd": "2.0.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "finalhandler": "1.2.0", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "merge-descriptors": "1.0.1", + "methods": "~1.1.2", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "path-to-regexp": "0.1.7", + "proxy-addr": "~2.0.7", + "qs": "6.11.0", + "range-parser": "~1.2.1", + "safe-buffer": "5.2.1", + "send": "0.18.0", + "serve-static": "1.15.0", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "type-is": "~1.6.18", + "utils-merge": "1.0.1", + "vary": "~1.1.2" + }, + "engines": { + "node": ">= 0.10.0" + } + }, + "node_modules/express/node_modules/content-disposition": { + "version": "0.5.4", + "license": "MIT", + "dependencies": { + "safe-buffer": "5.2.1" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/express/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/express/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/express/node_modules/path-to-regexp": { + "version": "0.1.7", + "license": "MIT" + }, + "node_modules/express/node_modules/range-parser": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/extend": { + "version": "3.0.2", + "license": "MIT" + }, + "node_modules/extend-shallow": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "is-extendable": "^0.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/fast-deep-equal": { + "version": "3.1.3", + "license": "MIT" + }, + "node_modules/fast-glob": { + "version": "3.3.2", + "license": "MIT", + "dependencies": { + "@nodelib/fs.stat": "^2.0.2", + "@nodelib/fs.walk": "^1.2.3", + "glob-parent": "^5.1.2", + "merge2": "^1.3.0", + "micromatch": "^4.0.4" + }, + "engines": { + "node": ">=8.6.0" + } + }, + "node_modules/fast-json-stable-stringify": { + "version": "2.1.0", + "license": "MIT" + }, + "node_modules/fast-url-parser": { + "version": "1.1.3", + "license": "MIT", + "dependencies": { + "punycode": "^1.3.2" + } + }, + "node_modules/fastq": { + "version": "1.17.1", + "license": "ISC", + "dependencies": { + "reusify": "^1.0.4" + } + }, + "node_modules/fault": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "format": "^0.2.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/faye-websocket": { + "version": "0.11.4", + "license": "Apache-2.0", + "dependencies": { + "websocket-driver": ">=0.5.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/feed": { + "version": "4.2.2", + "license": "MIT", + "dependencies": { + "xml-js": "^1.6.11" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/file-loader": { + "version": "6.2.0", + "license": "MIT", + "dependencies": { + "loader-utils": "^2.0.0", + "schema-utils": "^3.0.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/file-loader/node_modules/ajv": { + "version": "6.12.6", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/file-loader/node_modules/ajv-keywords": { + "version": "3.5.2", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/file-loader/node_modules/json-schema-traverse": { + "version": "0.4.1", + "license": "MIT" + }, + "node_modules/file-loader/node_modules/schema-utils": { + "version": "3.3.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/filesize": { + "version": "8.0.7", + "license": "BSD-3-Clause", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/fill-range": { + "version": "7.0.1", + "license": "MIT", + "dependencies": { + "to-regex-range": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/finalhandler": { + "version": "1.2.0", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "on-finished": "2.4.1", + "parseurl": "~1.3.3", + "statuses": "2.0.1", + "unpipe": "~1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/finalhandler/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/finalhandler/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/find-cache-dir": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "common-path-prefix": "^3.0.0", + "pkg-dir": "^7.0.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/find-up": { + "version": "6.3.0", + "license": "MIT", + "dependencies": { + "locate-path": "^7.1.0", + "path-exists": "^5.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/flat": { + "version": "5.0.2", + "license": "BSD-3-Clause", + "bin": { + "flat": "cli.js" + } + }, + "node_modules/follow-redirects": { + "version": "1.15.6", + "funding": [ + { + "type": "individual", + "url": "https://github.com/sponsors/RubenVerborgh" + } + ], + "license": "MIT", + "engines": { + "node": ">=4.0" + }, + "peerDependenciesMeta": { + "debug": { + "optional": true + } + } + }, + "node_modules/for-each": { + "version": "0.3.3", + "license": "MIT", + "dependencies": { + "is-callable": "^1.1.3" + } + }, + "node_modules/fork-ts-checker-webpack-plugin": { + "version": "6.5.3", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.8.3", + "@types/json-schema": "^7.0.5", + "chalk": "^4.1.0", + "chokidar": "^3.4.2", + "cosmiconfig": "^6.0.0", + "deepmerge": "^4.2.2", + "fs-extra": "^9.0.0", + "glob": "^7.1.6", + "memfs": "^3.1.2", + "minimatch": "^3.0.4", + "schema-utils": "2.7.0", + "semver": "^7.3.2", + "tapable": "^1.0.0" + }, + "engines": { + "node": ">=10", + "yarn": ">=1.0.0" + }, + "peerDependencies": { + "eslint": ">= 6", + "typescript": ">= 2.7", + "vue-template-compiler": "*", + "webpack": ">= 4" + }, + "peerDependenciesMeta": { + "eslint": { + "optional": true + }, + "vue-template-compiler": { + "optional": true + } + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/ajv": { + "version": "6.12.6", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/ajv-keywords": { + "version": "3.5.2", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/cosmiconfig": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.1.0", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.7.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/fs-extra": { + "version": "9.1.0", + "license": "MIT", + "dependencies": { + "at-least-node": "^1.0.0", + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/json-schema-traverse": { + "version": "0.4.1", + "license": "MIT" + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/schema-utils": { + "version": "2.7.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.4", + "ajv": "^6.12.2", + "ajv-keywords": "^3.4.1" + }, + "engines": { + "node": ">= 8.9.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/fork-ts-checker-webpack-plugin/node_modules/tapable": { + "version": "1.1.3", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/form-data-encoder": { + "version": "2.1.4", + "license": "MIT", + "engines": { + "node": ">= 14.17" + } + }, + "node_modules/format": { + "version": "0.2.2", + "engines": { + "node": ">=0.4.x" + } + }, + "node_modules/forwarded": { + "version": "0.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fraction.js": { + "version": "4.3.7", + "license": "MIT", + "engines": { + "node": "*" + }, + "funding": { + "type": "patreon", + "url": "https://github.com/sponsors/rawify" + } + }, + "node_modules/fresh": { + "version": "0.5.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/fs-extra": { + "version": "11.2.0", + "license": "MIT", + "dependencies": { + "graceful-fs": "^4.2.0", + "jsonfile": "^6.0.1", + "universalify": "^2.0.0" + }, + "engines": { + "node": ">=14.14" + } + }, + "node_modules/fs-monkey": { + "version": "1.0.6", + "license": "Unlicense" + }, + "node_modules/fs.realpath": { + "version": "1.0.0", + "license": "ISC" + }, + "node_modules/function-bind": { + "version": "1.1.2", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/function.prototype.name": { + "version": "1.1.6", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "define-properties": "^1.2.0", + "es-abstract": "^1.22.1", + "functions-have-names": "^1.2.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/functions-have-names": { + "version": "1.2.3", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/gensync": { + "version": "1.0.0-beta.2", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/get-intrinsic": { + "version": "1.2.4", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "has-proto": "^1.0.1", + "has-symbols": "^1.0.3", + "hasown": "^2.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/get-own-enumerable-property-symbols": { + "version": "3.0.2", + "license": "ISC" + }, + "node_modules/get-stream": { + "version": "6.0.1", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/get-symbol-description": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.5", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/github-slugger": { + "version": "1.5.0", + "license": "ISC" + }, + "node_modules/glob": { + "version": "7.2.3", + "license": "ISC", + "dependencies": { + "fs.realpath": "^1.0.0", + "inflight": "^1.0.4", + "inherits": "2", + "minimatch": "^3.1.1", + "once": "^1.3.0", + "path-is-absolute": "^1.0.0" + }, + "engines": { + "node": "*" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/glob-parent": { + "version": "5.1.2", + "license": "ISC", + "dependencies": { + "is-glob": "^4.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/glob-to-regexp": { + "version": "0.4.1", + "license": "BSD-2-Clause" + }, + "node_modules/global-dirs": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "ini": "2.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/global-dirs/node_modules/ini": { + "version": "2.0.0", + "license": "ISC", + "engines": { + "node": ">=10" + } + }, + "node_modules/global-modules": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "global-prefix": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "ini": "^1.3.5", + "kind-of": "^6.0.2", + "which": "^1.3.1" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/global-prefix/node_modules/which": { + "version": "1.3.1", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "which": "bin/which" + } + }, + "node_modules/globals": { + "version": "11.12.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/globalthis": { + "version": "1.0.4", + "license": "MIT", + "dependencies": { + "define-properties": "^1.2.1", + "gopd": "^1.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/globby": { + "version": "11.1.0", + "license": "MIT", + "dependencies": { + "array-union": "^2.1.0", + "dir-glob": "^3.0.1", + "fast-glob": "^3.2.9", + "ignore": "^5.2.0", + "merge2": "^1.4.1", + "slash": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/gopd": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "get-intrinsic": "^1.1.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/got": { + "version": "12.6.1", + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^5.2.0", + "@szmarczak/http-timer": "^5.0.1", + "cacheable-lookup": "^7.0.0", + "cacheable-request": "^10.2.8", + "decompress-response": "^6.0.0", + "form-data-encoder": "^2.1.2", + "get-stream": "^6.0.1", + "http2-wrapper": "^2.1.10", + "lowercase-keys": "^3.0.0", + "p-cancelable": "^3.0.0", + "responselike": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sindresorhus/got?sponsor=1" + } + }, + "node_modules/got/node_modules/@sindresorhus/is": { + "version": "5.6.0", + "license": "MIT", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sindresorhus/is?sponsor=1" + } + }, + "node_modules/graceful-fs": { + "version": "4.2.11", + "license": "ISC" + }, + "node_modules/gray-matter": { + "version": "4.0.3", + "license": "MIT", + "dependencies": { + "js-yaml": "^3.13.1", + "kind-of": "^6.0.2", + "section-matter": "^1.0.0", + "strip-bom-string": "^1.0.0" + }, + "engines": { + "node": ">=6.0" + } + }, + "node_modules/gray-matter/node_modules/argparse": { + "version": "1.0.10", + "license": "MIT", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/gray-matter/node_modules/js-yaml": { + "version": "3.14.1", + "license": "MIT", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/gzip-size": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "duplexer": "^0.1.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/handle-thing": { + "version": "2.0.1", + "license": "MIT" + }, + "node_modules/has-bigints": { + "version": "1.0.2", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-flag": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/has-property-descriptors": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "es-define-property": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-proto": { + "version": "1.0.3", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-symbols": { + "version": "1.0.3", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-tostringtag": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/has-yarn": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/hasown": { + "version": "2.0.2", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hast-util-from-parse5": { + "version": "8.0.1", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "devlop": "^1.0.0", + "hastscript": "^8.0.0", + "property-information": "^6.0.0", + "vfile": "^6.0.0", + "vfile-location": "^5.0.0", + "web-namespaces": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-parse-selector": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-raw": { + "version": "9.0.2", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "@ungap/structured-clone": "^1.0.0", + "hast-util-from-parse5": "^8.0.0", + "hast-util-to-parse5": "^8.0.0", + "html-void-elements": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", + "parse5": "^7.0.0", + "unist-util-position": "^5.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0", + "web-namespaces": "^2.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-estree": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "devlop": "^1.0.0", + "estree-util-attach-comments": "^3.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "hast-util-whitespace": "^3.0.0", + "mdast-util-mdx-expression": "^2.0.0", + "mdast-util-mdx-jsx": "^3.0.0", + "mdast-util-mdxjs-esm": "^2.0.0", + "property-information": "^6.0.0", + "space-separated-tokens": "^2.0.0", + "style-to-object": "^0.4.0", + "unist-util-position": "^5.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-jsx-runtime": { + "version": "2.3.0", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "devlop": "^1.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "hast-util-whitespace": "^3.0.0", + "mdast-util-mdx-expression": "^2.0.0", + "mdast-util-mdx-jsx": "^3.0.0", + "mdast-util-mdxjs-esm": "^2.0.0", + "property-information": "^6.0.0", + "space-separated-tokens": "^2.0.0", + "style-to-object": "^1.0.0", + "unist-util-position": "^5.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-to-jsx-runtime/node_modules/inline-style-parser": { + "version": "0.2.3", + "license": "MIT" + }, + "node_modules/hast-util-to-jsx-runtime/node_modules/style-to-object": { + "version": "1.0.6", + "license": "MIT", + "dependencies": { + "inline-style-parser": "0.2.3" + } + }, + "node_modules/hast-util-to-parse5": { + "version": "8.0.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "devlop": "^1.0.0", + "property-information": "^6.0.0", + "space-separated-tokens": "^2.0.0", + "web-namespaces": "^2.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-whitespace": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hastscript": { + "version": "8.0.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-parse-selector": "^4.0.0", + "property-information": "^6.0.0", + "space-separated-tokens": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/he": { + "version": "1.2.0", + "license": "MIT", + "bin": { + "he": "bin/he" + } + }, + "node_modules/history": { + "version": "4.10.1", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.1.2", + "loose-envify": "^1.2.0", + "resolve-pathname": "^3.0.0", + "tiny-invariant": "^1.0.2", + "tiny-warning": "^1.0.0", + "value-equal": "^1.0.1" + } + }, + "node_modules/hoist-non-react-statics": { + "version": "3.3.2", + "license": "BSD-3-Clause", + "dependencies": { + "react-is": "^16.7.0" + } + }, + "node_modules/hpack.js": { + "version": "2.1.6", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.1", + "obuf": "^1.0.0", + "readable-stream": "^2.0.1", + "wbuf": "^1.1.0" + } + }, + "node_modules/hpack.js/node_modules/isarray": { + "version": "1.0.0", + "license": "MIT" + }, + "node_modules/hpack.js/node_modules/readable-stream": { + "version": "2.3.8", + "license": "MIT", + "dependencies": { + "core-util-is": "~1.0.0", + "inherits": "~2.0.3", + "isarray": "~1.0.0", + "process-nextick-args": "~2.0.0", + "safe-buffer": "~5.1.1", + "string_decoder": "~1.1.1", + "util-deprecate": "~1.0.1" + } + }, + "node_modules/hpack.js/node_modules/safe-buffer": { + "version": "5.1.2", + "license": "MIT" + }, + "node_modules/hpack.js/node_modules/string_decoder": { + "version": "1.1.1", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.1.0" + } + }, + "node_modules/html-entities": { + "version": "2.5.2", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/mdevils" + }, + { + "type": "patreon", + "url": "https://patreon.com/mdevils" + } + ], + "license": "MIT" + }, + "node_modules/html-escaper": { + "version": "2.0.2", + "license": "MIT" + }, + "node_modules/html-minifier-terser": { + "version": "7.2.0", + "license": "MIT", + "dependencies": { + "camel-case": "^4.1.2", + "clean-css": "~5.3.2", + "commander": "^10.0.0", + "entities": "^4.4.0", + "param-case": "^3.0.4", + "relateurl": "^0.2.7", + "terser": "^5.15.1" + }, + "bin": { + "html-minifier-terser": "cli.js" + }, + "engines": { + "node": "^14.13.1 || >=16.0.0" + } + }, + "node_modules/html-minifier-terser/node_modules/commander": { + "version": "10.0.1", + "license": "MIT", + "engines": { + "node": ">=14" + } + }, + "node_modules/html-tags": { + "version": "3.3.1", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/html-void-elements": { + "version": "3.0.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/html-webpack-plugin": { + "version": "5.6.0", + "license": "MIT", + "dependencies": { + "@types/html-minifier-terser": "^6.0.0", + "html-minifier-terser": "^6.0.2", + "lodash": "^4.17.21", + "pretty-error": "^4.0.0", + "tapable": "^2.0.0" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/html-webpack-plugin" + }, + "peerDependencies": { + "@rspack/core": "0.x || 1.x", + "webpack": "^5.20.0" + }, + "peerDependenciesMeta": { + "@rspack/core": { + "optional": true + }, + "webpack": { + "optional": true + } + } + }, + "node_modules/html-webpack-plugin/node_modules/commander": { + "version": "8.3.0", + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/html-webpack-plugin/node_modules/html-minifier-terser": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "camel-case": "^4.1.2", + "clean-css": "^5.2.2", + "commander": "^8.3.0", + "he": "^1.2.0", + "param-case": "^3.0.4", + "relateurl": "^0.2.7", + "terser": "^5.10.0" + }, + "bin": { + "html-minifier-terser": "cli.js" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/htmlparser2": { + "version": "8.0.2", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "MIT", + "dependencies": { + "domelementtype": "^2.3.0", + "domhandler": "^5.0.3", + "domutils": "^3.0.1", + "entities": "^4.4.0" + } + }, + "node_modules/http-cache-semantics": { + "version": "4.1.1", + "license": "BSD-2-Clause" + }, + "node_modules/http-deceiver": { + "version": "1.2.7", + "license": "MIT" + }, + "node_modules/http-errors": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "depd": "2.0.0", + "inherits": "2.0.4", + "setprototypeof": "1.2.0", + "statuses": "2.0.1", + "toidentifier": "1.0.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/http-parser-js": { + "version": "0.5.8", + "license": "MIT" + }, + "node_modules/http-proxy": { + "version": "1.18.1", + "license": "MIT", + "dependencies": { + "eventemitter3": "^4.0.0", + "follow-redirects": "^1.0.0", + "requires-port": "^1.0.0" + }, + "engines": { + "node": ">=8.0.0" + } + }, + "node_modules/http-proxy-middleware": { + "version": "2.0.6", + "license": "MIT", + "dependencies": { + "@types/http-proxy": "^1.17.8", + "http-proxy": "^1.18.1", + "is-glob": "^4.0.1", + "is-plain-obj": "^3.0.0", + "micromatch": "^4.0.2" + }, + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "@types/express": "^4.17.13" + }, + "peerDependenciesMeta": { + "@types/express": { + "optional": true + } + } + }, + "node_modules/http-proxy-middleware/node_modules/is-plain-obj": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/http2-wrapper": { + "version": "2.2.1", + "license": "MIT", + "dependencies": { + "quick-lru": "^5.1.1", + "resolve-alpn": "^1.2.0" + }, + "engines": { + "node": ">=10.19.0" + } + }, + "node_modules/human-signals": { + "version": "2.1.0", + "license": "Apache-2.0", + "engines": { + "node": ">=10.17.0" + } + }, + "node_modules/iconv-lite": { + "version": "0.4.24", + "license": "MIT", + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/icss-utils": { + "version": "5.1.0", + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/ignore": { + "version": "5.3.1", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/image-size": { + "version": "1.1.1", + "license": "MIT", + "dependencies": { + "queue": "6.0.2" + }, + "bin": { + "image-size": "bin/image-size.js" + }, + "engines": { + "node": ">=16.x" + } + }, + "node_modules/immer": { + "version": "9.0.21", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/immer" + } + }, + "node_modules/immutable": { + "version": "4.3.5", + "resolved": "https://registry.npmjs.org/immutable/-/immutable-4.3.5.tgz", + "integrity": "sha512-8eabxkth9gZatlwl5TBuJnCsoTADlL6ftEr7A4qgdaTsPyreilDSnUk57SO+jfKcNtxPa22U5KK6DSeAYhpBJw==" + }, + "node_modules/import-fresh": { + "version": "3.3.0", + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/import-lazy": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/imurmurhash": { + "version": "0.1.4", + "license": "MIT", + "engines": { + "node": ">=0.8.19" + } + }, + "node_modules/indent-string": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/infima": { + "version": "0.2.0-alpha.43", + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/inflight": { + "version": "1.0.6", + "license": "ISC", + "dependencies": { + "once": "^1.3.0", + "wrappy": "1" + } + }, + "node_modules/inherits": { + "version": "2.0.4", + "license": "ISC" + }, + "node_modules/ini": { + "version": "1.3.8", + "license": "ISC" + }, + "node_modules/inline-style-parser": { + "version": "0.1.1", + "license": "MIT" + }, + "node_modules/internal-slot": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "hasown": "^2.0.0", + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/interpret": { + "version": "1.4.0", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/invariant": { + "version": "2.2.4", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.0.0" + } + }, + "node_modules/ipaddr.js": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/is-alphabetical": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-alphanumerical": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "is-alphabetical": "^2.0.0", + "is-decimal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-array-buffer": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "get-intrinsic": "^1.2.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "license": "MIT" + }, + "node_modules/is-bigint": { + "version": "1.0.4", + "license": "MIT", + "dependencies": { + "has-bigints": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-binary-path": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "binary-extensions": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-boolean-object": { + "version": "1.1.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-callable": { + "version": "1.2.7", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-ci": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "ci-info": "^3.2.0" + }, + "bin": { + "is-ci": "bin.js" + } + }, + "node_modules/is-core-module": { + "version": "2.13.1", + "license": "MIT", + "dependencies": { + "hasown": "^2.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-data-view": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-date-object": { + "version": "1.0.5", + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-decimal": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-docker": { + "version": "2.2.1", + "license": "MIT", + "bin": { + "is-docker": "cli.js" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-extendable": { + "version": "0.1.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-extglob": { + "version": "2.1.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-glob": { + "version": "4.0.3", + "license": "MIT", + "dependencies": { + "is-extglob": "^2.1.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-hexadecimal": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/is-installed-globally": { + "version": "0.4.0", + "license": "MIT", + "dependencies": { + "global-dirs": "^3.0.0", + "is-path-inside": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-negative-zero": { + "version": "2.0.3", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-npm": { + "version": "6.0.0", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-number": { + "version": "7.0.0", + "license": "MIT", + "engines": { + "node": ">=0.12.0" + } + }, + "node_modules/is-number-object": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-obj": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-path-cwd": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-path-inside": { + "version": "3.0.3", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/is-plain-obj": { + "version": "4.1.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-plain-object": { + "version": "2.0.4", + "license": "MIT", + "dependencies": { + "isobject": "^3.0.1" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-reference": { + "version": "3.0.2", + "license": "MIT", + "dependencies": { + "@types/estree": "*" + } + }, + "node_modules/is-regex": { + "version": "1.1.4", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-regexp": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/is-root": { + "version": "2.1.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/is-shared-array-buffer": { + "version": "1.0.3", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-stream": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-string": { + "version": "1.0.7", + "license": "MIT", + "dependencies": { + "has-tostringtag": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-symbol": { + "version": "1.0.4", + "license": "MIT", + "dependencies": { + "has-symbols": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typed-array": { + "version": "1.1.13", + "license": "MIT", + "dependencies": { + "which-typed-array": "^1.1.14" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-typedarray": { + "version": "1.0.0", + "license": "MIT" + }, + "node_modules/is-weakref": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/is-wsl": { + "version": "2.2.0", + "license": "MIT", + "dependencies": { + "is-docker": "^2.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-yarn-global": { + "version": "0.4.1", + "license": "MIT", + "engines": { + "node": ">=12" + } + }, + "node_modules/isarray": { + "version": "0.0.1", + "license": "MIT" + }, + "node_modules/isexe": { + "version": "2.0.0", + "license": "ISC" + }, + "node_modules/isobject": { + "version": "3.0.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/jest-util": { + "version": "29.7.0", + "license": "MIT", + "dependencies": { + "@jest/types": "^29.6.3", + "@types/node": "*", + "chalk": "^4.0.0", + "ci-info": "^3.2.0", + "graceful-fs": "^4.2.9", + "picomatch": "^2.2.3" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker": { + "version": "29.7.0", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "jest-util": "^29.7.0", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": "^14.15.0 || ^16.10.0 || >=18.0.0" + } + }, + "node_modules/jest-worker/node_modules/supports-color": { + "version": "8.1.1", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/jiti": { + "version": "1.21.0", + "license": "MIT", + "bin": { + "jiti": "bin/jiti.js" + } + }, + "node_modules/joi": { + "version": "17.13.1", + "license": "BSD-3-Clause", + "dependencies": { + "@hapi/hoek": "^9.3.0", + "@hapi/topo": "^5.1.0", + "@sideway/address": "^4.1.5", + "@sideway/formula": "^3.0.1", + "@sideway/pinpoint": "^2.0.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "license": "MIT" + }, + "node_modules/js-yaml": { + "version": "4.1.0", + "license": "MIT", + "dependencies": { + "argparse": "^2.0.1" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/jsesc": { + "version": "2.5.2", + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/json-buffer": { + "version": "3.0.1", + "license": "MIT" + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "license": "MIT" + }, + "node_modules/json-schema-traverse": { + "version": "1.0.0", + "license": "MIT" + }, + "node_modules/json5": { + "version": "2.2.3", + "license": "MIT", + "bin": { + "json5": "lib/cli.js" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/jsonfile": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "universalify": "^2.0.0" + }, + "optionalDependencies": { + "graceful-fs": "^4.1.6" + } + }, + "node_modules/keyv": { + "version": "4.5.4", + "license": "MIT", + "dependencies": { + "json-buffer": "3.0.1" + } + }, + "node_modules/kind-of": { + "version": "6.0.3", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/kleur": { + "version": "3.0.3", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/klona": { + "version": "2.0.6", + "resolved": "https://registry.npmjs.org/klona/-/klona-2.0.6.tgz", + "integrity": "sha512-dhG34DXATL5hSxJbIexCft8FChFXtmskoZYnoPWjXQuebWYCNkVeV3KkGegCK9CP1oswI/vQibS2GY7Em/sJJA==", + "engines": { + "node": ">= 8" + } + }, + "node_modules/latest-version": { + "version": "7.0.0", + "license": "MIT", + "dependencies": { + "package-json": "^8.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/launch-editor": { + "version": "2.6.1", + "license": "MIT", + "dependencies": { + "picocolors": "^1.0.0", + "shell-quote": "^1.8.1" + } + }, + "node_modules/leven": { + "version": "3.1.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/lilconfig": { + "version": "3.1.1", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "license": "MIT" + }, + "node_modules/loader-runner": { + "version": "4.3.0", + "license": "MIT", + "engines": { + "node": ">=6.11.5" + } + }, + "node_modules/loader-utils": { + "version": "2.0.4", + "license": "MIT", + "dependencies": { + "big.js": "^5.2.2", + "emojis-list": "^3.0.0", + "json5": "^2.1.2" + }, + "engines": { + "node": ">=8.9.0" + } + }, + "node_modules/locate-path": { + "version": "7.2.0", + "license": "MIT", + "dependencies": { + "p-locate": "^6.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lodash": { + "version": "4.17.21", + "license": "MIT" + }, + "node_modules/lodash.debounce": { + "version": "4.0.8", + "license": "MIT" + }, + "node_modules/lodash.memoize": { + "version": "4.1.2", + "license": "MIT" + }, + "node_modules/lodash.uniq": { + "version": "4.5.0", + "license": "MIT" + }, + "node_modules/longest-streak": { + "version": "3.1.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/lower-case": { + "version": "2.0.2", + "license": "MIT", + "dependencies": { + "tslib": "^2.0.3" + } + }, + "node_modules/lowercase-keys": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/lru-cache": { + "version": "5.1.1", + "license": "ISC", + "dependencies": { + "yallist": "^3.0.2" + } + }, + "node_modules/markdown-extensions": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/markdown-table": { + "version": "3.0.3", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/mdast-util-directive": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "parse-entities": "^4.0.0", + "stringify-entities": "^4.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-find-and-replace": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "escape-string-regexp": "^5.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-find-and-replace/node_modules/escape-string-regexp": { + "version": "5.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mdast-util-from-markdown": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark": "^4.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-decode-string": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-from-markdown/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/mdast-util-frontmatter": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "escape-string-regexp": "^5.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "micromark-extension-frontmatter": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-frontmatter/node_modules/escape-string-regexp": { + "version": "5.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mdast-util-gfm": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-gfm-autolink-literal": "^2.0.0", + "mdast-util-gfm-footnote": "^2.0.0", + "mdast-util-gfm-strikethrough": "^2.0.0", + "mdast-util-gfm-table": "^2.0.0", + "mdast-util-gfm-task-list-item": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-autolink-literal": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "ccount": "^2.0.0", + "devlop": "^1.0.0", + "mdast-util-find-and-replace": "^3.0.0", + "micromark-util-character": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-autolink-literal/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/mdast-util-gfm-autolink-literal/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/mdast-util-gfm-footnote": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.1.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-strikethrough": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-table": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "markdown-table": "^3.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-gfm-task-list-item": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdx": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-mdx-expression": "^2.0.0", + "mdast-util-mdx-jsx": "^3.0.0", + "mdast-util-mdxjs-esm": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdx-expression": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdx-jsx": { + "version": "3.1.2", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "ccount": "^2.0.0", + "devlop": "^1.1.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0", + "parse-entities": "^4.0.0", + "stringify-entities": "^4.0.0", + "unist-util-remove-position": "^5.0.0", + "unist-util-stringify-position": "^4.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-mdxjs-esm": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "@types/estree-jsx": "^1.0.0", + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "devlop": "^1.0.0", + "mdast-util-from-markdown": "^2.0.0", + "mdast-util-to-markdown": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-phrasing": { + "version": "4.1.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-hast": { + "version": "13.1.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "@ungap/structured-clone": "^1.0.0", + "devlop": "^1.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "trim-lines": "^3.0.0", + "unist-util-position": "^5.0.0", + "unist-util-visit": "^5.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-markdown": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "@types/unist": "^3.0.0", + "longest-streak": "^3.0.0", + "mdast-util-phrasing": "^4.0.0", + "mdast-util-to-string": "^4.0.0", + "micromark-util-decode-string": "^2.0.0", + "unist-util-visit": "^5.0.0", + "zwitch": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdast-util-to-string": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/mdn-data": { + "version": "2.0.4", + "license": "CC0-1.0" + }, + "node_modules/media-typer": { + "version": "0.3.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/memfs": { + "version": "3.5.3", + "license": "Unlicense", + "dependencies": { + "fs-monkey": "^1.0.4" + }, + "engines": { + "node": ">= 4.0.0" + } + }, + "node_modules/merge-descriptors": { + "version": "1.0.1", + "license": "MIT" + }, + "node_modules/merge-stream": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/merge2": { + "version": "1.4.1", + "license": "MIT", + "engines": { + "node": ">= 8" + } + }, + "node_modules/methods": { + "version": "1.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/micromark": { + "version": "4.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/debug": "^4.0.0", + "debug": "^4.0.0", + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark": { + "version": "2.0.1", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "devlop": "^1.0.0", + "micromark-factory-destination": "^2.0.0", + "micromark-factory-label": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-factory-title": "^2.0.0", + "micromark-factory-whitespace": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-html-tag-name": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-subtokenize": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-core-commonmark/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-directive": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-factory-whitespace": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "parse-entities": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-directive/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-directive/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-directive/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-frontmatter": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "fault": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-frontmatter/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-frontmatter/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-gfm": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "micromark-extension-gfm-autolink-literal": "^2.0.0", + "micromark-extension-gfm-footnote": "^2.0.0", + "micromark-extension-gfm-strikethrough": "^2.0.0", + "micromark-extension-gfm-table": "^2.0.0", + "micromark-extension-gfm-tagfilter": "^2.0.0", + "micromark-extension-gfm-task-list-item": "^2.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-autolink-literal": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-autolink-literal/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-autolink-literal/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-gfm-footnote": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-normalize-identifier": "^2.0.0", + "micromark-util-sanitize-uri": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-footnote/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-gfm-strikethrough": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-classify-character": "^2.0.0", + "micromark-util-resolve-all": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-strikethrough/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-gfm-table": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-table/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-table/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-table/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-gfm-tagfilter": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-task-list-item": { + "version": "2.0.1", + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-gfm-task-list-item/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-mdx-expression": { + "version": "3.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "devlop": "^1.0.0", + "micromark-factory-mdx-expression": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-events-to-acorn": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdx-expression/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdx-expression/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdx-expression/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-mdx-jsx": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/acorn": "^4.0.0", + "@types/estree": "^1.0.0", + "devlop": "^1.0.0", + "estree-util-is-identifier-name": "^3.0.0", + "micromark-factory-mdx-expression": "^2.0.0", + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdx-jsx/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-extension-mdx-md": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-mdxjs": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "acorn": "^8.0.0", + "acorn-jsx": "^5.0.0", + "micromark-extension-mdx-expression": "^3.0.0", + "micromark-extension-mdx-jsx": "^3.0.0", + "micromark-extension-mdx-md": "^2.0.0", + "micromark-extension-mdxjs-esm": "^3.0.0", + "micromark-util-combine-extensions": "^2.0.0", + "micromark-util-types": "^2.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-mdxjs-esm": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "devlop": "^1.0.0", + "micromark-core-commonmark": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-events-to-acorn": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unist-util-position-from-estree": "^2.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/micromark-extension-mdxjs-esm/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-extension-mdxjs-esm/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-destination": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-destination/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-destination/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-label": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-label/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-label/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-mdx-expression": { + "version": "2.0.1", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "devlop": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-events-to-acorn": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unist-util-position-from-estree": "^2.0.0", + "vfile-message": "^4.0.0" + } + }, + "node_modules/micromark-factory-mdx-expression/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-mdx-expression/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-space": { + "version": "1.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^1.0.0", + "micromark-util-types": "^1.0.0" + } + }, + "node_modules/micromark-factory-space/node_modules/micromark-util-types": { + "version": "1.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-title": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-title/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-title/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-title/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-factory-whitespace": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-factory-space": "^2.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-whitespace/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-whitespace/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-factory-whitespace/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-character": { + "version": "1.2.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^1.0.0", + "micromark-util-types": "^1.0.0" + } + }, + "node_modules/micromark-util-character/node_modules/micromark-util-types": { + "version": "1.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-chunked": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-chunked/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-classify-character": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-classify-character/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-classify-character/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-combine-extensions": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-chunked": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-numeric-character-reference": { + "version": "2.0.1", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-numeric-character-reference/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-decode-string": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "decode-named-character-reference": "^1.0.0", + "micromark-util-character": "^2.0.0", + "micromark-util-decode-numeric-character-reference": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-string/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-decode-string/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-encode": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-events-to-acorn": { + "version": "2.0.2", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "@types/acorn": "^4.0.0", + "@types/estree": "^1.0.0", + "@types/unist": "^3.0.0", + "devlop": "^1.0.0", + "estree-util-visit": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0", + "vfile-message": "^4.0.0" + } + }, + "node_modules/micromark-util-events-to-acorn/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-html-tag-name": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-normalize-identifier": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-normalize-identifier/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-resolve-all": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-sanitize-uri": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-sanitize-uri/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-sanitize-uri/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-subtokenize": { + "version": "2.0.1", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "devlop": "^1.0.0", + "micromark-util-chunked": "^2.0.0", + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-subtokenize/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-symbol": { + "version": "1.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark-util-types": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromark/node_modules/micromark-factory-space": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark/node_modules/micromark-util-character": { + "version": "2.1.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT", + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark/node_modules/micromark-util-symbol": { + "version": "2.0.0", + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "license": "MIT" + }, + "node_modules/micromatch": { + "version": "4.0.5", + "license": "MIT", + "dependencies": { + "braces": "^3.0.2", + "picomatch": "^2.3.1" + }, + "engines": { + "node": ">=8.6" + } + }, + "node_modules/mime": { + "version": "1.6.0", + "license": "MIT", + "bin": { + "mime": "cli.js" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/mime-db": { + "version": "1.33.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mime-types": { + "version": "2.1.18", + "license": "MIT", + "dependencies": { + "mime-db": "~1.33.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/mimic-fn": { + "version": "2.1.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/mimic-response": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mini-css-extract-plugin": { + "version": "2.9.0", + "license": "MIT", + "dependencies": { + "schema-utils": "^4.0.0", + "tapable": "^2.2.1" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.0.0" + } + }, + "node_modules/minimalistic-assert": { + "version": "1.0.1", + "license": "ISC" + }, + "node_modules/minimatch": { + "version": "3.1.2", + "license": "ISC", + "dependencies": { + "brace-expansion": "^1.1.7" + }, + "engines": { + "node": "*" + } + }, + "node_modules/minimist": { + "version": "1.2.8", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/mkdirp": { + "version": "0.5.6", + "license": "MIT", + "dependencies": { + "minimist": "^1.2.6" + }, + "bin": { + "mkdirp": "bin/cmd.js" + } + }, + "node_modules/mrmime": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=10" + } + }, + "node_modules/ms": { + "version": "2.1.2", + "license": "MIT" + }, + "node_modules/multicast-dns": { + "version": "7.2.5", + "license": "MIT", + "dependencies": { + "dns-packet": "^5.2.2", + "thunky": "^1.0.2" + }, + "bin": { + "multicast-dns": "cli.js" + } + }, + "node_modules/nanoid": { + "version": "3.3.7", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/negotiator": { + "version": "0.6.3", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/neo-async": { + "version": "2.6.2", + "license": "MIT" + }, + "node_modules/no-case": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "lower-case": "^2.0.2", + "tslib": "^2.0.3" + } + }, + "node_modules/node-emoji": { + "version": "2.1.3", + "license": "MIT", + "dependencies": { + "@sindresorhus/is": "^4.6.0", + "char-regex": "^1.0.2", + "emojilib": "^2.4.0", + "skin-tone": "^2.0.0" + }, + "engines": { + "node": ">=18" + } + }, + "node_modules/node-forge": { + "version": "1.3.1", + "license": "(BSD-3-Clause OR GPL-2.0)", + "engines": { + "node": ">= 6.13.0" + } + }, + "node_modules/node-releases": { + "version": "2.0.14", + "license": "MIT" + }, + "node_modules/normalize-path": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-range": { + "version": "0.1.2", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/normalize-url": { + "version": "8.0.1", + "license": "MIT", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path": { + "version": "4.0.1", + "license": "MIT", + "dependencies": { + "path-key": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/nprogress": { + "version": "0.2.0", + "license": "MIT" + }, + "node_modules/nth-check": { + "version": "2.1.1", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0" + }, + "funding": { + "url": "https://github.com/fb55/nth-check?sponsor=1" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/object-inspect": { + "version": "1.13.1", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object-keys": { + "version": "1.1.1", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/object.assign": { + "version": "4.1.5", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.5", + "define-properties": "^1.2.1", + "has-symbols": "^1.0.3", + "object-keys": "^1.1.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.getownpropertydescriptors": { + "version": "2.1.8", + "license": "MIT", + "dependencies": { + "array.prototype.reduce": "^1.0.6", + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.2", + "es-object-atoms": "^1.0.0", + "gopd": "^1.0.1", + "safe-array-concat": "^1.1.2" + }, + "engines": { + "node": ">= 0.8" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/object.values": { + "version": "1.2.0", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/obuf": { + "version": "1.1.2", + "license": "MIT" + }, + "node_modules/on-finished": { + "version": "2.4.1", + "license": "MIT", + "dependencies": { + "ee-first": "1.1.1" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/on-headers": { + "version": "1.0.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/once": { + "version": "1.4.0", + "license": "ISC", + "dependencies": { + "wrappy": "1" + } + }, + "node_modules/onetime": { + "version": "5.1.2", + "license": "MIT", + "dependencies": { + "mimic-fn": "^2.1.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/open": { + "version": "8.4.2", + "license": "MIT", + "dependencies": { + "define-lazy-prop": "^2.0.0", + "is-docker": "^2.1.1", + "is-wsl": "^2.2.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/opener": { + "version": "1.5.2", + "license": "(WTFPL OR MIT)", + "bin": { + "opener": "bin/opener-bin.js" + } + }, + "node_modules/p-cancelable": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=12.20" + } + }, + "node_modules/p-limit": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "yocto-queue": "^1.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-locate": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "p-limit": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-map": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "aggregate-error": "^3.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/p-retry": { + "version": "4.6.2", + "license": "MIT", + "dependencies": { + "@types/retry": "0.12.0", + "retry": "^0.13.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/p-try": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/package-json": { + "version": "8.1.1", + "license": "MIT", + "dependencies": { + "got": "^12.1.0", + "registry-auth-token": "^5.0.1", + "registry-url": "^6.0.0", + "semver": "^7.3.7" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/param-case": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-entities": { + "version": "4.0.1", + "license": "MIT", + "dependencies": { + "@types/unist": "^2.0.0", + "character-entities": "^2.0.0", + "character-entities-legacy": "^3.0.0", + "character-reference-invalid": "^2.0.0", + "decode-named-character-reference": "^1.0.0", + "is-alphanumerical": "^2.0.0", + "is-decimal": "^2.0.0", + "is-hexadecimal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/parse-entities/node_modules/@types/unist": { + "version": "2.0.10", + "license": "MIT" + }, + "node_modules/parse-json": { + "version": "5.2.0", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/parse-numeric-range": { + "version": "1.3.0", + "license": "ISC" + }, + "node_modules/parse5": { + "version": "7.1.2", + "license": "MIT", + "dependencies": { + "entities": "^4.4.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parse5-htmlparser2-tree-adapter": { + "version": "7.0.0", + "license": "MIT", + "dependencies": { + "domhandler": "^5.0.2", + "parse5": "^7.0.0" + }, + "funding": { + "url": "https://github.com/inikulin/parse5?sponsor=1" + } + }, + "node_modules/parseurl": { + "version": "1.3.3", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/pascal-case": { + "version": "3.1.2", + "license": "MIT", + "dependencies": { + "no-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/path-exists": { + "version": "5.0.0", + "license": "MIT", + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/path-is-absolute": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/path-is-inside": { + "version": "1.0.2", + "license": "(WTFPL OR MIT)" + }, + "node_modules/path-key": { + "version": "3.1.1", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "license": "MIT" + }, + "node_modules/path-to-regexp": { + "version": "1.8.0", + "license": "MIT", + "dependencies": { + "isarray": "0.0.1" + } + }, + "node_modules/path-type": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/periscopic": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "@types/estree": "^1.0.0", + "estree-walker": "^3.0.0", + "is-reference": "^3.0.0" + } + }, + "node_modules/picocolors": { + "version": "1.0.0", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "2.3.1", + "license": "MIT", + "engines": { + "node": ">=8.6" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/pkg-dir": { + "version": "7.0.0", + "license": "MIT", + "dependencies": { + "find-up": "^6.3.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-up": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "find-up": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/pkg-up/node_modules/find-up": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "locate-path": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/locate-path": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "p-locate": "^3.0.0", + "path-exists": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/p-limit": { + "version": "2.3.0", + "license": "MIT", + "dependencies": { + "p-try": "^2.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/pkg-up/node_modules/p-locate": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "p-limit": "^2.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/pkg-up/node_modules/path-exists": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/possible-typed-array-names": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/postcss": { + "version": "8.4.38", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.7", + "picocolors": "^1.0.0", + "source-map-js": "^1.2.0" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/postcss-calc": { + "version": "9.0.1", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.11", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.2.2" + } + }, + "node_modules/postcss-colormin": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "caniuse-api": "^3.0.0", + "colord": "^2.9.3", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-convert-values": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-comments": { + "version": "6.0.2", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-duplicates": { + "version": "6.0.3", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-empty": { + "version": "6.0.3", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-overridden": { + "version": "6.0.2", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-discard-unused": { + "version": "6.0.5", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.16" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-loader": { + "version": "7.3.4", + "license": "MIT", + "dependencies": { + "cosmiconfig": "^8.3.5", + "jiti": "^1.20.0", + "semver": "^7.5.4" + }, + "engines": { + "node": ">= 14.15.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "postcss": "^7.0.0 || ^8.0.1", + "webpack": "^5.0.0" + } + }, + "node_modules/postcss-loader/node_modules/cosmiconfig": { + "version": "8.3.6", + "license": "MIT", + "dependencies": { + "import-fresh": "^3.3.0", + "js-yaml": "^4.1.0", + "parse-json": "^5.2.0", + "path-type": "^4.0.0" + }, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/d-fischer" + }, + "peerDependencies": { + "typescript": ">=4.9.5" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/postcss-merge-idents": { + "version": "6.0.3", + "license": "MIT", + "dependencies": { + "cssnano-utils": "^4.0.2", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-merge-longhand": { + "version": "6.0.5", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "stylehacks": "^6.1.1" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-merge-rules": { + "version": "6.1.1", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "caniuse-api": "^3.0.0", + "cssnano-utils": "^4.0.2", + "postcss-selector-parser": "^6.0.16" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-font-values": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-gradients": { + "version": "6.0.3", + "license": "MIT", + "dependencies": { + "colord": "^2.9.3", + "cssnano-utils": "^4.0.2", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-params": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "cssnano-utils": "^4.0.2", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-minify-selectors": { + "version": "6.0.4", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.16" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-modules-extract-imports": { + "version": "3.1.0", + "license": "ISC", + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-local-by-default": { + "version": "4.0.5", + "license": "MIT", + "dependencies": { + "icss-utils": "^5.0.0", + "postcss-selector-parser": "^6.0.2", + "postcss-value-parser": "^4.1.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-scope": { + "version": "3.2.0", + "license": "ISC", + "dependencies": { + "postcss-selector-parser": "^6.0.4" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-modules-values": { + "version": "4.0.0", + "license": "ISC", + "dependencies": { + "icss-utils": "^5.0.0" + }, + "engines": { + "node": "^10 || ^12 || >= 14" + }, + "peerDependencies": { + "postcss": "^8.1.0" + } + }, + "node_modules/postcss-normalize-charset": { + "version": "6.0.2", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-display-values": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-positions": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-repeat-style": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-string": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-timing-functions": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-unicode": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-url": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-normalize-whitespace": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-ordered-values": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "cssnano-utils": "^4.0.2", + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-idents": { + "version": "6.0.3", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-initial": { + "version": "6.1.0", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "caniuse-api": "^3.0.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-reduce-transforms": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-selector-parser": { + "version": "6.0.16", + "license": "MIT", + "dependencies": { + "cssesc": "^3.0.0", + "util-deprecate": "^1.0.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/postcss-sort-media-queries": { + "version": "5.2.0", + "license": "MIT", + "dependencies": { + "sort-css-media-queries": "2.2.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "postcss": "^8.4.23" + } + }, + "node_modules/postcss-svgo": { + "version": "6.0.3", + "license": "MIT", + "dependencies": { + "postcss-value-parser": "^4.2.0", + "svgo": "^3.2.0" + }, + "engines": { + "node": "^14 || ^16 || >= 18" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-svgo/node_modules/commander": { + "version": "7.2.0", + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/postcss-svgo/node_modules/css-tree": { + "version": "2.3.1", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.30", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0" + } + }, + "node_modules/postcss-svgo/node_modules/csso": { + "version": "5.0.5", + "license": "MIT", + "dependencies": { + "css-tree": "~2.2.0" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/postcss-svgo/node_modules/csso/node_modules/css-tree": { + "version": "2.2.1", + "license": "MIT", + "dependencies": { + "mdn-data": "2.0.28", + "source-map-js": "^1.0.1" + }, + "engines": { + "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0", + "npm": ">=7.0.0" + } + }, + "node_modules/postcss-svgo/node_modules/csso/node_modules/mdn-data": { + "version": "2.0.28", + "license": "CC0-1.0" + }, + "node_modules/postcss-svgo/node_modules/mdn-data": { + "version": "2.0.30", + "license": "CC0-1.0" + }, + "node_modules/postcss-svgo/node_modules/svgo": { + "version": "3.2.0", + "license": "MIT", + "dependencies": { + "@trysound/sax": "0.2.0", + "commander": "^7.2.0", + "css-select": "^5.1.0", + "css-tree": "^2.3.1", + "css-what": "^6.1.0", + "csso": "^5.0.5", + "picocolors": "^1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/svgo" + } + }, + "node_modules/postcss-unique-selectors": { + "version": "6.0.4", + "license": "MIT", + "dependencies": { + "postcss-selector-parser": "^6.0.16" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/postcss-value-parser": { + "version": "4.2.0", + "license": "MIT" + }, + "node_modules/postcss-zindex": { + "version": "6.0.2", + "license": "MIT", + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/pretty-error": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "lodash": "^4.17.20", + "renderkid": "^3.0.0" + } + }, + "node_modules/pretty-time": { + "version": "1.1.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/prism-react-renderer": { + "version": "2.3.1", + "license": "MIT", + "dependencies": { + "@types/prismjs": "^1.26.0", + "clsx": "^2.0.0" + }, + "peerDependencies": { + "react": ">=16.0.0" + } + }, + "node_modules/prism-react-renderer/node_modules/clsx": { + "version": "2.1.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/prismjs": { + "version": "1.29.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/process-nextick-args": { + "version": "2.0.1", + "license": "MIT" + }, + "node_modules/prompts": { + "version": "2.4.2", + "license": "MIT", + "dependencies": { + "kleur": "^3.0.3", + "sisteransi": "^1.0.5" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/property-information": { + "version": "6.5.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/proto-list": { + "version": "1.2.4", + "license": "ISC" + }, + "node_modules/proxy-addr": { + "version": "2.0.7", + "license": "MIT", + "dependencies": { + "forwarded": "0.2.0", + "ipaddr.js": "1.9.1" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/proxy-addr/node_modules/ipaddr.js": { + "version": "1.9.1", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/punycode": { + "version": "1.4.1", + "license": "MIT" + }, + "node_modules/pupa": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "escape-goat": "^4.0.0" + }, + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/q": { + "version": "1.5.1", + "license": "MIT", + "engines": { + "node": ">=0.6.0", + "teleport": ">=0.2.0" + } + }, + "node_modules/qs": { + "version": "6.11.0", + "license": "BSD-3-Clause", + "dependencies": { + "side-channel": "^1.0.4" + }, + "engines": { + "node": ">=0.6" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/queue": { + "version": "6.0.2", + "license": "MIT", + "dependencies": { + "inherits": "~2.0.3" + } + }, + "node_modules/queue-microtask": { + "version": "1.2.3", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/quick-lru": { + "version": "5.1.1", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/randombytes": { + "version": "2.1.0", + "license": "MIT", + "dependencies": { + "safe-buffer": "^5.1.0" + } + }, + "node_modules/range-parser": { + "version": "1.2.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/raw-body": { + "version": "2.5.2", + "license": "MIT", + "dependencies": { + "bytes": "3.1.2", + "http-errors": "2.0.0", + "iconv-lite": "0.4.24", + "unpipe": "1.0.0" + }, + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/raw-body/node_modules/bytes": { + "version": "3.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/rc": { + "version": "1.2.8", + "license": "(BSD-2-Clause OR MIT OR Apache-2.0)", + "dependencies": { + "deep-extend": "^0.6.0", + "ini": "~1.3.0", + "minimist": "^1.2.0", + "strip-json-comments": "~2.0.1" + }, + "bin": { + "rc": "cli.js" + } + }, + "node_modules/rc/node_modules/strip-json-comments": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react": { + "version": "18.3.1", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dev-utils": { + "version": "12.0.1", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.16.0", + "address": "^1.1.2", + "browserslist": "^4.18.1", + "chalk": "^4.1.2", + "cross-spawn": "^7.0.3", + "detect-port-alt": "^1.1.6", + "escape-string-regexp": "^4.0.0", + "filesize": "^8.0.6", + "find-up": "^5.0.0", + "fork-ts-checker-webpack-plugin": "^6.5.0", + "global-modules": "^2.0.0", + "globby": "^11.0.4", + "gzip-size": "^6.0.0", + "immer": "^9.0.7", + "is-root": "^2.1.0", + "loader-utils": "^3.2.0", + "open": "^8.4.0", + "pkg-up": "^3.1.0", + "prompts": "^2.4.2", + "react-error-overlay": "^6.0.11", + "recursive-readdir": "^2.2.2", + "shell-quote": "^1.7.3", + "strip-ansi": "^6.0.1", + "text-table": "^0.2.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/react-dev-utils/node_modules/find-up": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "locate-path": "^6.0.0", + "path-exists": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/loader-utils": { + "version": "3.2.1", + "license": "MIT", + "engines": { + "node": ">= 12.13.0" + } + }, + "node_modules/react-dev-utils/node_modules/locate-path": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "p-locate": "^5.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/p-limit": { + "version": "3.1.0", + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/p-locate": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "p-limit": "^3.0.2" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dev-utils/node_modules/path-exists": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/react-dev-utils/node_modules/yocto-queue": { + "version": "0.1.0", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/react-dom": { + "version": "18.3.1", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0", + "scheduler": "^0.23.2" + }, + "peerDependencies": { + "react": "^18.3.1" + } + }, + "node_modules/react-error-overlay": { + "version": "6.0.11", + "license": "MIT" + }, + "node_modules/react-fast-compare": { + "version": "3.2.2", + "license": "MIT" + }, + "node_modules/react-helmet-async": { + "version": "1.3.0", + "license": "Apache-2.0", + "dependencies": { + "@babel/runtime": "^7.12.5", + "invariant": "^2.2.4", + "prop-types": "^15.7.2", + "react-fast-compare": "^3.2.0", + "shallowequal": "^1.1.0" + }, + "peerDependencies": { + "react": "^16.6.0 || ^17.0.0 || ^18.0.0", + "react-dom": "^16.6.0 || ^17.0.0 || ^18.0.0" + } + }, + "node_modules/react-is": { + "version": "16.13.1", + "license": "MIT" + }, + "node_modules/react-json-view-lite": { + "version": "1.4.0", + "license": "MIT", + "engines": { + "node": ">=14" + }, + "peerDependencies": { + "react": "^16.13.1 || ^17.0.0 || ^18.0.0" + } + }, + "node_modules/react-loadable": { + "name": "@docusaurus/react-loadable", + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "@types/react": "*" + }, + "peerDependencies": { + "react": "*" + } + }, + "node_modules/react-loadable-ssr-addon-v5-slorber": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.10.3" + }, + "engines": { + "node": ">=10.13.0" + }, + "peerDependencies": { + "react-loadable": "*", + "webpack": ">=4.41.1 || 5.x" + } + }, + "node_modules/react-router": { + "version": "5.3.4", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.13", + "history": "^4.9.0", + "hoist-non-react-statics": "^3.1.0", + "loose-envify": "^1.3.1", + "path-to-regexp": "^1.7.0", + "prop-types": "^15.6.2", + "react-is": "^16.6.0", + "tiny-invariant": "^1.0.2", + "tiny-warning": "^1.0.0" + }, + "peerDependencies": { + "react": ">=15" + } + }, + "node_modules/react-router-config": { + "version": "5.1.1", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.1.2" + }, + "peerDependencies": { + "react": ">=15", + "react-router": ">=5" + } + }, + "node_modules/react-router-dom": { + "version": "5.3.4", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.13", + "history": "^4.9.0", + "loose-envify": "^1.3.1", + "prop-types": "^15.6.2", + "react-router": "5.3.4", + "tiny-invariant": "^1.0.2", + "tiny-warning": "^1.0.0" + }, + "peerDependencies": { + "react": ">=15" + } + }, + "node_modules/react-transition-group": { + "version": "4.4.5", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/runtime": "^7.5.5", + "dom-helpers": "^5.0.1", + "loose-envify": "^1.4.0", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": ">=16.6.0", + "react-dom": ">=16.6.0" + } + }, + "node_modules/readable-stream": { + "version": "3.6.2", + "license": "MIT", + "dependencies": { + "inherits": "^2.0.3", + "string_decoder": "^1.1.1", + "util-deprecate": "^1.0.1" + }, + "engines": { + "node": ">= 6" + } + }, + "node_modules/readdirp": { + "version": "3.6.0", + "license": "MIT", + "dependencies": { + "picomatch": "^2.2.1" + }, + "engines": { + "node": ">=8.10.0" + } + }, + "node_modules/reading-time": { + "version": "1.5.0", + "license": "MIT" + }, + "node_modules/rechoir": { + "version": "0.6.2", + "dependencies": { + "resolve": "^1.1.6" + }, + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/recursive-readdir": { + "version": "2.2.3", + "license": "MIT", + "dependencies": { + "minimatch": "^3.0.5" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/regenerate": { + "version": "1.4.2", + "license": "MIT" + }, + "node_modules/regenerate-unicode-properties": { + "version": "10.1.1", + "license": "MIT", + "dependencies": { + "regenerate": "^1.4.2" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/regenerator-runtime": { + "version": "0.14.1", + "license": "MIT" + }, + "node_modules/regenerator-transform": { + "version": "0.15.2", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.4" + } + }, + "node_modules/regexp.prototype.flags": { + "version": "1.5.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "define-properties": "^1.2.1", + "es-errors": "^1.3.0", + "set-function-name": "^2.0.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/regexpu-core": { + "version": "5.3.2", + "license": "MIT", + "dependencies": { + "@babel/regjsgen": "^0.8.0", + "regenerate": "^1.4.2", + "regenerate-unicode-properties": "^10.1.0", + "regjsparser": "^0.9.1", + "unicode-match-property-ecmascript": "^2.0.0", + "unicode-match-property-value-ecmascript": "^2.1.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/registry-auth-token": { + "version": "5.0.2", + "license": "MIT", + "dependencies": { + "@pnpm/npm-conf": "^2.1.0" + }, + "engines": { + "node": ">=14" + } + }, + "node_modules/registry-url": { + "version": "6.0.1", + "license": "MIT", + "dependencies": { + "rc": "1.2.8" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/regjsparser": { + "version": "0.9.1", + "license": "BSD-2-Clause", + "dependencies": { + "jsesc": "~0.5.0" + }, + "bin": { + "regjsparser": "bin/parser" + } + }, + "node_modules/regjsparser/node_modules/jsesc": { + "version": "0.5.0", + "bin": { + "jsesc": "bin/jsesc" + } + }, + "node_modules/rehype-raw": { + "version": "7.0.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "hast-util-raw": "^9.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/relateurl": { + "version": "0.2.7", + "license": "MIT", + "engines": { + "node": ">= 0.10" + } + }, + "node_modules/remark-directive": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-directive": "^3.0.0", + "micromark-extension-directive": "^3.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-emoji": { + "version": "4.0.1", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.2", + "emoticon": "^4.0.1", + "mdast-util-find-and-replace": "^3.0.1", + "node-emoji": "^2.1.0", + "unified": "^11.0.4" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + } + }, + "node_modules/remark-frontmatter": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-frontmatter": "^2.0.0", + "micromark-extension-frontmatter": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-gfm": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-gfm": "^3.0.0", + "micromark-extension-gfm": "^3.0.0", + "remark-parse": "^11.0.0", + "remark-stringify": "^11.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-mdx": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "mdast-util-mdx": "^3.0.0", + "micromark-extension-mdxjs": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-parse": { + "version": "11.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-from-markdown": "^2.0.0", + "micromark-util-types": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-rehype": { + "version": "11.1.0", + "license": "MIT", + "dependencies": { + "@types/hast": "^3.0.0", + "@types/mdast": "^4.0.0", + "mdast-util-to-hast": "^13.0.0", + "unified": "^11.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/remark-stringify": { + "version": "11.0.0", + "license": "MIT", + "dependencies": { + "@types/mdast": "^4.0.0", + "mdast-util-to-markdown": "^2.0.0", + "unified": "^11.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/renderkid": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "css-select": "^4.1.3", + "dom-converter": "^0.2.0", + "htmlparser2": "^6.1.0", + "lodash": "^4.17.21", + "strip-ansi": "^6.0.1" + } + }, + "node_modules/renderkid/node_modules/css-select": { + "version": "4.3.0", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^6.0.1", + "domhandler": "^4.3.1", + "domutils": "^2.8.0", + "nth-check": "^2.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/renderkid/node_modules/dom-serializer": { + "version": "1.4.1", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.2.0", + "entities": "^2.0.0" + }, + "funding": { + "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1" + } + }, + "node_modules/renderkid/node_modules/domhandler": { + "version": "4.3.1", + "license": "BSD-2-Clause", + "dependencies": { + "domelementtype": "^2.2.0" + }, + "engines": { + "node": ">= 4" + }, + "funding": { + "url": "https://github.com/fb55/domhandler?sponsor=1" + } + }, + "node_modules/renderkid/node_modules/domutils": { + "version": "2.8.0", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "^1.0.1", + "domelementtype": "^2.2.0", + "domhandler": "^4.2.0" + }, + "funding": { + "url": "https://github.com/fb55/domutils?sponsor=1" + } + }, + "node_modules/renderkid/node_modules/entities": { + "version": "2.2.0", + "license": "BSD-2-Clause", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/renderkid/node_modules/htmlparser2": { + "version": "6.1.0", + "funding": [ + "https://github.com/fb55/htmlparser2?sponsor=1", + { + "type": "github", + "url": "https://github.com/sponsors/fb55" + } + ], + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "domhandler": "^4.0.0", + "domutils": "^2.5.2", + "entities": "^2.0.0" + } + }, + "node_modules/require-from-string": { + "version": "2.0.2", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/require-like": { + "version": "0.1.2", + "engines": { + "node": "*" + } + }, + "node_modules/requires-port": { + "version": "1.0.0", + "license": "MIT" + }, + "node_modules/resolve": { + "version": "1.22.8", + "license": "MIT", + "dependencies": { + "is-core-module": "^2.13.0", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-alpn": { + "version": "1.2.1", + "license": "MIT" + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/resolve-pathname": { + "version": "3.0.0", + "license": "MIT" + }, + "node_modules/responselike": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "lowercase-keys": "^3.0.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/retry": { + "version": "0.13.1", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/reusify": { + "version": "1.0.4", + "license": "MIT", + "engines": { + "iojs": ">=1.0.0", + "node": ">=0.10.0" + } + }, + "node_modules/rimraf": { + "version": "3.0.2", + "license": "ISC", + "dependencies": { + "glob": "^7.1.3" + }, + "bin": { + "rimraf": "bin.js" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, + "node_modules/rtl-detect": { + "version": "1.1.2", + "license": "BSD-3-Clause" + }, + "node_modules/rtlcss": { + "version": "4.1.1", + "license": "MIT", + "dependencies": { + "escalade": "^3.1.1", + "picocolors": "^1.0.0", + "postcss": "^8.4.21", + "strip-json-comments": "^3.1.1" + }, + "bin": { + "rtlcss": "bin/rtlcss.js" + }, + "engines": { + "node": ">=12.0.0" + } + }, + "node_modules/run-parallel": { + "version": "1.2.0", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "queue-microtask": "^1.2.2" + } + }, + "node_modules/safe-array-concat": { + "version": "1.1.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "get-intrinsic": "^1.2.4", + "has-symbols": "^1.0.3", + "isarray": "^2.0.5" + }, + "engines": { + "node": ">=0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safe-array-concat/node_modules/isarray": { + "version": "2.0.5", + "license": "MIT" + }, + "node_modules/safe-buffer": { + "version": "5.2.1", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/safe-regex-test": { + "version": "1.0.3", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.6", + "es-errors": "^1.3.0", + "is-regex": "^1.1.4" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "license": "MIT" + }, + "node_modules/sass": { + "version": "1.77.0", + "resolved": "https://registry.npmjs.org/sass/-/sass-1.77.0.tgz", + "integrity": "sha512-eGj4HNfXqBWtSnvItNkn7B6icqH14i3CiCGbzMKs3BAPTq62pp9NBYsBgyN4cA+qssqo9r26lW4JSvlaUUWbgw==", + "dependencies": { + "chokidar": ">=3.0.0 <4.0.0", + "immutable": "^4.0.0", + "source-map-js": ">=0.6.2 <2.0.0" + }, + "bin": { + "sass": "sass.js" + }, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/sass-loader": { + "version": "10.5.2", + "resolved": "https://registry.npmjs.org/sass-loader/-/sass-loader-10.5.2.tgz", + "integrity": "sha512-vMUoSNOUKJILHpcNCCyD23X34gve1TS7Rjd9uXHeKqhvBG39x6XbswFDtpbTElj6XdMFezoWhkh5vtKudf2cgQ==", + "dependencies": { + "klona": "^2.0.4", + "loader-utils": "^2.0.0", + "neo-async": "^2.6.2", + "schema-utils": "^3.0.0", + "semver": "^7.3.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "fibers": ">= 3.1.0", + "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0", + "sass": "^1.3.0", + "webpack": "^4.36.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "fibers": { + "optional": true + }, + "node-sass": { + "optional": true + }, + "sass": { + "optional": true + } + } + }, + "node_modules/sass-loader/node_modules/ajv": { + "version": "6.12.6", + "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz", + "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/sass-loader/node_modules/ajv-keywords": { + "version": "3.5.2", + "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz", + "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/sass-loader/node_modules/json-schema-traverse": { + "version": "0.4.1", + "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz", + "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==" + }, + "node_modules/sass-loader/node_modules/schema-utils": { + "version": "3.3.0", + "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-3.3.0.tgz", + "integrity": "sha512-pN/yOAvcC+5rQ5nERGuwrjLlYvLTbCibnZ1I7B1LaiAz9BRBlE9GMgE/eqV30P7aJQUf7Ddimy/RsbYO/GrVGg==", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/sax": { + "version": "1.3.0", + "license": "ISC" + }, + "node_modules/scheduler": { + "version": "0.23.2", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.1.0" + } + }, + "node_modules/schema-utils": { + "version": "4.2.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.9", + "ajv": "^8.9.0", + "ajv-formats": "^2.1.1", + "ajv-keywords": "^5.1.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/search-insights": { + "version": "2.13.0", + "license": "MIT", + "peer": true + }, + "node_modules/section-matter": { + "version": "1.0.0", + "license": "MIT", + "dependencies": { + "extend-shallow": "^2.0.1", + "kind-of": "^6.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/select-hose": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/selfsigned": { + "version": "2.4.1", + "license": "MIT", + "dependencies": { + "@types/node-forge": "^1.3.0", + "node-forge": "^1" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver": { + "version": "7.6.0", + "license": "ISC", + "dependencies": { + "lru-cache": "^6.0.0" + }, + "bin": { + "semver": "bin/semver.js" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver-diff": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "semver": "^7.3.5" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/semver/node_modules/lru-cache": { + "version": "6.0.0", + "license": "ISC", + "dependencies": { + "yallist": "^4.0.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/semver/node_modules/yallist": { + "version": "4.0.0", + "license": "ISC" + }, + "node_modules/send": { + "version": "0.18.0", + "license": "MIT", + "dependencies": { + "debug": "2.6.9", + "depd": "2.0.0", + "destroy": "1.2.0", + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "etag": "~1.8.1", + "fresh": "0.5.2", + "http-errors": "2.0.0", + "mime": "1.6.0", + "ms": "2.1.3", + "on-finished": "2.4.1", + "range-parser": "~1.2.1", + "statuses": "2.0.1" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/send/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/send/node_modules/debug/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/send/node_modules/ms": { + "version": "2.1.3", + "license": "MIT" + }, + "node_modules/send/node_modules/range-parser": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serialize-javascript": { + "version": "6.0.2", + "license": "BSD-3-Clause", + "dependencies": { + "randombytes": "^2.1.0" + } + }, + "node_modules/serve-handler": { + "version": "6.1.5", + "license": "MIT", + "dependencies": { + "bytes": "3.0.0", + "content-disposition": "0.5.2", + "fast-url-parser": "1.1.3", + "mime-types": "2.1.18", + "minimatch": "3.1.2", + "path-is-inside": "1.0.2", + "path-to-regexp": "2.2.1", + "range-parser": "1.2.0" + } + }, + "node_modules/serve-handler/node_modules/path-to-regexp": { + "version": "2.2.1", + "license": "MIT" + }, + "node_modules/serve-index": { + "version": "1.9.1", + "license": "MIT", + "dependencies": { + "accepts": "~1.3.4", + "batch": "0.6.1", + "debug": "2.6.9", + "escape-html": "~1.0.3", + "http-errors": "~1.6.2", + "mime-types": "~2.1.17", + "parseurl": "~1.3.2" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/serve-index/node_modules/debug": { + "version": "2.6.9", + "license": "MIT", + "dependencies": { + "ms": "2.0.0" + } + }, + "node_modules/serve-index/node_modules/depd": { + "version": "1.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/http-errors": { + "version": "1.6.3", + "license": "MIT", + "dependencies": { + "depd": "~1.1.2", + "inherits": "2.0.3", + "setprototypeof": "1.1.0", + "statuses": ">= 1.4.0 < 2" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-index/node_modules/inherits": { + "version": "2.0.3", + "license": "ISC" + }, + "node_modules/serve-index/node_modules/ms": { + "version": "2.0.0", + "license": "MIT" + }, + "node_modules/serve-index/node_modules/setprototypeof": { + "version": "1.1.0", + "license": "ISC" + }, + "node_modules/serve-index/node_modules/statuses": { + "version": "1.5.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/serve-static": { + "version": "1.15.0", + "license": "MIT", + "dependencies": { + "encodeurl": "~1.0.2", + "escape-html": "~1.0.3", + "parseurl": "~1.3.3", + "send": "0.18.0" + }, + "engines": { + "node": ">= 0.8.0" + } + }, + "node_modules/set-function-length": { + "version": "1.2.2", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "function-bind": "^1.1.2", + "get-intrinsic": "^1.2.4", + "gopd": "^1.0.1", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/set-function-name": { + "version": "2.0.2", + "license": "MIT", + "dependencies": { + "define-data-property": "^1.1.4", + "es-errors": "^1.3.0", + "functions-have-names": "^1.2.3", + "has-property-descriptors": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/setprototypeof": { + "version": "1.2.0", + "license": "ISC" + }, + "node_modules/shallow-clone": { + "version": "3.0.1", + "license": "MIT", + "dependencies": { + "kind-of": "^6.0.2" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shallowequal": { + "version": "1.1.0", + "license": "MIT" + }, + "node_modules/shebang-command": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "shebang-regex": "^3.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/shebang-regex": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/shell-quote": { + "version": "1.8.1", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/shelljs": { + "version": "0.8.5", + "license": "BSD-3-Clause", + "dependencies": { + "glob": "^7.0.0", + "interpret": "^1.0.0", + "rechoir": "^0.6.2" + }, + "bin": { + "shjs": "bin/shjs" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/side-channel": { + "version": "1.0.6", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "get-intrinsic": "^1.2.4", + "object-inspect": "^1.13.1" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/signal-exit": { + "version": "3.0.7", + "license": "ISC" + }, + "node_modules/sirv": { + "version": "2.0.4", + "license": "MIT", + "dependencies": { + "@polka/url": "^1.0.0-next.24", + "mrmime": "^2.0.0", + "totalist": "^3.0.0" + }, + "engines": { + "node": ">= 10" + } + }, + "node_modules/sisteransi": { + "version": "1.0.5", + "license": "MIT" + }, + "node_modules/sitemap": { + "version": "7.1.1", + "license": "MIT", + "dependencies": { + "@types/node": "^17.0.5", + "@types/sax": "^1.2.1", + "arg": "^5.0.0", + "sax": "^1.2.4" + }, + "bin": { + "sitemap": "dist/cli.js" + }, + "engines": { + "node": ">=12.0.0", + "npm": ">=5.6.0" + } + }, + "node_modules/sitemap/node_modules/@types/node": { + "version": "17.0.45", + "license": "MIT" + }, + "node_modules/skin-tone": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "unicode-emoji-modifier-base": "^1.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/slash": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/snake-case": { + "version": "3.0.4", + "license": "MIT", + "dependencies": { + "dot-case": "^3.0.4", + "tslib": "^2.0.3" + } + }, + "node_modules/sockjs": { + "version": "0.3.24", + "license": "MIT", + "dependencies": { + "faye-websocket": "^0.11.3", + "uuid": "^8.3.2", + "websocket-driver": "^0.7.4" + } + }, + "node_modules/sort-css-media-queries": { + "version": "2.2.0", + "license": "MIT", + "engines": { + "node": ">= 6.3.0" + } + }, + "node_modules/source-map": { + "version": "0.7.4", + "license": "BSD-3-Clause", + "engines": { + "node": ">= 8" + } + }, + "node_modules/source-map-js": { + "version": "1.2.0", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-support": { + "version": "0.5.21", + "license": "MIT", + "dependencies": { + "buffer-from": "^1.0.0", + "source-map": "^0.6.0" + } + }, + "node_modules/source-map-support/node_modules/source-map": { + "version": "0.6.1", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/space-separated-tokens": { + "version": "2.0.2", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/spdy": { + "version": "4.0.2", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "handle-thing": "^2.0.0", + "http-deceiver": "^1.2.7", + "select-hose": "^2.0.0", + "spdy-transport": "^3.0.0" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/spdy-transport": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "debug": "^4.1.0", + "detect-node": "^2.0.4", + "hpack.js": "^2.1.6", + "obuf": "^1.1.2", + "readable-stream": "^3.0.6", + "wbuf": "^1.7.3" + } + }, + "node_modules/sprintf-js": { + "version": "1.0.3", + "license": "BSD-3-Clause" + }, + "node_modules/srcset": { + "version": "4.0.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/stable": { + "version": "0.1.8", + "license": "MIT" + }, + "node_modules/statuses": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/std-env": { + "version": "3.7.0", + "license": "MIT" + }, + "node_modules/string_decoder": { + "version": "1.3.0", + "license": "MIT", + "dependencies": { + "safe-buffer": "~5.2.0" + } + }, + "node_modules/string-width": { + "version": "5.1.2", + "license": "MIT", + "dependencies": { + "eastasianwidth": "^0.2.0", + "emoji-regex": "^9.2.2", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/string-width/node_modules/ansi-regex": { + "version": "6.0.1", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/string-width/node_modules/strip-ansi": { + "version": "7.1.0", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/string.prototype.trim": { + "version": "1.2.9", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-abstract": "^1.23.0", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimend": { + "version": "1.0.8", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/string.prototype.trimstart": { + "version": "1.0.8", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "define-properties": "^1.2.1", + "es-object-atoms": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/stringify-entities": { + "version": "4.0.4", + "license": "MIT", + "dependencies": { + "character-entities-html4": "^2.0.0", + "character-entities-legacy": "^3.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/stringify-object": { + "version": "3.3.0", + "license": "BSD-2-Clause", + "dependencies": { + "get-own-enumerable-property-symbols": "^3.0.0", + "is-obj": "^1.0.1", + "is-regexp": "^1.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "license": "MIT", + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/strip-bom-string": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/strip-final-newline": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/strip-json-comments": { + "version": "3.1.1", + "license": "MIT", + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/style-to-object": { + "version": "0.4.4", + "license": "MIT", + "dependencies": { + "inline-style-parser": "0.1.1" + } + }, + "node_modules/stylehacks": { + "version": "6.1.1", + "license": "MIT", + "dependencies": { + "browserslist": "^4.23.0", + "postcss-selector-parser": "^6.0.16" + }, + "engines": { + "node": "^14 || ^16 || >=18.0" + }, + "peerDependencies": { + "postcss": "^8.4.31" + } + }, + "node_modules/supports-color": { + "version": "7.2.0", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/svg-parser": { + "version": "2.0.4", + "license": "MIT" + }, + "node_modules/svgo": { + "version": "1.3.2", + "license": "MIT", + "dependencies": { + "chalk": "^2.4.1", + "coa": "^2.0.2", + "css-select": "^2.0.0", + "css-select-base-adapter": "^0.1.1", + "css-tree": "1.0.0-alpha.37", + "csso": "^4.0.2", + "js-yaml": "^3.13.1", + "mkdirp": "~0.5.1", + "object.values": "^1.1.0", + "sax": "~1.2.4", + "stable": "^0.1.8", + "unquote": "~1.1.1", + "util.promisify": "~1.0.0" + }, + "bin": { + "svgo": "bin/svgo" + }, + "engines": { + "node": ">=4.0.0" + } + }, + "node_modules/svgo/node_modules/ansi-styles": { + "version": "3.2.1", + "license": "MIT", + "dependencies": { + "color-convert": "^1.9.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/argparse": { + "version": "1.0.10", + "license": "MIT", + "dependencies": { + "sprintf-js": "~1.0.2" + } + }, + "node_modules/svgo/node_modules/chalk": { + "version": "2.4.2", + "license": "MIT", + "dependencies": { + "ansi-styles": "^3.2.1", + "escape-string-regexp": "^1.0.5", + "supports-color": "^5.3.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/color-convert": { + "version": "1.9.3", + "license": "MIT", + "dependencies": { + "color-name": "1.1.3" + } + }, + "node_modules/svgo/node_modules/color-name": { + "version": "1.1.3", + "license": "MIT" + }, + "node_modules/svgo/node_modules/css-select": { + "version": "2.1.0", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "^1.0.0", + "css-what": "^3.2.1", + "domutils": "^1.7.0", + "nth-check": "^1.0.2" + } + }, + "node_modules/svgo/node_modules/css-what": { + "version": "3.4.2", + "license": "BSD-2-Clause", + "engines": { + "node": ">= 6" + }, + "funding": { + "url": "https://github.com/sponsors/fb55" + } + }, + "node_modules/svgo/node_modules/dom-serializer": { + "version": "0.2.2", + "license": "MIT", + "dependencies": { + "domelementtype": "^2.0.1", + "entities": "^2.0.0" + } + }, + "node_modules/svgo/node_modules/domutils": { + "version": "1.7.0", + "license": "BSD-2-Clause", + "dependencies": { + "dom-serializer": "0", + "domelementtype": "1" + } + }, + "node_modules/svgo/node_modules/domutils/node_modules/domelementtype": { + "version": "1.3.1", + "license": "BSD-2-Clause" + }, + "node_modules/svgo/node_modules/entities": { + "version": "2.2.0", + "license": "BSD-2-Clause", + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/svgo/node_modules/escape-string-regexp": { + "version": "1.0.5", + "license": "MIT", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/svgo/node_modules/has-flag": { + "version": "3.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/svgo/node_modules/js-yaml": { + "version": "3.14.1", + "license": "MIT", + "dependencies": { + "argparse": "^1.0.7", + "esprima": "^4.0.0" + }, + "bin": { + "js-yaml": "bin/js-yaml.js" + } + }, + "node_modules/svgo/node_modules/nth-check": { + "version": "1.0.2", + "license": "BSD-2-Clause", + "dependencies": { + "boolbase": "~1.0.0" + } + }, + "node_modules/svgo/node_modules/sax": { + "version": "1.2.4", + "license": "ISC" + }, + "node_modules/svgo/node_modules/supports-color": { + "version": "5.5.0", + "license": "MIT", + "dependencies": { + "has-flag": "^3.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/tapable": { + "version": "2.2.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/terser": { + "version": "5.31.0", + "license": "BSD-2-Clause", + "dependencies": { + "@jridgewell/source-map": "^0.3.3", + "acorn": "^8.8.2", + "commander": "^2.20.0", + "source-map-support": "~0.5.20" + }, + "bin": { + "terser": "bin/terser" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/terser-webpack-plugin": { + "version": "5.3.10", + "license": "MIT", + "dependencies": { + "@jridgewell/trace-mapping": "^0.3.20", + "jest-worker": "^27.4.5", + "schema-utils": "^3.1.1", + "serialize-javascript": "^6.0.1", + "terser": "^5.26.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^5.1.0" + }, + "peerDependenciesMeta": { + "@swc/core": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "uglify-js": { + "optional": true + } + } + }, + "node_modules/terser-webpack-plugin/node_modules/ajv": { + "version": "6.12.6", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/terser-webpack-plugin/node_modules/ajv-keywords": { + "version": "3.5.2", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/terser-webpack-plugin/node_modules/jest-worker": { + "version": "27.5.1", + "license": "MIT", + "dependencies": { + "@types/node": "*", + "merge-stream": "^2.0.0", + "supports-color": "^8.0.0" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/terser-webpack-plugin/node_modules/json-schema-traverse": { + "version": "0.4.1", + "license": "MIT" + }, + "node_modules/terser-webpack-plugin/node_modules/schema-utils": { + "version": "3.3.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/terser-webpack-plugin/node_modules/supports-color": { + "version": "8.1.1", + "license": "MIT", + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/terser/node_modules/commander": { + "version": "2.20.3", + "license": "MIT" + }, + "node_modules/text-table": { + "version": "0.2.0", + "license": "MIT" + }, + "node_modules/thunky": { + "version": "1.1.0", + "license": "MIT" + }, + "node_modules/tiny-invariant": { + "version": "1.3.3", + "license": "MIT" + }, + "node_modules/tiny-warning": { + "version": "1.0.3", + "license": "MIT" + }, + "node_modules/to-fast-properties": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/to-regex-range": { + "version": "5.0.1", + "license": "MIT", + "dependencies": { + "is-number": "^7.0.0" + }, + "engines": { + "node": ">=8.0" + } + }, + "node_modules/toidentifier": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">=0.6" + } + }, + "node_modules/totalist": { + "version": "3.0.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/trim-lines": { + "version": "3.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/trough": { + "version": "2.2.0", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/tslib": { + "version": "2.6.2", + "license": "0BSD" + }, + "node_modules/type-fest": { + "version": "2.19.0", + "license": "(MIT OR CC0-1.0)", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/type-is": { + "version": "1.6.18", + "license": "MIT", + "dependencies": { + "media-typer": "0.3.0", + "mime-types": "~2.1.24" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/type-is/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/type-is/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/typed-array-buffer": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "es-errors": "^1.3.0", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/typed-array-byte-length": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-proto": "^1.0.3", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-byte-offset": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-proto": "^1.0.3", + "is-typed-array": "^1.1.13" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typed-array-length": { + "version": "1.0.6", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-proto": "^1.0.3", + "is-typed-array": "^1.1.13", + "possible-typed-array-names": "^1.0.0" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/typedarray-to-buffer": { + "version": "3.1.5", + "license": "MIT", + "dependencies": { + "is-typedarray": "^1.0.0" + } + }, + "node_modules/typescript": { + "version": "5.2.2", + "license": "Apache-2.0", + "bin": { + "tsc": "bin/tsc", + "tsserver": "bin/tsserver" + }, + "engines": { + "node": ">=14.17" + } + }, + "node_modules/unbox-primitive": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "call-bind": "^1.0.2", + "has-bigints": "^1.0.2", + "has-symbols": "^1.0.3", + "which-boxed-primitive": "^1.0.2" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/undici-types": { + "version": "5.26.5", + "license": "MIT" + }, + "node_modules/unicode-canonical-property-names-ecmascript": { + "version": "2.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-emoji-modifier-base": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-ecmascript": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "unicode-canonical-property-names-ecmascript": "^2.0.0", + "unicode-property-aliases-ecmascript": "^2.0.0" + }, + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-match-property-value-ecmascript": { + "version": "2.1.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unicode-property-aliases-ecmascript": { + "version": "2.1.0", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/unified": { + "version": "11.0.4", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "bail": "^2.0.0", + "devlop": "^1.0.0", + "extend": "^3.0.0", + "is-plain-obj": "^4.0.0", + "trough": "^2.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unique-string": { + "version": "3.0.0", + "license": "MIT", + "dependencies": { + "crypto-random-string": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/unist-util-is": { + "version": "6.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position-from-estree": { + "version": "2.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-remove-position": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-visit": "^5.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "4.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit": { + "version": "5.0.0", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0", + "unist-util-visit-parents": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit-parents": { + "version": "6.0.1", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/universalify": { + "version": "2.0.1", + "license": "MIT", + "engines": { + "node": ">= 10.0.0" + } + }, + "node_modules/unpipe": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/unquote": { + "version": "1.1.1", + "license": "MIT" + }, + "node_modules/update-browserslist-db": { + "version": "1.0.15", + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/browserslist" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/browserslist" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "escalade": "^3.1.2", + "picocolors": "^1.0.0" + }, + "bin": { + "update-browserslist-db": "cli.js" + }, + "peerDependencies": { + "browserslist": ">= 4.21.0" + } + }, + "node_modules/update-notifier": { + "version": "6.0.2", + "license": "BSD-2-Clause", + "dependencies": { + "boxen": "^7.0.0", + "chalk": "^5.0.1", + "configstore": "^6.0.0", + "has-yarn": "^3.0.0", + "import-lazy": "^4.0.0", + "is-ci": "^3.0.1", + "is-installed-globally": "^0.4.0", + "is-npm": "^6.0.0", + "is-yarn-global": "^0.4.0", + "latest-version": "^7.0.0", + "pupa": "^3.1.0", + "semver": "^7.3.7", + "semver-diff": "^4.0.0", + "xdg-basedir": "^5.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/yeoman/update-notifier?sponsor=1" + } + }, + "node_modules/update-notifier/node_modules/boxen": { + "version": "7.1.1", + "license": "MIT", + "dependencies": { + "ansi-align": "^3.0.1", + "camelcase": "^7.0.1", + "chalk": "^5.2.0", + "cli-boxes": "^3.0.0", + "string-width": "^5.1.2", + "type-fest": "^2.13.0", + "widest-line": "^4.0.1", + "wrap-ansi": "^8.1.0" + }, + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/update-notifier/node_modules/camelcase": { + "version": "7.0.1", + "license": "MIT", + "engines": { + "node": ">=14.16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/update-notifier/node_modules/chalk": { + "version": "5.3.0", + "license": "MIT", + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/uri-js": { + "version": "4.4.1", + "license": "BSD-2-Clause", + "dependencies": { + "punycode": "^2.1.0" + } + }, + "node_modules/uri-js/node_modules/punycode": { + "version": "2.3.1", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/url-loader": { + "version": "4.1.1", + "license": "MIT", + "dependencies": { + "loader-utils": "^2.0.0", + "mime-types": "^2.1.27", + "schema-utils": "^3.0.0" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "file-loader": "*", + "webpack": "^4.0.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "file-loader": { + "optional": true + } + } + }, + "node_modules/url-loader/node_modules/ajv": { + "version": "6.12.6", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/url-loader/node_modules/ajv-keywords": { + "version": "3.5.2", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/url-loader/node_modules/json-schema-traverse": { + "version": "0.4.1", + "license": "MIT" + }, + "node_modules/url-loader/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/url-loader/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/url-loader/node_modules/schema-utils": { + "version": "3.3.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/util-deprecate": { + "version": "1.0.2", + "license": "MIT" + }, + "node_modules/util.promisify": { + "version": "1.0.1", + "license": "MIT", + "dependencies": { + "define-properties": "^1.1.3", + "es-abstract": "^1.17.2", + "has-symbols": "^1.0.1", + "object.getownpropertydescriptors": "^2.1.0" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/utila": { + "version": "0.4.0", + "license": "MIT" + }, + "node_modules/utility-types": { + "version": "3.11.0", + "license": "MIT", + "engines": { + "node": ">= 4" + } + }, + "node_modules/utils-merge": { + "version": "1.0.1", + "license": "MIT", + "engines": { + "node": ">= 0.4.0" + } + }, + "node_modules/uuid": { + "version": "8.3.2", + "license": "MIT", + "bin": { + "uuid": "dist/bin/uuid" + } + }, + "node_modules/value-equal": { + "version": "1.0.1", + "license": "MIT" + }, + "node_modules/vary": { + "version": "1.1.2", + "license": "MIT", + "engines": { + "node": ">= 0.8" + } + }, + "node_modules/vfile": { + "version": "6.0.1", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-location": { + "version": "5.0.2", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "vfile": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "4.0.2", + "license": "MIT", + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/watchpack": { + "version": "2.4.1", + "license": "MIT", + "dependencies": { + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.1.2" + }, + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/wbuf": { + "version": "1.7.3", + "license": "MIT", + "dependencies": { + "minimalistic-assert": "^1.0.0" + } + }, + "node_modules/web-namespaces": { + "version": "2.0.1", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/webpack": { + "version": "5.91.0", + "license": "MIT", + "dependencies": { + "@types/eslint-scope": "^3.7.3", + "@types/estree": "^1.0.5", + "@webassemblyjs/ast": "^1.12.1", + "@webassemblyjs/wasm-edit": "^1.12.1", + "@webassemblyjs/wasm-parser": "^1.12.1", + "acorn": "^8.7.1", + "acorn-import-assertions": "^1.9.0", + "browserslist": "^4.21.10", + "chrome-trace-event": "^1.0.2", + "enhanced-resolve": "^5.16.0", + "es-module-lexer": "^1.2.1", + "eslint-scope": "5.1.1", + "events": "^3.2.0", + "glob-to-regexp": "^0.4.1", + "graceful-fs": "^4.2.11", + "json-parse-even-better-errors": "^2.3.1", + "loader-runner": "^4.2.0", + "mime-types": "^2.1.27", + "neo-async": "^2.6.2", + "schema-utils": "^3.2.0", + "tapable": "^2.1.1", + "terser-webpack-plugin": "^5.3.10", + "watchpack": "^2.4.1", + "webpack-sources": "^3.2.3" + }, + "bin": { + "webpack": "bin/webpack.js" + }, + "engines": { + "node": ">=10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependenciesMeta": { + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-bundle-analyzer": { + "version": "4.10.2", + "license": "MIT", + "dependencies": { + "@discoveryjs/json-ext": "0.5.7", + "acorn": "^8.0.4", + "acorn-walk": "^8.0.0", + "commander": "^7.2.0", + "debounce": "^1.2.1", + "escape-string-regexp": "^4.0.0", + "gzip-size": "^6.0.0", + "html-escaper": "^2.0.2", + "opener": "^1.5.2", + "picocolors": "^1.0.0", + "sirv": "^2.0.3", + "ws": "^7.3.1" + }, + "bin": { + "webpack-bundle-analyzer": "lib/bin/analyzer.js" + }, + "engines": { + "node": ">= 10.13.0" + } + }, + "node_modules/webpack-bundle-analyzer/node_modules/commander": { + "version": "7.2.0", + "license": "MIT", + "engines": { + "node": ">= 10" + } + }, + "node_modules/webpack-dev-middleware": { + "version": "5.3.4", + "license": "MIT", + "dependencies": { + "colorette": "^2.0.10", + "memfs": "^3.4.3", + "mime-types": "^2.1.31", + "range-parser": "^1.2.1", + "schema-utils": "^4.0.0" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.0.0 || ^5.0.0" + } + }, + "node_modules/webpack-dev-middleware/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/webpack-dev-middleware/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/webpack-dev-middleware/node_modules/range-parser": { + "version": "1.2.1", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/webpack-dev-server": { + "version": "4.15.2", + "license": "MIT", + "dependencies": { + "@types/bonjour": "^3.5.9", + "@types/connect-history-api-fallback": "^1.3.5", + "@types/express": "^4.17.13", + "@types/serve-index": "^1.9.1", + "@types/serve-static": "^1.13.10", + "@types/sockjs": "^0.3.33", + "@types/ws": "^8.5.5", + "ansi-html-community": "^0.0.8", + "bonjour-service": "^1.0.11", + "chokidar": "^3.5.3", + "colorette": "^2.0.10", + "compression": "^1.7.4", + "connect-history-api-fallback": "^2.0.0", + "default-gateway": "^6.0.3", + "express": "^4.17.3", + "graceful-fs": "^4.2.6", + "html-entities": "^2.3.2", + "http-proxy-middleware": "^2.0.3", + "ipaddr.js": "^2.0.1", + "launch-editor": "^2.6.0", + "open": "^8.0.9", + "p-retry": "^4.5.0", + "rimraf": "^3.0.2", + "schema-utils": "^4.0.0", + "selfsigned": "^2.1.1", + "serve-index": "^1.9.1", + "sockjs": "^0.3.24", + "spdy": "^4.0.2", + "webpack-dev-middleware": "^5.3.4", + "ws": "^8.13.0" + }, + "bin": { + "webpack-dev-server": "bin/webpack-dev-server.js" + }, + "engines": { + "node": ">= 12.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + }, + "peerDependencies": { + "webpack": "^4.37.0 || ^5.0.0" + }, + "peerDependenciesMeta": { + "webpack": { + "optional": true + }, + "webpack-cli": { + "optional": true + } + } + }, + "node_modules/webpack-dev-server/node_modules/ws": { + "version": "8.17.0", + "license": "MIT", + "engines": { + "node": ">=10.0.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": ">=5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/webpack-merge": { + "version": "5.10.0", + "license": "MIT", + "dependencies": { + "clone-deep": "^4.0.1", + "flat": "^5.0.2", + "wildcard": "^2.0.0" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/webpack-sources": { + "version": "3.2.3", + "license": "MIT", + "engines": { + "node": ">=10.13.0" + } + }, + "node_modules/webpack/node_modules/ajv": { + "version": "6.12.6", + "license": "MIT", + "dependencies": { + "fast-deep-equal": "^3.1.1", + "fast-json-stable-stringify": "^2.0.0", + "json-schema-traverse": "^0.4.1", + "uri-js": "^4.2.2" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/epoberezkin" + } + }, + "node_modules/webpack/node_modules/ajv-keywords": { + "version": "3.5.2", + "license": "MIT", + "peerDependencies": { + "ajv": "^6.9.1" + } + }, + "node_modules/webpack/node_modules/json-schema-traverse": { + "version": "0.4.1", + "license": "MIT" + }, + "node_modules/webpack/node_modules/mime-db": { + "version": "1.52.0", + "license": "MIT", + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/webpack/node_modules/mime-types": { + "version": "2.1.35", + "license": "MIT", + "dependencies": { + "mime-db": "1.52.0" + }, + "engines": { + "node": ">= 0.6" + } + }, + "node_modules/webpack/node_modules/schema-utils": { + "version": "3.3.0", + "license": "MIT", + "dependencies": { + "@types/json-schema": "^7.0.8", + "ajv": "^6.12.5", + "ajv-keywords": "^3.5.2" + }, + "engines": { + "node": ">= 10.13.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/webpack" + } + }, + "node_modules/webpackbar": { + "version": "5.0.2", + "license": "MIT", + "dependencies": { + "chalk": "^4.1.0", + "consola": "^2.15.3", + "pretty-time": "^1.1.0", + "std-env": "^3.0.1" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "webpack": "3 || 4 || 5" + } + }, + "node_modules/websocket-driver": { + "version": "0.7.4", + "license": "Apache-2.0", + "dependencies": { + "http-parser-js": ">=0.5.1", + "safe-buffer": ">=5.1.0", + "websocket-extensions": ">=0.1.1" + }, + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/websocket-extensions": { + "version": "0.1.4", + "license": "Apache-2.0", + "engines": { + "node": ">=0.8.0" + } + }, + "node_modules/which": { + "version": "2.0.2", + "license": "ISC", + "dependencies": { + "isexe": "^2.0.0" + }, + "bin": { + "node-which": "bin/node-which" + }, + "engines": { + "node": ">= 8" + } + }, + "node_modules/which-boxed-primitive": { + "version": "1.0.2", + "license": "MIT", + "dependencies": { + "is-bigint": "^1.0.1", + "is-boolean-object": "^1.1.0", + "is-number-object": "^1.0.4", + "is-string": "^1.0.5", + "is-symbol": "^1.0.3" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/which-typed-array": { + "version": "1.1.15", + "license": "MIT", + "dependencies": { + "available-typed-arrays": "^1.0.7", + "call-bind": "^1.0.7", + "for-each": "^0.3.3", + "gopd": "^1.0.1", + "has-tostringtag": "^1.0.2" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/widest-line": { + "version": "4.0.1", + "license": "MIT", + "dependencies": { + "string-width": "^5.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/wildcard": { + "version": "2.0.1", + "license": "MIT" + }, + "node_modules/wrap-ansi": { + "version": "8.1.0", + "license": "MIT", + "dependencies": { + "ansi-styles": "^6.1.0", + "string-width": "^5.0.1", + "strip-ansi": "^7.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-regex": { + "version": "6.0.1", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/ansi-styles": { + "version": "6.2.1", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/wrap-ansi/node_modules/strip-ansi": { + "version": "7.1.0", + "license": "MIT", + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/wrappy": { + "version": "1.0.2", + "license": "ISC" + }, + "node_modules/write-file-atomic": { + "version": "3.0.3", + "license": "ISC", + "dependencies": { + "imurmurhash": "^0.1.4", + "is-typedarray": "^1.0.0", + "signal-exit": "^3.0.2", + "typedarray-to-buffer": "^3.1.5" + } + }, + "node_modules/ws": { + "version": "7.5.9", + "license": "MIT", + "engines": { + "node": ">=8.3.0" + }, + "peerDependencies": { + "bufferutil": "^4.0.1", + "utf-8-validate": "^5.0.2" + }, + "peerDependenciesMeta": { + "bufferutil": { + "optional": true + }, + "utf-8-validate": { + "optional": true + } + } + }, + "node_modules/xdg-basedir": { + "version": "5.1.0", + "license": "MIT", + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/xml-js": { + "version": "1.6.11", + "license": "MIT", + "dependencies": { + "sax": "^1.2.4" + }, + "bin": { + "xml-js": "bin/cli.js" + } + }, + "node_modules/yallist": { + "version": "3.1.1", + "license": "ISC" + }, + "node_modules/yaml": { + "version": "1.10.2", + "license": "ISC", + "engines": { + "node": ">= 6" + } + }, + "node_modules/yocto-queue": { + "version": "1.0.0", + "license": "MIT", + "engines": { + "node": ">=12.20" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/zwitch": { + "version": "2.0.4", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + } + } +} diff --git a/website/package.json b/website/package.json new file mode 100644 index 0000000000..584ea36333 --- /dev/null +++ b/website/package.json @@ -0,0 +1,57 @@ +{ + "name": "silk-net-website", + "version": "0.0.0", + "private": true, + "scripts": { + "docusaurus": "docusaurus", + "start": "docusaurus start", + "build": "docusaurus build", + "swizzle": "docusaurus swizzle", + "deploy": "docusaurus deploy", + "clear": "docusaurus clear", + "serve": "docusaurus serve", + "write-translations": "docusaurus write-translations", + "write-heading-ids": "docusaurus write-heading-ids", + "typecheck": "tsc" + }, + "dependencies": { + "@docusaurus/core": "3.3.2", + "@docusaurus/preset-classic": "3.3.2", + "@fortawesome/fontawesome-svg-core": "^6.5.1", + "@fortawesome/free-brands-svg-icons": "^6.5.1", + "@fortawesome/free-regular-svg-icons": "^6.5.1", + "@fortawesome/free-solid-svg-icons": "^6.5.1", + "@fortawesome/react-fontawesome": "^0.2.0", + "@mdx-js/react": "^3.0.0", + "@svgr/webpack": "^5.5.0", + "clsx": "^1.1.1", + "docusaurus-plugin-sass": "^0.2.5", + "file-loader": "^6.2.0", + "prism-react-renderer": "^2.1.0", + "react": "^18.3.0", + "react-dom": "^18.3.0", + "react-transition-group": "^4.4.5", + "sass": "^1.77.0", + "url-loader": "^4.1.1" + }, + "devDependencies": { + "@docusaurus/module-type-aliases": "3.0.0", + "@docusaurus/tsconfig": "3.0.0", + "@types/react": "^18.2.29", + "@types/react-helmet": "^6.1.2", + "@types/react-router-dom": "^5.1.8", + "typescript": "~5.2.2" + }, + "browserslist": { + "production": [ + ">0.5%", + "not dead", + "not op_mini all" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] + } +} diff --git a/website/sidebars.js b/website/sidebars.js new file mode 100644 index 0000000000..981a73cd7a --- /dev/null +++ b/website/sidebars.js @@ -0,0 +1,26 @@ +/** + * Creating a sidebar enables you to: + - create an ordered group of docs + - render a sidebar for each doc of that group + - provide next/previous navigation + + The sidebars can be generated from the filesystem, or explicitly defined here. + + Create as many sidebars as you want. + */ + +module.exports = { + // By default, Docusaurus generates a sidebar from the docs folder structure + tutorialSidebar: [{type: 'autogenerated', dirName: '.'}], + + // But you can create a sidebar manually + /* + tutorialSidebar: [ + { + type: 'category', + label: 'Tutorial', + items: ['hello'], + }, + ], + */ +}; diff --git a/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.module.scss b/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.module.scss new file mode 100644 index 0000000000..0310922ef2 --- /dev/null +++ b/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.module.scss @@ -0,0 +1,40 @@ +img { + user-select: none; +} + +.content { + display: flex; + flex-direction: column; + align-items: center; +} + +.title { + text-align: center; +} + +.item { + display: flex; +} + +.item span { + height: 30px; + width: 30px; + aspect-ratio: 1/1; + background-color: rgba(65, 215, 242, .3); + border-radius: 100%; + display: flex; + align-items: center; + justify-content: center; + margin-right: 20px; +} + +@media screen and (max-width: 478px) +{ + .item { + flex-direction: column; + align-items: center; + text-align: center; + + padding: 10px; + } +} \ No newline at end of file diff --git a/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.tsx b/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.tsx new file mode 100644 index 0000000000..87568c6092 --- /dev/null +++ b/website/src/components/mainPage/AllInOneSolution/AllinOneSolution.tsx @@ -0,0 +1,33 @@ +import React from "react"; +import styles from "./AllinOneSolution.module.scss"; +import { FontAwesomeIcon } from "@fortawesome/react-fontawesome"; +import { faTrowelBricks, faMobileScreen, faFaceSmile } from "@fortawesome/free-solid-svg-icons"; + +export default function AllInOneSolution(): JSX.Element { + + return ( +
+ +

An All-in-one solution

+ + + +
+ +

First-party bindings for over 17 individual APIs

+
+ +
+ +

Official support for all major desktop & mobile platforms

+
+ +
+ +

Friendly and active community & developers

+
+ +
+ ); + +} \ No newline at end of file diff --git a/website/src/components/mainPage/JoinConversation/joinConversation.module.scss b/website/src/components/mainPage/JoinConversation/joinConversation.module.scss new file mode 100644 index 0000000000..e5bfab4c01 --- /dev/null +++ b/website/src/components/mainPage/JoinConversation/joinConversation.module.scss @@ -0,0 +1,285 @@ +.body { + margin: 30px 0; +} + +.title { + text-align: center; +} + +.wigdgetsContainer { + display: flex; + justify-content: space-evenly; + margin: 10px 5px 30px 5px; +} + +.discordWigdget { + position: relative; + width: calc(50% - 100px); + min-height: 250px; + + background: #424549; + border: 2px solid #1e2124; + border-radius: 20px; + + color: white; + + overflow: hidden; +} + +.discordWigdget .topBar { + background: #36393e; + height: calc(40px + 30px); +} + +.discordWigdget .icon { + position: absolute; + + top: 30px; + left: 30px; + + height: 70px; + width: 70px; + background:white url('/img/silkdotnet_v3.svg'); + background-size: 80%; + background-repeat: no-repeat; + background-position: center; + border: 2px solid #282b30; + border-radius: 10px; +} + +.discordWigdget .discordLogo { + position: absolute; + + top: 20px; + right: 20px; + + height: 30px; + width: 150px; + background: url('/img/others/discord-logo-white.svg'); + background-size: 80%; + background-repeat: no-repeat; + background-position: center; +} + +.discordWigdget .content { + margin: 20px 20px 20px 150px; +} + +.discordWigdget .content p { + margin: 0; +} + +.discordWigdget .content p::before { + display:inline-block; + content: ""; + height: 20px; + width: 20px; + margin-top: 4px; + margin-bottom: -4px; + margin-right: 5px; + background: url('/img/others/discord-star.png'); + background-size: 100%; + background-repeat: no-repeat; + background-position: center; +} +.discordWigdget .content p { + + .channelLink { + background-color: rgba(17, 121, 156, 0.8); + border-radius: 5px; + padding: 0 5px; + } + + .channelLink::before { + content: "#"; + font-family: 'Arial Narrow', Arial, sans-serif; + margin-right: 5px; + } + +} + +.discordWigdget .joinButton { + position: absolute; + background-color: #7289da; + + color: white; + text-decoration: none; + + padding: 10px 20px; + border-radius: 5px; + + left: 20px; + bottom: 20px; +} + +html[data-theme='dark'] .githubWigdget { + --gh-background-hard-color: #0d1117; + --gh-background-soft-color: #24292d; + --gh-main-color: #4078c0; + --gh-border-color: #848d97; + + --gh-transparent-bg-color-hover: #b1bac41f; +} +html[data-theme='light'] .githubWigdget { + --gh-background-hard-color: #ffffff; + --gh-background-soft-color: #f6f8fa; + --gh-main-color: #4078c0; + --gh-border-color: #d0d7de; + + --gh-transparent-bg-color-hover: #d0d7de33; +} + +.githubWigdget { + position: relative; + + background: var(--gh-background-soft-color); + border: 1px solid var(--gh-border-color); + border-radius: 20px; + width: calc(50% - 100px); + min-height: 250px; + + overflow: hidden; +} + +.githubWigdget .header { + background: var(--gh-background-hard-color); + height: 60px; + border-bottom: max(1px, 0.0625rem) solid var(--gh-border-color); +} + +.githubWigdget .header .githubLogo { + display: block; + position: absolute; + height: 40px; + width: 40px; + margin: 10px; + background: url('/img/others/github-logo.png'); + background-size: 80%; + background-repeat: no-repeat; + background-position: center; +} +html[data-theme='dark'] .githubWigdget .header .githubLogo { + filter: invert(100%); +} + +.githubWigdget .header .breadcrumb { + position: absolute; + + left: 60px; + top: 16px; + + color: white; + display: flex; + + p { + color: #848d97; + } + + a { + padding: 2px 10px 2px 10px; + text-decoration: none; + color: var(--ifm-font-color-base); + height: 30px; + } + a:hover { + background: var(--gh-transparent-bg-color-hover); + border-radius: 5px; + } + a:last-child { + font-weight: bold; + } +} + +.githubWigdget .header .discussionsTitle { + position: absolute; + top: 15px; + right: 15px; + + display: flex; + align-items: center; + + svg { + margin-right: 5px; + margin-top: 2px; + } +} +html[data-theme='dark'] .githubWigdget .header .discussionsTitle svg { + filter: invert(100%); +} + +.githubWigdget .content { + position: relative; + margin: 5px 15px 50px 15px; + p { + margin: 0; + } + + .list { + border-left: 1px solid rgba(0,0,0, 0.5); + padding-left: 20px; + } +} + +.githubWigdget .joinButton { + position: absolute; + padding: 5px 20px; + + color: white; + font-weight: bold; + text-decoration: none; + + background: #238636; + border-radius: 6px; + + left: 10px; + bottom: 10px; +} +.githubWigdget .joinButton:hover { + background: #29903b; +} +.githubWigdget .joinButton:active { + background: #2e9a40; +} + +@media screen and (max-width: 1120px) +{ + .wigdgetsContainer { + flex-direction: column; + } + + .discordWigdget { + width: calc(80%); + margin: 20px 10%; + } + + .githubWigdget { + width: calc(80%); + margin: 20px 10%; + } + +} + +@media screen and (max-width: 470px) +{ + .wigdgetsContainer { + margin: 0; + } + + + .discordWigdget { + width: 100%; + margin: 20px 0; + border-left: none; + border-right: none; + border-radius: 0; + } + + .githubWigdget { + width: 100%; + margin: 20px 0; + border-left: none; + border-right: none; + border-radius: 0; + } + +} \ No newline at end of file diff --git a/website/src/components/mainPage/JoinConversation/joinConversation.tsx b/website/src/components/mainPage/JoinConversation/joinConversation.tsx new file mode 100644 index 0000000000..a9c52384b1 --- /dev/null +++ b/website/src/components/mainPage/JoinConversation/joinConversation.tsx @@ -0,0 +1,80 @@ +import React from "react"; +import styles from "./joinConversation.module.scss"; +import Link from '@docusaurus/Link'; + +export default function JoinTheConversation(): JSX.Element { + + return ( +
+ +

Joint the conversation!

+

Talk to us on Discord or GitHub

+ +
+ +
+ +
+ +
+ +
+ +
+ +

Active and fun community;

+

Quick answers and help channel;

+

News and announcements

+ +
+ + + Join Now! + + +
+ +
+ +
+ + + +
+ dotnet +

/

+ Silk.NET +
+ +
+ + Discussions +
+ +
+ +
+

Contribute with:

+
+

💡 ideas;

+

⏫ suggestions;

+

🐞 bug reports;

+
+

+ And the future of Silk.NET directly with the + .NET team! +

+
+ + New Discussion + +
+ +
+
+ ); + +} \ No newline at end of file diff --git a/website/src/components/mainPage/LightBalls/LightBalls.module.scss b/website/src/components/mainPage/LightBalls/LightBalls.module.scss new file mode 100644 index 0000000000..24b2b7ad9c --- /dev/null +++ b/website/src/components/mainPage/LightBalls/LightBalls.module.scss @@ -0,0 +1,30 @@ +#container { + height: 100%; + width: 100%; + overflow: hidden; + z-index: -1; +} + +.lightBall { + position: absolute; + background-color: white; + border-radius: 100%; + filter: blur(5px); + animation: lightBallMovement infinite; +} + +html[data-theme='light'] .lightBall { + background-color: black; +} + +@keyframes lightBallMovement { + 0% { + transform: translateY(0px); + } + 50% { + transform: translateY(30px); + } + 100% { + transform: translateY(0px); + } +} \ No newline at end of file diff --git a/website/src/components/mainPage/LightBalls/LightBalls.tsx b/website/src/components/mainPage/LightBalls/LightBalls.tsx new file mode 100644 index 0000000000..b0a4229368 --- /dev/null +++ b/website/src/components/mainPage/LightBalls/LightBalls.tsx @@ -0,0 +1,53 @@ +import React, { useEffect, useState } from 'react'; +import styles from './LightBalls.module.scss'; + + +type LightBall = { + posX : number; + posY : number; + size : number; +} + +let Lightballs : LightBall[] = []; +function LightBallElement({posX, posY, size} : LightBall) +{ + return ( +
+
+ ); +} + +export default function BackgroundLighBalls(): JSX.Element +{ + + Lightballs = []; + for (let i = 0; i < 10; i++) { + Lightballs.push( + { + posX : Math.random(), + posY : Math.random(), + size : Math.random() + } + ) + } + + return ( + +
+ {Lightballs.map((props, idx) => ( + + ))} +
+ + ); + +} \ No newline at end of file diff --git a/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.module.scss b/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.module.scss new file mode 100644 index 0000000000..c5dd94f980 --- /dev/null +++ b/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.module.scss @@ -0,0 +1,138 @@ + +.title { + + font-size: xx-large; + text-align: center; + +} + +.majorContainer { + width: 100%; + height: 70vh; + margin-top: 100px; +} + +.center { + position: relative; + margin: 0 30%; + top: 10%; + width: 40%; + text-align: center; + +} + +.apiItem { + height: 100px; + width: 100px; + + background-size: contain; + background-position: center; + background-repeat: no-repeat; + + margin: 20px; +} + +.staticApiItensElement { + display: none; + + flex-wrap: wrap; + justify-content: center; +} + +.movingApiItensElement .apiItem { + position: absolute; + left: calc(50% - 50px); + transform: translateX(calc(50vw - 150px)) rotateY(0.5deg); + + animation: ApiItemOrbit 10s infinite linear; +} + +@media screen and (max-width: 1000px) { + .movingApiItensElement { + display: none; + } + .staticApiItensElement { + display: flex; + } + + .majorContainer { + height: auto; + min-height: 70vh; + } + + .center { + top: 0; + margin: 0 10%; + width: 80%; + } +} + +@media screen and (max-width: 420px) +{ + .apiItem { + height: 50px; + width: 50px; + } +} + +@keyframes ApiItemOrbit { + 0% { + transform: + rotateX(0deg) + rotateY(0deg) + translateX(calc(35vw)) + rotateY(0deg); + z-index: 0; + } + + 25% { + transform: + rotateX(10deg) + rotateY(90deg) + translateX(calc(35vw)) + rotateY(-90deg); + z-index: 0; + } + + 50% { + transform: + rotateX(0deg) + rotateY(180deg) + translateX(calc(35vw)) + rotateY(-180deg); + z-index: -1; + } + + 55% { + opacity: 1; + z-index: -3; + } + 60% { + opacity: 0; + } + + 75% { + transform: + rotateX(15deg) + rotateY(270deg) + translateX(calc(35vw)) + rotateY(-270deg); + z-index: -3; + } + + 90% { + opacity: 0; + } + 95% { + opacity: 1; + } + + 100% { + transform: + rotateX(0deg) + rotateY(360deg) + translateX(calc(35vw)) + rotateY(-360deg); + z-index: -1; + } +} \ No newline at end of file diff --git a/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.tsx b/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.tsx new file mode 100644 index 0000000000..89f120cd8c --- /dev/null +++ b/website/src/components/mainPage/ReadyForAnything/ReadyForAnything.tsx @@ -0,0 +1,89 @@ +import React from "react"; +import styles from './ReadyForAnything.module.scss'; + + +type ApiItem = { + index : number; + image : string; +} + +export default function ReadyForAnything(): JSX.Element { + + return ( +
+

Ready for anything

+ +
+ +
+

+ Silk.NET provides a plethora of bindings to accommodate + just about any audio, video, graphics, asset management + and compute workload you could possibly throw at it. +

+
+ + + + +
+ +
+ ); + +} + +// components +let ApiItens : ApiItem[] = [ + { index : 0, image : "assimp.png" }, + { index : 1, image : "dx12ultimate.png" }, + { index : 2, image : "glfw.png" }, + { index : 3, image : "openal.png" }, + { index : 4, image : "opencl.svg" }, + { index : 5, image : "opengl.jpg" }, + { index : 6, image : "opengles.png" }, + { index : 7, image : "openxr.svg" }, + { index : 8, image : "sdl.png" }, + { index : 9, image : "vulkan.svg" }, +]; + +function MovingApiItensElement() : JSX.Element +{ + return ( +
+ + {ApiItens.map((props, idx) => ( + + ))} + +
+ ); +} + +function StaticApiItensElement() : JSX.Element +{ + + return ( +
+ + {ApiItens.map((props, idx) => ( + + ))} + +
+ ); + +} + +function ApiItemElement({image, index} : ApiItem) +{ + return ( +
+
+ ); +} + diff --git a/website/src/components/mainPage/ReliableDepend/ReliableDepend.module.scss b/website/src/components/mainPage/ReliableDepend/ReliableDepend.module.scss new file mode 100644 index 0000000000..9641b49b79 --- /dev/null +++ b/website/src/components/mainPage/ReliableDepend/ReliableDepend.module.scss @@ -0,0 +1,44 @@ +.title { + text-align: center; +} + +.container { + background:var(--ifm-hero-background-color); + min-height: 100vh; + padding: 50px 0; +} + +.item { + width: calc(100% - 300px); + margin: 30px 150px; + display: flex; + flex-direction: column; + align-items: center; +} + +.item p { + width: 100%; + text-align: justify; +} + +.item .icon { + display: block; + height: 50px; + width: 50px; + background: rgba(65, 215, 242, .3); + border-radius: 100%; +} + +.item .icon svg { + height: 50%; + width: 50%; + padding: 25%; +} + +@media screen and (max-width: 650px) +{ + .item { + width: calc(90%); + margin: 0 5%; + } +} \ No newline at end of file diff --git a/website/src/components/mainPage/ReliableDepend/ReliableDepend.tsx b/website/src/components/mainPage/ReliableDepend/ReliableDepend.tsx new file mode 100644 index 0000000000..742f4e235d --- /dev/null +++ b/website/src/components/mainPage/ReliableDepend/ReliableDepend.tsx @@ -0,0 +1,85 @@ +import React from "react"; +import styles from "./ReliableDepend.module.scss"; +import { FontAwesomeIcon } from "@fortawesome/react-fontawesome"; +import { faHeartCirclePlus, faLightbulb, faWrench } from "@fortawesome/free-solid-svg-icons"; + +export default function RealiableAndDependable(): JSX.Element { + + return ( +
+ +

Reliable & dependable

+ +
+ + + + + +

Strong backing

+ +

+ We're proud to be an official project under the benevolent .NET Foundation + umbrella - an independent, non-profit organization established to support + an innovative, commercially friendly, open-source ecosystem around the .NET + platform with corporate sponsorship from Microsoft, Amazon AWS, and many + others. +

+ +

+ This means you can count on us not disappearing tomorrow, and continuing to + reamin under steady development; a guarantee that similar libraries just + can't provide. +

+ +
+ +
+ + + + + +

Continuously improving

+ +

+ We're quick to develop and release new major versions for keeping up with + changes and new trends in the ecosystem. In addition, we're keen to create + infrastructure to make minor incremental improvments easy to implement. +

+ +

+ We're happy to look at any idea the community has for us, large or small, + so feel free to chat to us if you think there's a way we can improve! +

+ +
+ +
+ + + + + +

Free & open-source

+ +

+ Silk.NET is licensed under the very permissive MIT/X11 license, which means + that you can use Silk.NET in your commercial, non-commercial, hobby, or just + about any other kind of project. +

+ +

+ We offer no commercial support, which means that everyone has equal access to + the best support the Silk.NET team can provide. And last but not least, we + have a thriving, friendly, and approachable community who, if we're unable to + for whatever reason, are happy to guide you in using our library. +

+ +
+ + +
+ ); + +} \ No newline at end of file diff --git a/website/src/components/mainPage/SilkFeatures/SilkFeatures.module.scss b/website/src/components/mainPage/SilkFeatures/SilkFeatures.module.scss new file mode 100644 index 0000000000..9894a16c10 --- /dev/null +++ b/website/src/components/mainPage/SilkFeatures/SilkFeatures.module.scss @@ -0,0 +1,69 @@ +.featuresContainer { + display: flex; + align-items: center; + padding: 2rem 0; + width: 100%; + min-height: 100vh; +} + +.featuresList { + display: flex; + justify-content: space-between; +} + +.featureCard { + display: flex; + justify-content: flex-start; + flex-direction: column; + align-items: center; + + background-color: #434C5E; + width: calc(100% / 3 - 20px); + padding: 15px; + border-radius: 10px; + + box-shadow: 0 5px 5px rgba(0,0,0, 0.25); + transition: scale 0.25s; +} + +html[data-theme='light'] .featureCard { + background-color: hsl(0, 0%, 98%); +} + +.featureCard:hover { + scale: 1.15; + transition: scale 0.5s; +} + +.featureCard p { + text-align: center; +} + +.featureIcon { + height: 50px; + width: 50px; + margin: 10px; + + +} + +@media screen and (max-width: 930px) { + .featuresList { + flex-direction: column; + } + .featureCard { + width: 100%; + border-radius: 0; + box-shadow: none; + } + .featureCard:hover { + scale: 1; + } + + .featuresList :first-child { + border-radius: 20px 20px 0 0; + } + .featuresList :last-child { + border-radius: 0 0 20px 20px; + } +} diff --git a/website/src/components/mainPage/SilkFeatures/SilkFeatures.tsx b/website/src/components/mainPage/SilkFeatures/SilkFeatures.tsx new file mode 100644 index 0000000000..a2ffe57ce5 --- /dev/null +++ b/website/src/components/mainPage/SilkFeatures/SilkFeatures.tsx @@ -0,0 +1,89 @@ +import React from 'react'; +import clsx from 'clsx'; +import styles from './SilkFeatures.module.scss'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { faUpLong } from '@fortawesome/free-solid-svg-icons/faUpLong'; +import { faRocket } from '@fortawesome/free-solid-svg-icons/faRocket'; +import { faAtom } from '@fortawesome/free-solid-svg-icons/faAtom'; +import { IconDefinition } from '@fortawesome/fontawesome-svg-core'; + +type FeatureItem = { + color: string; + title: string; + icon: IconDefinition; + description: JSX.Element; +}; + +const FeatureList: FeatureItem[] = [ + { + color: '#C624FF', + title: 'UP-TO-DATE', + icon: faUpLong, + description: ( + <> + With an efficient bindings regeneration mechanism, we are committed to + ensuring our bindings reflect the latest specifications with monthly + updates generated straight from the upstream sources. + + ), + }, + { + color: '#4AFF5C', + title: 'HIGH-LEVEL UTILITIES', + icon: faAtom, + description: ( + <> + In addition to providing high-speed, direct, and transparent bindings, + we provide high-level utilities and wrappers to maximise productivity + in common workloads such as platform-agnostic abstractions around Windowing + and Input, bringing your apps to a vast number of platforms without changing + a single line! + + ), + }, + { + color: '#E86100', + title: 'GOOD-TO-GO', + icon: faRocket, + description: ( + <> + Silk.NET caters for anything you could need in swift development of multimedia, + graphics, compute applications. Silk.NET is an all-in-one solution, complete + with Graphics, Compute, Audio, Input, and Windowing. + + ), + }, +]; + +function Feature({color, title, icon, description}: FeatureItem) { + return ( +
+ + + + + + +

{title}

+

{description}

+ +
+ ); +} + +export default function SilkFeatures(): JSX.Element { + return ( +
+ +
+
+ {FeatureList.map((props, idx) => ( + + ))} +
+
+ +
+ ); +} diff --git a/website/src/components/mainPage/TryStride/TryStride.module.scss b/website/src/components/mainPage/TryStride/TryStride.module.scss new file mode 100644 index 0000000000..dfdeed4d13 --- /dev/null +++ b/website/src/components/mainPage/TryStride/TryStride.module.scss @@ -0,0 +1,87 @@ +/* #434C5E */ +/* hsl(0, 0%, 98%) */ + +html[data-theme='dark'] .container { + background: #434C5E; +} +html[data-theme='light'] .container { + background: hsl(0, 0%, 98%); +} +.container { + padding: 30px 20px; + + height: 50vh; + width: calc(100% - 100px); + margin: 50px; + box-shadow: 0px 5px 10px rgba(0,0,0, 0.5); + + display: flex; +} + +.container .left { + width: 60%; +} + +.container h1 { + color: var(--ifm-color-danger); + font-weight: normal; +} + +.container p { + text-align: justify; + font-size: 18px; + font-weight: lighter; +} + +.container .right { + width: 40%; + display: flex; + flex-direction: column; + align-items: center; + justify-content: space-evenly; +} +.container .right .strideLogo { + width: 80%; +} + +.container .right .learnMore { + background-color: white; + padding: 10px 20px; + margin: 20px 10px; + color: black; + border-radius: 10px; +} + +html[data-theme='light'] .container .right .learnMore { + background-color: black; + color: white; +} + +html[data-theme='dark'] .container .right .strideLogo { + filter: invert(100%); +} + +@media screen and (max-width: 760px) +{ + .container { + height: auto; + flex-direction: column; + align-items: center; + + .left { + width: 80%; + } + + .right { + width: 80%; + } + } +} + +@media screen and (max-width: 510px) +{ + .container { + width: calc(100% - 20px); + margin: 50px 10px; + } +} \ No newline at end of file diff --git a/website/src/components/mainPage/TryStride/TryStride.tsx b/website/src/components/mainPage/TryStride/TryStride.tsx new file mode 100644 index 0000000000..657cb5ebe4 --- /dev/null +++ b/website/src/components/mainPage/TryStride/TryStride.tsx @@ -0,0 +1,37 @@ +import React from "react"; +import styles from "./TryStride.module.scss"; +import Link from "@docusaurus/Link"; + +export default function TryStride(): JSX.Element { + + return ( +
+ +
+ +
+ +

Not your cup of tea? Try Stride

+

+ Silk.NET is low-level and empowers the developer with complete control + over rendering. Because of this, we understand Silk.NET isn't for everyone. + If you fancy something more high-level, give Stride a shot! Stride is a 2D + & 3D game engine supported by the .NET Foundation. +

+ +
+ +
+ + + + LEARN MORE + +
+ +
+ +
+ ); + +} \ No newline at end of file diff --git a/website/src/css/custom.css b/website/src/css/custom.css new file mode 100644 index 0000000000..951bc2ef21 --- /dev/null +++ b/website/src/css/custom.css @@ -0,0 +1,29 @@ +/** + * Any CSS included here will be global. The classic template + * bundles Infima by default. Infima is a CSS framework designed to + * work well for content-centric websites. + */ + +/* You can override the default Infima variables here. */ +:root { + --ifm-color-primary: #25c2a0; + --ifm-color-primary-dark: rgb(33, 175, 144); + --ifm-color-primary-darker: rgb(31, 165, 136); + --ifm-color-primary-darkest: rgb(26, 136, 112); + --ifm-color-primary-light: rgb(70, 203, 174); + --ifm-color-primary-lighter: rgb(102, 212, 189); + --ifm-color-primary-lightest: rgb(146, 224, 208); + --ifm-code-font-size: 95%; +} + + +.docusaurus-highlight-code-line { + background-color: rgba(0, 0, 0, 0.1); + display: block; + margin: 0 calc(-1 * var(--ifm-pre-padding)); + padding: 0 var(--ifm-pre-padding); +} + +html[data-theme='dark'] .docusaurus-highlight-code-line { + background-color: rgba(0, 0, 0, 0.3); +} diff --git a/website/src/pages/index.module.css b/website/src/pages/index.module.css new file mode 100644 index 0000000000..362592deaf --- /dev/null +++ b/website/src/pages/index.module.css @@ -0,0 +1,250 @@ +@import url('https://fonts.googleapis.com/css2?family=Open+Sans:ital,wght@0,300..800;1,300..800&display=swap'); +@import url('https://db.onlinewebfonts.com/c/00d5a78493aed4b11e2584ad7cceee49?family=Gilroy-ExtraBold'); + +html { + background-color: var(--ifm-background-color); +} + +html[data-theme='dark'] { + --ifm-background-color: #3B4252; + --ifm-hero-background-color: #2E3440; +} +html[data-theme='light'] { + --ifm-background-color: white; + --ifm-hero-background-color: whitesmoke; +} + +.heroBanner { + text-align: center; + position: relative; + overflow: hidden; + + height: calc(100vh - 110px); + padding-bottom: 84px; + margin-bottom: 50px; + + color: white; +} + +.container { + display: flex; + flex-direction: column; + align-items: center; + z-index: 0; +} + +html[data-theme='light'] .heroBanner { + color: black; +} + +@media screen and (max-width: 966px) { + .heroBanner { + padding: 2rem; + } +} + +.wordmark { + width: 300px; + margin: 20px; + user-select: none; +} +.wordmark.thin { + width: 20%; +} +html[data-theme='dark'] .wordmarkLight, +html[data-theme='light'] .wordmarkDark { + display: none; +} + +.wordmarkLabel { + font-family: "Gilroy-ExtraBold"; + letter-spacing: 0.4em; +} +html[data-theme='dark'] .wordmarkLabel { + color: white; +} +html[data-theme='light'] .wordmarkLabel { + color: #5820d3; +} + +.buttonsHolder { + display: flex; + align-items: center; + justify-content: space-between; + width : 50%; +} + +.button { + background-color: white; + color: black; + padding: 10px 20px; + font-size: large; + font-weight: 500; + display: flex; + align-items: center; + justify-content: center; + border-radius: 5px; + user-select: none; + box-shadow: 0 5px 10px rgba(0,0,0,0.5); +} + +.button:hover { + text-decoration: none; + color: black; + scale: 1.05; +} +.button:active { + scale: 0.95; + filter: brightness(75%); + transition: scale 0.2s; +} + +.buttonIcons { + height: 30px; + width: 30px; + margin: 0 10px; + position: relative; +} + +@media screen and (max-width: 770px) { + .buttons { + flex-direction: column; + height: 120px; + } +} + +.container p { + color: inherit; +} + +.subtitle { + font-weight: bold; + max-width: 500px; + font-size: 30px; + margin-bottom: 40px; +} +@media screen and (max-width: 600px) { + .subtitle { + font-weight: bold; + max-width: 500px; + font-size: 20px; + } +} + +.description { + font-weight: lighter; + font-size: 20px; +} + +.dotNetLogo { + width: 100%; + height: 80px; + position: absolute; + overflow: hidden; + + bottom: 0; +} + +.dotNetLogo .angledBar { + width: 120%; + height: 90px; + + z-index: 0; + + background-color: var(--ifm-background-color); + transform: rotate(-1deg); + + top: 10px; + + position: absolute; +} + +.dotNetLogo .content { + position: absolute; + font-family: 'Open Sans', sans-serif; + z-index: 1; + display: flex; + align-items: center; + justify-content: center; + width: 100%; + bottom: -1px; +} +.dotNetLogo .content p { + font-size: 13px; +} +.dotNetLogo .content img { + position: relative; + height: 50px; + top: -11px; + margin-left: 5px; +} +html[data-theme='light'] .dotNetLogo .content img { + filter: invert(); +} + +@media screen and (max-width: 940px) +{ + .buttonsHolder { + flex-direction: column; + height: 120px; + } + + .button { + width: calc(200px + 20%); + } +} + +@media screen and (min-width: 600px) +{ + .wordmark.wide { + display: block; + } + .wordmark.thin { + display: none; + } + .wordmarkLabel { + display: none; + } +} +@media screen and (max-width: 600px) +{ + .wordmark.wide { + display: none; + } + .wordmark.thin { + display: block; + } + .wordmarkLabel { + display: block; + } +} + +@media screen and (max-height: 700px) and (max-width: 700px) +{ + .subtitles, + .description, + .dynamicText + { + display: none; + } +} + + +/* Animation */ +.fadeEnter { + opacity: 0; + position: relative; + height: 0; + margin: 0; +} +.fadeEnterDone { + opacity: 1; + transition: opacity 500ms ease-in; +} +.fadeExit { + opacity: 1; +} +.fadeExitActive { + opacity: 0; + transition: opacity 500ms ease-out; +} \ No newline at end of file diff --git a/website/src/pages/index.tsx b/website/src/pages/index.tsx new file mode 100644 index 0000000000..e5ba568f09 --- /dev/null +++ b/website/src/pages/index.tsx @@ -0,0 +1,156 @@ +import React, { useEffect, useState } from 'react'; +import { CSSTransition } from 'react-transition-group'; +import clsx from 'clsx'; +import Layout from '@theme/Layout'; +import Link from '@docusaurus/Link'; +import useDocusaurusContext from '@docusaurus/useDocusaurusContext'; +import styles from './index.module.css'; +import SilkFeatures from '../components/mainPage/SilkFeatures/SilkFeatures'; +import BackgroundLighBalls from '../components/mainPage/LightBalls/LightBalls'; +import { FontAwesomeIcon } from '@fortawesome/react-fontawesome'; +import { faCode } from '@fortawesome/free-solid-svg-icons/faCode'; +import { faGithubAlt } from '@fortawesome/free-brands-svg-icons/faGithubAlt'; +import ReadyForAnything from '../components/mainPage/ReadyForAnything/ReadyForAnything'; +import AllInOneSolution from '../components/mainPage/AllInOneSolution/AllinOneSolution'; +import RealiableAndDependable from '../components/mainPage/ReliableDepend/ReliableDepend'; +import JoinTheConversation from '../components/mainPage/JoinConversation/joinConversation'; +import TryStride from '../components/mainPage/TryStride/TryStride'; + + +export default function Home(): JSX.Element { + const {siteConfig} = useDocusaurusContext(); + return ( + + + + + + + +
+ + + + + + + + +
+ + + + ); +} + +/* Components */ + +function HomepageHeader() { + + const {siteConfig} = useDocusaurusContext(); + return ( + +
+ +
+ + + + {/* just one of these will appear in the page, for each theme and device width */} + + + + + + +

SILK.NET

+ +

+ {siteConfig.tagline} +

+ +

+ Spruce up your applications and games with cross-platform 2D & 3D graphics, + audio, compute and haptics. +

+ + + +
+ + + START NOW + + + + + + COLABORATE + + +
+ +
+ +
+ + ); + +} +function DynamicText() { + + const options = ["FAST", "FREE", "CROSS PLATAFORM"]; + const [index, setIndex] = useState(0); + + useEffect(() => { + + const updateText = () => { setIndex( oldIndex => (oldIndex + 1) % options.length ); }; + + const interval = setInterval(updateText, 3000); + return () => clearInterval(interval); + + }, []); + + return ( +
+ {options.map((textOption : string, i : number) => ( + +

{textOption}

+ + ))} +
+ ); + +} +function MicrosoftLogo() { + return ( +
+ +
+ +
+

SUPPORTED BY

+ +
+ +
+ ); +} \ No newline at end of file diff --git a/website/static/.nojekyll b/website/static/.nojekyll new file mode 100644 index 0000000000..e69de29bb2 diff --git a/website/static/img/apis/assimp.png b/website/static/img/apis/assimp.png new file mode 100644 index 0000000000000000000000000000000000000000..ca5dc23962257b766f6071553a10d736977bd7d5 GIT binary patch literal 45487 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≦zeSIU2v&Fn_b+`$m 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 Hu0mjf^#=rC literal 0 HcmV?d00001 diff --git a/website/static/img/apis/dx12ultimate.png b/website/static/img/apis/dx12ultimate.png new file mode 100644 index 0000000000000000000000000000000000000000..9865091f5cb05e46843fb58b26a3f8426090aa94 GIT binary patch literal 88197 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 bZNvWud#?H+H3Rh000000NkvXXu0mjf))T;5 literal 0 HcmV?d00001 diff --git a/website/static/img/apis/openal.png b/website/static/img/apis/openal.png new file mode 100644 index 0000000000000000000000000000000000000000..f9fcab1ea2506d1242317a9569b0d43d5e6c5f07 GIT binary patch literal 13852 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 Sw0S5mfUKm_rz&xip#K4otx-n+ literal 0 HcmV?d00001 diff --git a/website/static/img/apis/opencl.svg b/website/static/img/apis/opencl.svg new file mode 100644 index 0000000000..bd9079cc7b --- /dev/null +++ b/website/static/img/apis/opencl.svg @@ -0,0 +1,64 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/website/static/img/apis/opengl.jpg b/website/static/img/apis/opengl.jpg new file mode 100644 index 0000000000000000000000000000000000000000..40d107980193128f4651eb672b9e3315a30875a9 GIT binary patch literal 7073 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 literal 0 HcmV?d00001 diff --git a/website/static/img/apis/openxr.svg b/website/static/img/apis/openxr.svg new file mode 100644 index 0000000000..f9443ac3b3 --- /dev/null +++ b/website/static/img/apis/openxr.svg @@ -0,0 +1,63 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/website/static/img/apis/sdl.png b/website/static/img/apis/sdl.png new file mode 100644 index 0000000000000000000000000000000000000000..b5098197cee29d6907221d2039c43a1f51025a74 GIT binary patch literal 20932 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 literal 0 HcmV?d00001 diff --git a/website/static/img/apis/vulkan.svg b/website/static/img/apis/vulkan.svg new file mode 100644 index 0000000000..1ae75e6f35 --- /dev/null +++ b/website/static/img/apis/vulkan.svg @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + diff --git a/website/static/img/dotnetfoundation.png b/website/static/img/dotnetfoundation.png new file mode 100644 index 0000000000000000000000000000000000000000..fc2e18030c6cd55b8aae43009105dc59b6b686cd GIT binary patch literal 322453 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

aH*Z5HF?Ek$29D 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�!F3tm zLpAAru~s1nl5&}41>9V#DXa~y7vQ){cSg?Wfo;^hyj#QD^$;(Fzi#sz4Gkp}T%h_`Sh|)|z=b{pfJ^7nPv#(<|3V-bk0?dfgcXFO!u$^+qp$aRFG$Av8M__( z23)>p3AE{J>`Mo0yoBo!RDpU-xx<&xK$saUz{eCg^;{GgzkhgRRCG_v`Oh03nsW+1 zcS?e7p@$z+6Jnw#01WHZI^E&?H;ArI%TJD0=X@6Xy8YZQCpWE<2-ka6O=B|wY;dFv z8mH7{zIn8e6x9LFSRSli_jqr*d%9D{v~`TMsNoKr{<(e^w?l46KjT*8PGve$H}L_`)D;OW**d+N+4`oM`J+J8~uq5Jq0|x z4cW80isv4qn(rhDT)&M9-(?B$gc(_ucs%1L&qXIxi>%{x^(Z~dJ(s+P8^t^&x*kIl z$5jq1jXGS8alok7l)my2%ab^qH4p!kL4(~a)sSt4Ay(m7uv0e(Klb;?8O>8L8!UW_ zhJty@6|W>1&*EAu4QYt5%N^T3TQ~Xj-$v_*kjro)EkzNMdv9Pdq@x9G8KW0Xi3NLayHar z)Hp#-@Dq^zm@m=nJ4yzZHXlH(Xyw5oLKP=hb?BJ_tS_#<#F3P{8}0;9TH=VSG`xiESp2_#e%k* z04`jdHZzhRfIDfkfHf;x_Wi1DvTbMDvd;?`thf!Dt#K~;1;JJcJuS+6mR7DccB6OmzI<-YooWKx=maR<9&NByH%01Y@r~M&Kqd zxQ@YKT_n`>@q26^?o#k zGM2}a#%8FC)?VjB;P5I%bDJT+LjAgf!$>kDrXbZ(;}>v zfIrLT!$&Wl0qt351?4dL3n|I?r$!_hg|vb4&yTm`g>?K#p!COoQ7F0 z&)iX;b<(dtN&$qvXlQ`-rTss5jWUBPS_Coh!DGK7MTF{t^tUYK5c1>vd-2)*Y1>`u&)6w$tTfaJ+UNGmUqaIYW? zh=)=V7E|r6@lk2)d$GZm+t9hH{S`0HFx@e9P0#_-4|nYD602rCaqAZ9aTA~@XF1o3 z(x67&i#;td#s!16%g-sUW{(r2JAPaXsHC@!ztYEKB^|?{9dz8;932VC7_mn77ZAHbt%7 zC4&vN2N-tN@gjbodD0r20`+I58iz`ZdMEw7iAX_0Es8jkK}I+lqT>=2oW~A5++hTQ zJu#_aC+Kd`XECHwk)NCtaECPke0VNt;Ft%-wG%i$m<`?qbdUhAIN}sr4SKykN0_;o zBtvO0ynCvN=6jgvHyK2=6*r%2wglGYnj7B|&QwuDkDbpIdiKY(TIObj4SPkO5f9tt z9SOb`i791Tnzjghh5I)>El_#kP!iGFcX$CO=Fd}QDCHtpoZG5A?o1ZK&<8}|0xK4E z>n|2iC`|9wF{kNd$|L-jIVW@gs5XXvY!Tig@)paaX-s#RLa2o`=7dVzh>)`P^9}d) zPxtI8Pg>*DOLt8JOwr!+9wzg*Eaz%fFip`1IxpoTebX0j9Hn)wunBuHxt zY~%i=!zYp-r%b6lLMS8XNm&nd8WuDwaEuTT&Vu6AJj^$2JB_*+WfO831V^t$QtAn0 z29DrY;qu7y8!aN=0W|x5O=*x*9tf~BCx9<>zO|)l3?+{Mo=G-WmIdDp?i1?}AM%lz zWj*o-i8~PfC25UX09jp=Pf(sL?sTEI`~4PfO@t#OLIu*Dy=$4%o#2r|1rSq$U5`Y8 z-SxAI2ni}3Cs7$(B)d43kR2_h8v2x;Q}%ZqmvRVOrz75gVmhnKt!Q56JFYVZD(p&( z0gkFEAul+L9&JdpM#KdSkekDstD75*^Ho(eI2Q7lwP1}o*kcp$SD3c~C?znbFyE;B z-6qPw+1fQ4ml`oNfPKUFP-(TyTI(T~i@;NDxFA8-DfZMC7%J906KEj==}&uW<&MV+ z<|f3!97^khxz@GRYL>(jFdgH4U$A9}rBS{W|9T&~1z^YKQDvvn0k}rKe$&#%vxJ!M zRPN(t#IGQz(HQ#EwNR95c5sWhE`Drz7kp@kQU2hi!S5Vn2`cdbqU7P)UeuV`8#ou< zq)5z<*c|how6hp@zbksQAPDZmY}MF%>#Xw!HHtKzDzVQ9Iu5sG0hG7Cls9IMyDz`y zda_gQP@L9o;$WBU>Fw*?7f=boPeaUa@oF@Y)^cf`7EjGU6fBkNWOAw`Qtd{ zR^h^?^EDiEDNvv^4-|iVPj?>E!t6U6@O4)g<+xD`v0Ln(xFsL8QI>cOe`{HPy`t2< zvE+g8xCEHYAor;sV97(!Vy{&p_CC=5uAO3@|a() zV!o|wHd8K#O=?hqfFC~pdPp;)k!}pY#g4|yGlN~$lZ~s6>$gH#HeA$#hoQ!Pk=UU8 zz3vwyhF>_dt@(5@6GgTFGLi?mRT#Zd(0lbS)>I}J<+jG?HI!h*YQu#_%mi8!k(?g2 zcAsBiRABN6%zn+KnS#vJvqzN#H=0cYrN3*qjmifd6^Fb-l;lP9x^$>z zw)ahOXWut%@7XW;+&CY5@UBvCAG6J6Pk(fi0U_Ei20ULNm+&>)q%wD&v+m9??%oR6jV+)aUsmcax;bpU?LU%>J@(59AMQ%UB0}Xw3?Zu@L#*YTc&PJQYUdWcz z_<{{nm(DAuG9hp~bQwa*p+H3mBYvnf>Q17$GCA6=9&(6J^G8;sUDgO5MsH{lA& zZF0c|AqI8IH%bN56*;FzqW4zw--Wp_zVd{2qhtzc4gpV)}G zd2iih;peuBk{`n_n^5p8p`SC2sMN(&gl2RX7yhL(MlW%57iexFZ^JkX$cs1{*_DOG zL0E?~=YM#0TY_%g)0R(V{qI6$<%p{;C@|&nryw89D~yCr^iBSxwt4IeeisWmMN-S% zV_9M)Ue@{OV$58y6uPJJS<61&X};84YM=Ilz%Of4!9h!eLf-~)DT6m19%GLQG?T;e zZ|E+0+$S!lc&MhLnQR3~3)&GOnEsE;OE=5>L0{eo*SSYBdO0yIji$V~AE4$Z-#WdE zDewRQL}4Xhi;QwxhL*sFoED;-?JsP)3WRg_;}Lt^$i@UhbB9EhdQ^G~ISS$!TY$oJ zIWZp~Zq%^Bw6RV{Y6MCklpGSRe$Dpav%8bP2!i9Q%Iw;f0!7S16VAi3WBWc6eifP*bxEz#XL)i9iXR+0hBatda&>S+G_@ zfq07ZkMrWdcPP|(+4JVxvS<2Z@QD^WnIc(8SwPGuZ=2&|C5Nj^b2piUG}-MQCa>|} zX}($wkPnH~M^^_b$9P-{_y6K&nyDHk_(6(k)!CIEGmy$9yRA(dyG_Ggot>15*>&Zs zS$a-XUPo_T`BjmsULM`8O%^NMB$VsHcl|EvJ4$DBRDu@>B?1wiUchfTZmSluK+~L@ zt(vSICDPvf!LB;b?TGP#1(6as9c5yzZGo28z8XJm{bV%dfIVks=+M@6CkPs0{*|k! z9=rC?sg7?|BU-=c-@czqa#>+Pau-lt$|WIlRAIhqLagOVjaF}gb#jYk0Yy&L9Ne0K zbAe6*4hf$iTp8Ek>o?pU+dTqrW*OhO1!i0htdq3X`*(poFXMF!{y$a{7etZ zfs!!SmPef1pg>SF1blLe#xnKslDKqbP!FjL({-hJ=v|VZyN%JaGMx;yn$POR#k^J( zpX9^~CH*(Jd(~Taloz&m?Mcfwdlb91rI4e}1qjK?L0hQ(9^=n8MbAP=c@(G&v@PDy z7*gSRx9n9#=a1+daZ45VyL7af3)C_7W~nIKU(ld3;t-qA1(N!1%I^Q zj~4vVfV!Z literal 0 HcmV?d00001 diff --git a/website/static/img/favicon.ico b/website/static/img/favicon.ico new file mode 100644 index 0000000000000000000000000000000000000000..c01d54bcd39a5f853428f3cd5aa0f383d963c484 GIT binary patch literal 3626 zcmb`Je@s(X6vrR`EK3%b%orErlDW({vnABqA zcfaS{d+xbU5JKp0*;0YOg+;Fl!eT)XRuapIwFLL`=imZCSon$`se`_<%@MB=M~KG+ z=EW^FL`w|Bo>*ktlaS^(fut!95`iG5u=SZ8nfDHO#GaTlH1-XG^;vsjUb^gWTVz0+ z^=WR1wv9-2oeR=_;fL0H7rNWqAzGtO(D;`~cX(RcN0w2v24Y8)6t`cS^_ghs`_ho? z{0ka~1Dgo8TfAP$r*ua?>$_V+kZ!-(TvEJ7O2f;Y#tezt$&R4 zLI}=-y@Z!grf*h3>}DUL{km4R>ya_I5Ag#{h_&?+HpKS!;$x3LC#CqUQ8&nM?X))Q zXAy2?`YL4FbC5CgJu(M&Q|>1st8XXLZ|5MgwgjP$m_2Vt0(J z&Gu7bOlkbGzGm2sh?X`){7w69Y$1#@P@7DF{ZE=4%T0NDS)iH`tiPSKpDNW)zmtn( zw;4$f>k)4$LBc>eBAaTZeCM2(iD+sHlj!qd z2GjRJ>f_Qes(+mnzdA^NH?^NB(^o-%Gmg$c8MNMq&`vm@9Ut;*&$xSD)PKH{wBCEC z4P9%NQ;n2s59ffMn8*5)5AAg4-93gBXBDX`A7S& zH-|%S3Wd%T79fk-e&l`{!?lve8_epXhE{d3Hn$Cg!t=-4D(t$cK~7f&4s?t7wr3ZP z*!SRQ-+tr|e1|hbc__J`k3S!rMy<0PHy&R`v#aJv?`Y?2{avK5sQz%=Us()jcNuZV z*$>auD4cEw>;t`+m>h?f?%VFJZj8D|Y1e_SjxG%J4{-AkFtT2+ZZS5UScS~%;dp!V>)7zi`w(xwSd*FS;Lml=f6hn#jq)2is4nkp+aTrV?)F6N z>DY#SU0IZ;*?Hu%tSj4edd~kYNHMFvS&5}#3-M;mBCOCZL3&;2obdG?qZ>rD|zC|Lu|sny76pn2xl|6sk~Hs{X9{8iBW zwiwgQt+@hi`FYMEhX2 \ No newline at end of file diff --git a/website/static/img/others/discord-logo.svg b/website/static/img/others/discord-logo.svg new file mode 100644 index 0000000000..41b3b8b460 --- /dev/null +++ b/website/static/img/others/discord-logo.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/website/static/img/others/discord-star.png b/website/static/img/others/discord-star.png new file mode 100644 index 0000000000000000000000000000000000000000..07427b59c8d6da800a1631dccec47ce66e42f741 GIT binary patch literal 12337 zcmch8_dk_w{P=yWvK@OX%F2$&RtHbY-dkjcBji+OlH*v9Pbhn3%g9LfK0O*zWMm$X z$UX@t>wK=;^Z66LudiP^_jO;__1^m~-o!|sk&c%Rf*{5lf1%7EhywhifX>o@e|}>| z4BNGoNU#@@tD`E;(t| z;)mp~GURRj$s6D8xYdOH|NmFyri(hB$h!p&) z@9BjBUX;jG2#am4VNU-tL60wFE+csHCw9m&GitMaM{8{kGH-_@&L5^7Rt$Z{X0Re@ zqpV2R_$uPz=VDqwourM3I z?u5PR=*sL9x5lSJ^Rneay3*JA3^TERL8v?H&b*^#i%ApCzJIRDm>)f>yvi|-K&D=T z4}GLrH79be*Y2*TC|BiGPMX9WZoGs~p&aLoUnypFB`LcKz48@mH!c42J!>@ka3c-- zjzb$INV-(Vu1rwbSU7B95A{+^qYrpfe2Pdp^Eo$dDxY)BH^N(r(BKR<;vR>i%aGtoB#_l6GHvF*){qAgJk;F$uyWy zzO#zX*Jpz-DUV&{Kg!tKw@=#&~8R=1`NZAf_6CMT?69?YwoHpM%+wclcWIACPvsd6fJb|u^cGyc{Chh87) z|9lG0blRl)Mq#P6QRQvs-&O>DE$9_L7GYPE5`>F_zmkLsoC6s;3)OT1b*aQIe_k@> zdI|>+R&W)3=03T0B>bC;pe~HYuiugTHcyK~p22TMcaPcblS4CO(1N225i{q75iCfK zA%7L;{Z?)H=at#;0RolOScj3hz>Sd+Sb>R=db3saZ#F~ZK9y9i8GWTb)#|qJBW7wY zlON)Sj_2S@mZ+pSJm+a!Pt|&nj98au>X|eNu&a3nbH!D;8u_`KZKO)R@(~Q;^^sV{ z;@Mnr_+-e8f(3WCCdIr-PK5}(xyT|dev!P=Lv64DG$XhO8^)v}oSd(6!kkl*(MNR4 z{ZFs@-kaRs?I%XgqjM@6PVtr>B#$I0;q*eo`Qe*WiIF+4R4v5*Q{Ol2f`>oJ7>bOw zvoPDmsY8?<=0{MnGA3Cil(RJ0clN+mMU_s5m9!UGjx5@6@2G%%8iqgPBjZz51Xc~- zH%kY+k z;k{7SlYSO?p!H*cf^N}rAI9m4|U+L>81UVQHKGAO+MckLnItQ}hkwgAERrYM)M`)n@sROP=ze=S{K- z`rto0OicyiG+&*g`{q*PV+RxS>*t*1gmD%2Yv4<7cG#0pODmtGTt|PZ6)_BjwdKwq z;~K<|6-k)AKyR)l%Qc-MXlfsNBos%uTfTM>68E1lQIuTbP1eOz?#M|hZe&Ocvx(iK zBcbQgZngb$L57^%3{h)l;*MOge?D*&6AV!5a^Y%04y+{-rr+6|U*m7=onicd+} zp8W}%are(w16UmSCrMXZqU?Z^7dZ8ot)0v+9DC#b1PA_G@>frx__ZHuCBMw^H#;Sd zzNvAGr1ir!seUl|Kf6cn_8sTSpQP;kzQSy_e(FRMi@nIiNd6@E|9}{i@#@v}F3GK( zb0Vj_cZ{TwtX{_wBdhD&gCoa^PhEz<^)u4sc(>2BRsZRz7N-lNrNE}L&S~V<(yG4< zRO#{S+ISd`=(kRvqTl_>|D;?n8J1%Pd)CKx6^`3K z=TxHa(VhBs@mRCu0fk&C&f7{&-?fnZKreupTYZm&DAP1J9ATcD(tX&<0;cuk8S2SX ztP0cn;Ft-vDuB+Y}m_*Gc10W+}2^%Scgk5x_JcM)EbAOKML$~l|s!*WctzBO?yRL`Kl<^|K{R)32M zIzvz|SC$>qfiK_vVGe~1fFn=n%XbtLj93A`y!MJdm8p-QknhFy&4LrKPl54>Fb%#n znG1i(!~!!kUxkNyDRq#Hq~;P2Nj~2HLJQxO{li2sXg{+5XQhaxWQM?!CDOdh3GO6&f6z8i~Em@FfUe6ko?Al2VzPo>pH>1xotUvI(Ut3Fv& zDDQfUz_hAP$5C8D7YJ~T#L$2KEUs#a8hN~WpouHWs>*n~qN`J1?Bh3Ks#~bI-f~U) zzKwUmgwC^*hRSCL%f=_emGbeahZiF6C;dZS_SM;)cqmcZ$NP+pn2(X!T^7Ipm$%V< z^;jRg(#GF7Gx>k=%dFI@6-_tl{vq3n{n@#7GHhq5R*Gl#5i4&|M9*x7hUzCTdV8V_=U28h`pbQ#g8>U``#0l6zt|6 zy1>-Jc@}bcjgZSdb8zd()_#4NXMl4$g*?Da6bNJ18d(pwDXw6cnGHvnjOXhG<(U0g zyi?sHnS%|N*Ix$31^0mLwqF=ie!nt@y^@5lzN#9u+FGLcuslSzy5}pJX%EB?Vd2d_ zu0Tr7lF>sYzM&~b4};8w^y(cVs{O2|TizxI5?RmqW+8Vp<+d-+)C3QJwAlCtZMy>eX!m$fDzyv zTR8c~5T!b;KXUVdd|s@pHF$yQxxCG)8{jxMX9tsFPS>PPEvr{s!2&StAhC^|vveGv zQ$-XMs4`i*GMh^P0{6PpeQc{=uqH{g?&l|H;p0oMgM0W>y1J)Tr?uJ;CS6T@bVEK4 zcU1vK{kkebt7XP7I-u?2Mez{jc9$uAGPt|`Y-IVwM@ss2oKss7rwTKr$2D+CwZ*IM zt|{sy$JWEzCa&kM%9qarfcN`KR$lcTUlxMc4X$!hdH`>SVwhKHE2yVmi@43fB>xO- zBDhpPY3&Rs6@z}bq))==SIOy1UlxSUxW=D8-bA1CP=}IxbwFqb=q46>NI@WRgOYpv zPgkV+>p_lOss$-ZN~-tV#Q}X0`!GSJ?e~R0Cgx))cvP_o%28!Qn9wE7I<0$OfvL;m zO>%PAvqEsK^n^9Q%=uydQ2q)f!lcjyH^~l=NXk5sO?GQL{r!C;Clm52FdeM>=k)rx zG*#8h!;m7qPsy~~>2<>rAs(|7G#2vs!4GeXL$gLgHM> zP#F8192*QYdo;x?J>klyFbJaF^~A^y8kParUW5+C&7$6QDs7&rC<>u&zfyC+>glI^ zpfDC_;DQPsKO#Py4p0S){l^%}P0Q|es_y==?j<%7pT((eNuF3$2w7JusJL2ln7?G& z2bwPw@zo+8Tpl^lfDYi{mFM6sHSq53XkiF_K?jfyJmd8Eky7?&puRL)+9f0=C+yZF zuu>#Z;|RH{rkIwn>D2*6DKsLfKa#tHhyrRNFi&EZy-BQTh2IO6D50Tw8byZ+ocsIeV#%st}$l$Px<6lM_|Oo{Y_TCvhx)%_{$04ye-D1i!CMu zh6mkM`pGcZ&;>?}>=lW$9;8AB|+gHQw~QEd4GOC$v!K*J1<$1K23uedjY z#CCLEuC6#ea>Oy7_>$MlXMp4agm7ZKjo6Ps@A|Vh3qE zM)HO*B#CSrs58w;*Z@|G1S{^Rx>9rzUDd`2k;oxtRRrEub~x$r@Uu*{Ef0 zD+7vBZBJ}fTPnQRLe~}RlncmpWq3o7blgPG2B~)PWc23 zDUjJoH#~!|HYk*{+b4vxk|T!naI|oG7JF#{dO6-K+&en#A3qGen?m&Y7}{(_)vdtl5gYS~=H~u5x270gEMFsp*yG&P8vFLHD-}3PxT| zs&GDclm6kY0j~XC$27hw5z6Z;>8pH=!sU4>V$2^S>V)fSN(S`i&+lToTz8%boX|!& zhC9}oWR)%0<)jEUhyjB5^9Pr*lD?-`R?k4RQ4%Q-$6k-nLP~u~CKu3(o9zNy7OUYt z*LkME+n;9RyTyCr?u<2qKRt|qbgctRz8tZ;w=?*U`qMS~QKjMTsW?6LbW#2aUw!!m zS=(o9F*Jqz3;NIq!m0wZZ{XErrCq@0&Hg4E{TZvLSA0Af{c0HeUQYb@C^GKG(#Nf& z1YYaOC+gG+zI7U*i;JWHDtA`a!LVY^O#O^(-^_hO0C@((lUF<%@F!tRw38ra4M{hs z|0OXRgl7DdeP;#mQjz$;LFbQf(~{L64+=TrBMQYV4(INR7!kobH*mjTcQ%@Km;MEs z0b~HVT=MS^@%fWF z*rI?ra{*FaoP_ANgWD=q@Qu`FY`n-Ke!SlZ4k~(6L@Jbqzc4R{3~vY ztgTEmNeohzrl7mqe;IvobIcEbb8?9HG*SK{N8EmXDJr>xRh+jH;SjSV4ste>MHr8@ zxMqw85C4cRD`XPj@M(Hu^xj#SzJ~fXBjALxw>8_HDnfa3iyeM(%v7EQDc=W6N9-kZ zyAdlAIoCIa%dYQWNQN#ztcdW$qBl~5=`AclO$}J=L~?du(wCze57Te{?CkP^>2ht0 zlPwH!Uiv_Vxn`sGC9f>KIic!iig4u~%50&b^zu4`M2_@(qN#V^mp?mv=uB~Ln0gfV zTFB`M7a`CNAPY>gsFQJDQg`!^4Ql(<>XNd0qlG5i&J=~Z+n%lel|wuw87NNlxnVd+Z8%d64L+wN}DO2_6GUDAQhqJ7a!xSzmEIh^}BNTH*NN1n=nHQhR-pd-YdTsjbk&XK^bVOpF0 zI-p*=6cLhamX}zC{vSBR&-IRt+RII4-3(`iYy}maywlu>k`7NE+}8sX_8DTD>WOL} zH!NkQ3zXcMwP#sh96A_uunpt$7sNy_0nhSSt8XW;%$(V;xKE2M>K3Izp{;SBl1+?Y zim0&gAW_1h(A3}B_wdy(LkK0H$!Ivi7n!Ivs40rWp55$I+cugm(|LC1J>eOSi2IgwqA#QcaP=X`6X8H;ud1-E@*569zBm?3+q$)m#f<_+lIM-&?6hXmv8YwDkB;;|%- z+1NLg5rv@+4~E7YOaFrYMf3;`Jwq!UY~*0ENiB~L0u$d1j~@yn{$A42pI^eLa!$!3 zk@jc}rx>!&e=oed!yK+X;7I5-$SbmAiKQ2cG#`-t!WBhSQwL;y3K57^cg6Ff?V-i=d_6Xd#!^z|8k8l6B+bTtSJWg$DRdp z7=4izCfK*o3H5j>Cm)F*{$_lvp`nLgkFCl9#V_Fh3~|a5H60f^FF-0W)UwPANjWPnid$!h5~1=^_8FqnZrd*J$F$ElruCa-y#r zI)UO|s&4^2@h5*>F9*ng#`|w}?r#1Kap4~>-K1oH>O?@t0A@yL*~=3d*qrye>jrQr z{jB`2a&`MhRL0!m!F$JX;|jT`*eP3-RKH|-A80MX9hQpY>f*mr~-loAvKT+G6Vkj z5|b)_PT=qR!qaFNTsn<7kvsAQ$w5I~HDFbI^vA4V)kP#f6V_E7D%`S*?m9>si}=nt?62RhyimY*fF5iqSsc zA8f4+5WTf<8*QkP5xa zRid%g3thTzDa@DQ%+P`kvrs7OJJgq=B*8I2r z2sw%X3z;VC_Al1odJaUXdD7rcMI&deoPd4HZNeFRV$}`w;I)Lqf*CC+C?-r1gN9xp6RBfg_l^@)u(N`>yGAv-cqGWkm? zxWSX44JKOr*oNR_01!;|MiRz=OTdbAo7@a2y9=wOg+&}87-W@%;1a>oVqksmBaQG2 zpsm@z045p-nj2C8_J|ZU<;w0mVd01McBZ36xxg?CN=DQn&qsHWNY4tU&z%6+?$c+c zCij2u=3%kLXvxtv$ zvSbTv7vKVYe=#p#;Dy&BFV&U7&tg_4P0MBle?k4%sudrA7JxW?QweyIw{iU?ESxdV zy&(dy8{ehOi8(fOLiI@;QW&Aji30-d~<(ttq+ z+f;2b!UWotaRP`<8<8OlG;+f=3D_5LmJb_$p9=ox%$emZRX`u_o0JTo?J7L@Oz?e_g(>Y}Rqg{37}p+G4k1yF?;^#>BDjAu6Kmz#4hb~ai zEhCh!(p6+oo!#(@*3RL(z{=8y$AQiN#AD6|;O&V8|HP|&#|)oT+5#tH^VkjaDYppw z6|z0<7^Y4)ye_|??KSy6z}Ap(A&%)I8kR+q6e<<*qqDae2$bBr6T+Op zFZ&$@7Oafr6>;J;>U-T1NY3rFkyV(#yd}Akqgp$KI^&irJ8{qF&!xx^)SK4h&wOYB zK06st3se=v=?c5q$8kgR*w^gmEhgZB- zcV(}OsO^N_Ws>Q)w7FY^HJ+E4P&hABW(el8`imAwsGHm0iou7pe1jhhtPrc>NzAUG zTI4`LIk@7FF95b}$M$HRa@B1^OSof*8RQ{xeu;o|@$Q zqC!IZU+Jj3gd!|-Liya6R9$IHqkk***Q2@LYujNg0fRK{yq-l^m#Bk%Zlw)jYbcQ0 zh^@!th(o66B-sqc;%;fl5 z`YUe^7tSlYz-5j}{CsAq9qy~pleclO9eoR2C`SR$Vu zgJq^~^PXS1ia}o+)>6~yO8MO@miq#t-!gCw}lpLM4mS5&igc^5E%hrE@PvZy#C9Fgc7DAL?~ zfN5gd?@=GR*ut;>lQU2)?}@Wfc!8cM6e!HOMkAjb*;5erXs&GXAWjQ(hSKud^&FbFq8We-p|6q_Z@^uep1caK^6f49Sh;hD(a0_YgJk+(xq)qj1G|W^M-7+W`qx z%ew<}ZrB6)rpDt1W_Ps6$1fIPIjT?gT@s8q%F2^14dcN^WAZqKZ14BrB2s`u+**bG z(C0y;ygMK9U$-Us3)u$pP3DY1=fkB;R}?Z8|KX}#7B8w9-K048H8qahZ_E&2xi;r^ zR;aJVh>g-GQ@;rw^KgtISH9jLSYsITj5-{Rug3|Vu+6c`oe81pid);hlzZWTLx17{ za0v(XY>13SmR#Y^r=A4KBal;Dl?InR_U%rwYjqJ_@L1rc>Z zow+G`%*!jZo^cER_tTWhkoIh@QqVig8dRFboo{EhZ))?J4^#Z@-(U_fplqP%q+e->) zDO4HszV0SWk@(z?nA%%ki8+H|WFPrO4qzIX#O{4(1D;j@hZyt5 z>=sJn{*GtNbKvfbd7F(3&5JY)UylB^yGPnu{}iRi^Y!lRW1SHl>X|1KXUJR#G^7Y1q79*l$)8^;A1aO&Tnnv99e!kTNNZ$nSt!>0xK@D z+x2+Pw-i|L2})MS_A=&~6(?xQ8Fa)ds1}DFzh!+9BeuAj!Muc_oxNjZ8R1#1&kBap z4O~Cmw5xEYVJtDcNw=Fm9WCTviZ(5&!JqT*zyC^-rhF%93X!U-9mt;HqZ_C^i|y*W zzSR5uV-^aG9LVA7T+Tf=1OK*SD>F;(eWOtdsQJ_%ZFj>W4Ds9xQ$;A0+VxIl5f6E$ zx3kg0ov%M;K+w)9SwfBAULXCNkB+wjt)WoRGq&;?NR4#Lr9MNrNTQVbB1xbmX(Vdg zQ_%;ODsD6`NjM}?j@=9l<>CEjVXnxTQ|h|Nb{B@{1ezO@Bn0#O6v2s27sGrozkl<9 z_*40EQ>}uDywu3=4z!7tn%MKzedUv!af`uVR0^^dNV~+8j^?xPl>rUR#k`n+OO}WH zC#E#YU(6TOFicL-k3N*H4EQwJrb)g&a}EOYgL&;CvB1}pEF9!$>xH0lfxzwMxvFcn z(bkJn><#BTW0gpAR3V}eqMVFopc`W4_q)>X(ay#tp;=|CHou*s(3o0D2x>XI)$P%6 zKDoETL~9!49*DLr9gyl%d)OU8!`7?L^EDu3IW(Gjg78)BjGrF1knPz)mt}I&*BN*# zOo5~nDtDL7@e~~ZW$gL)`ZeQsgO6e&{`8}R+VZ!8D4%YhPt3egf6Z^bL=h%Z1&Pm= z2$ZeqZrEmYwgr9Df(GEVVkozw0|?}Wd(&0)OCp}8jZsqM3h~~SE|=x%tc4JTshWR8Ctt79&` z+4r5ubmYT&Ci2dM&rWGtz4@*}=F?{uvPVqRNCt{40_ggT&I}VD{qMt+^YMJaRP$Do?is@5);eTyiS; zmgvr{wrcXmu8v_!Dp<&|YiP>mJO66M{;J%h7&0eH^52&1_uU@ad?X;p7A0QZ#3eRm zIns}>w<3lbkH@@(5lu_|c{qXO1 z`mwxnk3HvAkG|Ak`@|E1E2y;Bqr*3KjSrIeX<6)E0%WOMTd)o;+;gWc)AjVr%fs|Ce5!NL0} zqMh-crnTK2WO7UdU*rE^6-aAmsQ$zf4Akl8w!K{0nb*u{qcAMlx7hFEcezK)g{gHU0XrhcN~(~LTaT+j$sNn+gpPvSU7gSlj=7c1(aR?s_65< z3!S9qB8qKNbf&QztzRP->|3oV&e4s{kcu{gl$~(Pgh%dZH*573uJ|bDxbA(TgTvGO zpPJ62<)N1>Lk*z*X3-LhFn0UkINb1}Ye}bJy@W`&e;P}-XuH7k`8m^&xL2fdkBW!- zAtfL;FPn+R9bCLS`bV(WK2W~1pxhme;z~ei4{)JrPgt3MhKaN=4sC^*bKQhcx_>U# z;9EZJY8)YUOGtAHibW1BrcWGbO^#{_?xgTA>t$X%)(3f>>AGHB*TwE|46Y84%3Cx+I=kTFJv3!Q= zMuedDnno z{t`wn)8kh@HKz~me(ME3qM(2#636G`rp7(mDY+IKMpY;Kw1km$NR9M^s}4^>T^jaw zuRFwjw0LzMmw^m%)Y3@zc%V8Pt2^~Rw}ob{E_|H%1bj1d=u%_%6n!yy%t^3Ui14sd zp>c!?q@;fK!ya9UaA26x_A7X)OP0zb%J)UcRV8VEf7vDxyxcdo(zQ+pvLBGpu zVH&<(`)!A#-9S3u)aSAYnTPF9xd|m@3+MZ$JozJOr|2^vtpJtz=1HY)8u(tg&cqkP zy@mHBY8fa6foTO%Zz5OE7j7>|TwGH{8!>WyFHKwFm;aaZXjB!xN@jA#$!WQK~D_*&{ zeYbjG(X_O1Wvf4lq~GR84qzU>G4`hQolGjxAmD*|1her#{fc~(0GxtT6M44SFm@S zcsqa_LafYcZq2NfpY3K#22pa=c{oqRtV++`w}p^}v4O^SE8BrC#KQ zgfRH(NbypMl!ZV_5Lz@D-(&OSt+*)ffarA0*21M0#<|btf^tSYQw0}6p(2mw?a1bF zmOFDee~v%#xSs1rkt<(B>?1VS=HM}}`}9Q1y%7P`o2b!jqY_WSkoM=TT)XFndM213 zxoOfhFGNfyv;`_hEF6X=sVsxGi@LvI-8@fiQnrkkP F{}*jqd0+ql literal 0 HcmV?d00001 diff --git a/website/static/img/others/github-logo.png b/website/static/img/others/github-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..9490ffc6d2e158b266f719d58365905c1c5060cb GIT binary patch literal 8640 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 literal 0 HcmV?d00001 diff --git a/website/static/img/silkdotnet_v3.svg b/website/static/img/silkdotnet_v3.svg new file mode 100644 index 0000000000..e2c64519a0 --- /dev/null +++ b/website/static/img/silkdotnet_v3.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/website/static/img/silkdotnet_v3_w.svg b/website/static/img/silkdotnet_v3_w.svg new file mode 100644 index 0000000000..ac6e5ad3da --- /dev/null +++ b/website/static/img/silkdotnet_v3_w.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/website/static/img/stride.svg b/website/static/img/stride.svg new file mode 100644 index 0000000000..30bde03830 --- /dev/null +++ b/website/static/img/stride.svg @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/website/static/img/wordmark.svg b/website/static/img/wordmark.svg new file mode 100644 index 0000000000..d58c13e0c0 --- /dev/null +++ b/website/static/img/wordmark.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/website/static/img/wordmarkw.svg b/website/static/img/wordmarkw.svg new file mode 100644 index 0000000000..d0d0106d9f --- /dev/null +++ b/website/static/img/wordmarkw.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/website/static/img/xplatpromo.png b/website/static/img/xplatpromo.png new file mode 100644 index 0000000000000000000000000000000000000000..f9fb528f139ab15ec65cd7f71689c4b3bbb81f9e GIT binary patch literal 9809 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�tP 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