diff --git a/.github/workflows/publish-docs.yml b/.github/workflows/publish-docs.yml new file mode 100644 index 0000000..45658f9 --- /dev/null +++ b/.github/workflows/publish-docs.yml @@ -0,0 +1,57 @@ +name: Publish Docs + +on: + push: + branches: [main] + paths: + - 'docs/**' + - 'src/DocSamples/**' + - 'mdsnippets.json' + - 'package.json' + workflow_dispatch: + +env: + DOTNET_CLI_TELEMETRY_OPTOUT: 1 + DOTNET_SKIP_FIRST_TIME_EXPERIENCE: 1 + +jobs: + publish: + name: Build and deploy docs to Netlify + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v4 + + - name: Install Node.js + uses: actions/setup-node@v4 + with: + node-version: 20 + + - name: Install .NET 10.0.x + uses: actions/setup-dotnet@v4 + with: + dotnet-version: 10.0.x + + - name: Build DocSamples + run: dotnet build src/DocSamples/DocSamples.csproj -c Release + + - name: Install mdsnippets + run: dotnet tool install -g markdownSnippets.tool + + - name: Run mdsnippets + run: mdsnippets + + - name: Install npm dependencies + run: npm ci + + - name: Build VitePress site + run: npx vitepress build docs + + - name: Deploy to Netlify + uses: nwtgck/actions-netlify@v3 + with: + publish-dir: docs/.vitepress/dist + production-deploy: true + env: + NETLIFY_AUTH_TOKEN: ${{ secrets.NETLIFY_AUTH_TOKEN }} + NETLIFY_SITE_ID: ${{ secrets.NETLIFY_SITE_ID }} diff --git a/.gitignore b/.gitignore index e7c4576..8565fee 100644 --- a/.gitignore +++ b/.gitignore @@ -399,3 +399,7 @@ FodyWeavers.xsd .idea/ .DS_Store src/CommandLineRunner/description.txt + +# VitePress documentation +docs/.vitepress/cache +docs/.vitepress/dist diff --git a/docs/.gitignore b/docs/.gitignore new file mode 100644 index 0000000..94aa6e0 --- /dev/null +++ b/docs/.gitignore @@ -0,0 +1,3 @@ +.vitepress/cache +.vitepress/dist +node_modules diff --git a/docs/.vitepress/config.ts b/docs/.vitepress/config.ts new file mode 100644 index 0000000..79dd736 --- /dev/null +++ b/docs/.vitepress/config.ts @@ -0,0 +1,108 @@ +import { defineConfig } from 'vitepress' +import { withMermaid } from 'vitepress-plugin-mermaid' + +export default withMermaid( + defineConfig({ + title: 'JasperFx', + description: 'The foundational .NET library behind the Critter Stack', + head: [ + ['link', { rel: 'icon', href: '/jasperfx-logo.png' }] + ], + + themeConfig: { + logo: '/jasperfx-logo.png', + + nav: [ + { text: 'Guide', link: '/guide/' }, + { text: 'Code Generation', link: '/codegen/' }, + { text: 'Command Line', link: '/cli/' }, + { text: 'Configuration', link: '/configuration/critter-stack-defaults' }, + { + text: 'Ecosystem', + items: [ + { text: 'Marten', link: 'https://martendb.io' }, + { text: 'Wolverine', link: 'https://wolverinefx.io' }, + { text: 'Weasel', link: 'https://weasel.jasperfx.net' }, + { text: 'GitHub', link: 'https://github.com/JasperFx/jasperfx' } + ] + } + ], + + sidebar: [ + { + text: 'Getting Started', + collapsed: false, + items: [ + { text: 'Introduction', link: '/guide/' }, + { text: 'Installation', link: '/guide/installation' }, + { text: 'Quick Start', link: '/guide/quickstart' } + ] + }, + { + text: 'Code Generation', + collapsed: false, + items: [ + { text: 'Overview & Architecture', link: '/codegen/' }, + { text: 'Frames', link: '/codegen/frames' }, + { text: 'Variables', link: '/codegen/variables' }, + { text: 'MethodCall', link: '/codegen/method-call' }, + { text: 'Generated Types & Methods', link: '/codegen/generated-types' }, + { text: 'Built-in Frames', link: '/codegen/built-in-frames' }, + { text: 'CLI: codegen Command', link: '/codegen/cli' } + ] + }, + { + text: 'Command Line', + collapsed: false, + items: [ + { text: 'Setup & Integration', link: '/cli/' }, + { text: 'Writing Commands', link: '/cli/writing-commands' }, + { text: 'Arguments & Flags', link: '/cli/arguments-flags' }, + { text: 'Environment Checks', link: '/cli/environment-checks' }, + { text: 'Describe Command', link: '/cli/describe' } + ] + }, + { + text: 'Configuration', + collapsed: true, + items: [ + { text: 'CritterStackDefaults', link: '/configuration/critter-stack-defaults' }, + { text: 'JasperFxOptions', link: '/configuration/jasperfx-options' } + ] + }, + { + text: 'Extension Methods', + collapsed: true, + items: [ + { text: 'Overview', link: '/extensions/' }, + { text: 'String Extensions', link: '/extensions/string-extensions' }, + { text: 'Enumerable Extensions', link: '/extensions/enumerable-extensions' }, + { text: 'Reflection Extensions', link: '/extensions/reflection-extensions' } + ] + } + ], + + socialLinks: [ + { icon: 'github', link: 'https://github.com/JasperFx/jasperfx' } + ], + + editLink: { + pattern: 'https://github.com/JasperFx/jasperfx/edit/main/docs/:path' + }, + + footer: { + message: 'Released under the MIT License.', + copyright: 'Copyright JasperFx Software' + }, + + search: { + provider: 'local' + } + }, + + mermaid: {}, + mermaidPlugin: { + class: 'mermaid' + } + }) +) diff --git a/docs/.vitepress/theme/custom.css b/docs/.vitepress/theme/custom.css new file mode 100644 index 0000000..91ee6e0 --- /dev/null +++ b/docs/.vitepress/theme/custom.css @@ -0,0 +1,30 @@ +:root { + --vp-c-brand-1: #C26A1A; + --vp-c-brand-2: #D4782B; + --vp-c-brand-3: #E08A3D; + --vp-c-brand-soft: rgba(194, 106, 26, 0.14); + + --vp-home-hero-name-color: transparent; + --vp-home-hero-name-background: linear-gradient(135deg, #C26A1A 0%, #E08A3D 100%); + --vp-home-hero-image-background-image: linear-gradient(135deg, rgba(194, 106, 26, 0.3) 0%, rgba(224, 138, 61, 0.2) 100%); + --vp-home-hero-image-filter: blur(44px); + + --vp-button-brand-border: transparent; + --vp-button-brand-text: #fff; + --vp-button-brand-bg: #C26A1A; + --vp-button-brand-hover-border: transparent; + --vp-button-brand-hover-text: #fff; + --vp-button-brand-hover-bg: #D4782B; + --vp-button-brand-active-border: transparent; + --vp-button-brand-active-text: #fff; + --vp-button-brand-active-bg: #A85A16; +} + +.dark { + --vp-c-brand-1: #D4782B; + --vp-c-brand-2: #E08A3D; + --vp-c-brand-3: #ECA050; + --vp-c-brand-soft: rgba(212, 120, 43, 0.16); + + --vp-home-hero-image-background-image: linear-gradient(135deg, rgba(194, 106, 26, 0.2) 0%, rgba(224, 138, 61, 0.15) 100%); +} diff --git a/docs/.vitepress/theme/index.ts b/docs/.vitepress/theme/index.ts new file mode 100644 index 0000000..42fe9a9 --- /dev/null +++ b/docs/.vitepress/theme/index.ts @@ -0,0 +1,4 @@ +import DefaultTheme from 'vitepress/theme' +import './custom.css' + +export default DefaultTheme diff --git a/docs/cli/arguments-flags.md b/docs/cli/arguments-flags.md new file mode 100644 index 0000000..1e09a06 --- /dev/null +++ b/docs/cli/arguments-flags.md @@ -0,0 +1,100 @@ +# Arguments and Flags + +Command inputs are plain C# classes whose properties are mapped to arguments and flags. + +## Defining an Input Class + + + +```cs +public class BuildInput +{ + [Description("The target configuration")] + public string Configuration { get; set; } = "Debug"; + + [Description("The output directory")] + public string OutputPath { get; set; } = "./bin"; + + [FlagAlias("verbose", 'v')] + [Description("Enable verbose output")] + public bool VerboseFlag { get; set; } + + [FlagAlias("force", 'f')] + [Description("Force a clean rebuild")] + public bool ForceFlag { get; set; } + + [Description("Maximum degree of parallelism")] + public int ParallelCount { get; set; } = 4; +} +``` +snippet source | anchor + + +```cs +public class BuildInput +{ + [Description("The target configuration")] + public string Configuration { get; set; } = "Debug"; + + [Description("The output directory")] + public string OutputPath { get; set; } = "./bin"; + + [FlagAlias("verbose", 'v')] + [Description("Enable verbose output")] + public bool VerboseFlag { get; set; } + + [FlagAlias("force", 'f')] + [Description("Force a clean rebuild")] + public bool ForceFlag { get; set; } + + [Description("Maximum degree of parallelism")] + public int ParallelCount { get; set; } = 4; +} +``` +snippet source | anchor + + +## Arguments + +Public properties that are not suffixed with `Flag` are treated as positional arguments. They are matched in the order they appear on the class. + +- **Required arguments** -- Non-nullable properties without a default value +- **Optional arguments** -- Properties with a default value + +## Flags + +Properties whose names end with `Flag` are treated as command line flags (options). + +### Flag Aliases + +Use `[FlagAlias]` to define short and long flag names: + +```csharp +[FlagAlias("verbose", 'v')] +public bool VerboseFlag { get; set; } +``` + +This allows both `--verbose` and `-v` on the command line. + +### Flag Types + +| .NET Type | CLI Syntax | Example | +|-----------|-----------|---------| +| `bool` | `--flag` | `--verbose` | +| `string` | `--flag value` | `--output ./bin` | +| `int` | `--flag value` | `--parallel 8` | +| `Enum` | `--flag value` | `--level Debug` | + +## Description Attribute + +Use `[Description]` on properties to provide help text displayed in the CLI: + +```csharp +[Description("The target configuration")] +public string Configuration { get; set; } = "Debug"; +``` + +## Next Steps + +- [Writing Commands](/cli/writing-commands) -- Build commands using input classes +- [Environment Checks](/cli/environment-checks) -- Startup validation diff --git a/docs/cli/describe.md b/docs/cli/describe.md new file mode 100644 index 0000000..9231aca --- /dev/null +++ b/docs/cli/describe.md @@ -0,0 +1,91 @@ +# Describe Command + +The `describe` command outputs a summary of your application's configuration and registered components. It is built in and available automatically. + +## Running Describe + +```bash +dotnet run -- describe +``` + +This prints information about all registered `ISystemPart` instances, including those added by Critter Stack libraries like Marten and Wolverine. + +## Custom System Parts + +Implement `ISystemPart` to add your own sections to the describe output: + + + +```cs +public class MessagingSystemPart : SystemPartBase +{ + public MessagingSystemPart() + : base("Messaging Subsystem", new Uri("system://messaging")) + { + } + + public override Task WriteToConsole() + { + AnsiConsole.MarkupLine("[bold]Transport:[/] RabbitMQ"); + AnsiConsole.MarkupLine("[bold]Queues:[/] 12 active"); + AnsiConsole.MarkupLine("[bold]Consumers:[/] 8 running"); + return Task.CompletedTask; + } +} +``` +snippet source | anchor + + +```cs +public class MessagingSystemPart : SystemPartBase +{ + public MessagingSystemPart() + : base("Messaging Subsystem", new Uri("system://messaging")) + { + } + + public override Task WriteToConsole() + { + AnsiConsole.MarkupLine("[bold]Transport:[/] RabbitMQ"); + AnsiConsole.MarkupLine("[bold]Queues:[/] 12 active"); + AnsiConsole.MarkupLine("[bold]Consumers:[/] 8 running"); + return Task.CompletedTask; + } +} +``` +snippet source | anchor + + +Register your system part through `JasperFxOptions`: + +```csharp +services.AddJasperFx(opts => +{ + opts.Services.AddSingleton(); +}); +``` + +## IDescriptionWriter + +The `IDescriptionWriter` interface provides methods for structured output: + +| Method | Purpose | +|--------|---------| +| `BulletItem(string)` | Write a bullet point | +| `Header(string)` | Write a section header | +| `Write(string)` | Write plain text | + +## Built-in System Parts + +JasperFx itself registers a system part for `JasperFxOptions` that reports: + +- Active profile (Development, Staging, Production) +- Required files +- Registered environment checks + +Other Critter Stack libraries add their own parts automatically when referenced. + +## Next Steps + +- [Environment Checks](/cli/environment-checks) -- Validate dependencies at startup +- [JasperFx Options](/configuration/jasperfx-options) -- Full options reference diff --git a/docs/cli/environment-checks.md b/docs/cli/environment-checks.md new file mode 100644 index 0000000..3f159a3 --- /dev/null +++ b/docs/cli/environment-checks.md @@ -0,0 +1,180 @@ +# Environment Checks + +Environment checks let you verify that external dependencies are available when your application starts. + +## Registering Checks + +Use the `CheckEnvironment` extension methods on `IServiceCollection`: + + + +```cs +public static void RegisterChecks(IServiceCollection services) +{ + // Async check with IServiceProvider access + services.CheckEnvironment( + "Database is reachable", + async (IServiceProvider sp, CancellationToken ct) => + { + // Throw an exception to indicate failure + await Task.CompletedTask; + }); + + // Synchronous check + services.CheckEnvironment( + "Configuration file exists", + (IServiceProvider sp) => + { + if (!File.Exists("appsettings.json")) + { + throw new FileNotFoundException("Missing configuration file"); + } + }); +} +``` +snippet source | anchor + + +```cs +public static void RegisterChecks(IServiceCollection services) +{ + // Async check with IServiceProvider access + services.CheckEnvironment( + "Database is reachable", + async (IServiceProvider sp, CancellationToken ct) => + { + // Throw an exception to indicate failure + await Task.CompletedTask; + }); + + // Synchronous check + services.CheckEnvironment( + "Configuration file exists", + (IServiceProvider sp) => + { + if (!File.Exists("appsettings.json")) + { + throw new FileNotFoundException("Missing configuration file"); + } + }); +} +``` +snippet source | anchor + + +## Typed Service Checks + +You can resolve a registered service and check it directly: + + + +```cs +public static void RegisterTypedCheck(IServiceCollection services) +{ + services.CheckEnvironment( + "Required config keys present", + config => + { + if (config?.GetValue("ConnectionString") is null) + { + throw new Exception("ConnectionString is required"); + } + }); +} +``` +snippet source | anchor + + +```cs +public static void RegisterTypedCheck(IServiceCollection services) +{ + services.CheckEnvironment( + "Required config keys present", + config => + { + if (config?.GetValue("ConnectionString") is null) + { + throw new Exception("ConnectionString is required"); + } + }); +} +``` +snippet source | anchor + + +## Running Checks + +Run all registered checks from the command line: + +```bash +dotnet run -- check-env +``` + +Each check runs and reports success or failure. The command exits with a non-zero code if any check fails. + +## Inline Registration via JasperFxOptions + +You can also register checks directly through `JasperFxOptions`: + + + +```cs +public static void ConfigureOptions(IServiceCollection services) +{ + services.AddJasperFx(opts => + { + // Register an environment check inline + opts.RegisterEnvironmentCheck( + "Database connectivity", + async (sp, ct) => + { + // Verify your database is accessible + await Task.CompletedTask; + }); + }); +} +``` +snippet source | anchor + + +```cs +public static void ConfigureOptions(IServiceCollection services) +{ + services.AddJasperFx(opts => + { + // Register an environment check inline + opts.RegisterEnvironmentCheck( + "Database connectivity", + async (sp, ct) => + { + // Verify your database is accessible + await Task.CompletedTask; + }); + }); +} +``` +snippet source | anchor + + +## Required Files + +A common check is verifying that a configuration file exists. JasperFx provides a shorthand: + +```csharp +services.AddJasperFx(opts => +{ + opts.RequireFile("appsettings.json"); + opts.RequireFile("certs/server.pfx"); +}); +``` + +## Best Practices + +- Keep checks fast. They run at startup and slow checks delay your application. +- Throw descriptive exceptions so failures are easy to diagnose. +- Use environment checks for external dependencies (databases, files, services) rather than internal validation. + +## Next Steps + +- [Describe](/cli/describe) -- Customize application description output +- [Configuration](/configuration/jasperfx-options) -- Full options reference diff --git a/docs/cli/index.md b/docs/cli/index.md new file mode 100644 index 0000000..23249b8 --- /dev/null +++ b/docs/cli/index.md @@ -0,0 +1,82 @@ +# Command Line Tooling + +JasperFx includes a lightweight CLI framework for building commands that integrate with `Microsoft.Extensions.Hosting`. + +## Enabling the CLI + +Wire up the JasperFx command line by calling `ApplyJasperFxExtensions` on your host builder: + + + +```cs +await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); +``` +snippet source | anchor + + +```cs +await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); +``` +snippet source | anchor + + +Alternatively, use `RunJasperFxCommands` for more control over host configuration: + + + +```cs +var builder = Host.CreateDefaultBuilder(); + +builder.ConfigureServices(services => +{ + // Register your services here +}); + +await builder + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); +``` +snippet source | anchor + + +```cs +var builder = Host.CreateDefaultBuilder(); + +builder.ConfigureServices(services => +{ + // Register your services here +}); + +await builder + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); +``` +snippet source | anchor + + +## Built-in Commands + +JasperFx ships with several commands out of the box: + +| Command | Description | +|---------|-------------| +| `help` | List all available commands | +| `describe` | Describe the application configuration | +| `check-env` | Run all registered environment checks | + +## Command Discovery + +Commands are discovered automatically from referenced assemblies that carry the `[JasperFxTool]` attribute. Your own commands are found through assembly scanning. + +## Topics + +- [Writing Commands](/cli/writing-commands) -- Create synchronous and async commands +- [Arguments and Flags](/cli/arguments-flags) -- Define inputs with attributes +- [Environment Checks](/cli/environment-checks) -- Validate runtime dependencies +- [Describe](/cli/describe) -- Customize the describe output diff --git a/docs/cli/writing-commands.md b/docs/cli/writing-commands.md new file mode 100644 index 0000000..7fcb6ac --- /dev/null +++ b/docs/cli/writing-commands.md @@ -0,0 +1,128 @@ +# Writing Commands + +JasperFx provides two base classes for building CLI commands. + +## Synchronous Commands + +Extend `JasperFxCommand` for commands that do not need async operations: + + + +```cs +[Description("Say hello to someone")] +public class GreetingCommand : JasperFxCommand +{ + public override bool Execute(GreetingInput input) + { + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +``` +snippet source | anchor + + +```cs +[Description("Say hello to someone")] +public class GreetingCommand : JasperFxCommand +{ + public override bool Execute(GreetingInput input) + { + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +``` +snippet source | anchor + + +The `Execute` method returns `true` for success or `false` for failure. The exit code is set accordingly. + +## Async Commands + +Extend `JasperFxAsyncCommand` when you need to perform async work: + + + +```cs +[Description("Say hello to someone asynchronously")] +public class AsyncGreetingCommand : JasperFxAsyncCommand +{ + public override async Task Execute(GreetingInput input) + { + await Task.Delay(100); + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +``` +snippet source | anchor + + +```cs +[Description("Say hello to someone asynchronously")] +public class AsyncGreetingCommand : JasperFxAsyncCommand +{ + public override async Task Execute(GreetingInput input) + { + await Task.Delay(100); + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +``` +snippet source | anchor + + +## Input Classes + +Every command takes an input class that defines its arguments and flags: + + + +```cs +public class GreetingInput +{ + [Description("The name to greet")] + public string Name { get; set; } = "World"; +} +``` +snippet source | anchor + + +```cs +public class GreetingInput +{ + [Description("The name to greet")] + public string Name { get; set; } = "World"; +} +``` +snippet source | anchor + + +Properties on the input class are automatically mapped to command line arguments. See [Arguments and Flags](/cli/arguments-flags) for the full attribute reference. + +## Command Naming + +By default, the command name is derived from the class name by removing the `Command` suffix and converting to kebab-case. For example, `GreetingCommand` becomes `greeting`. + +## Usage Patterns + +Commands can define multiple usage patterns similar to Git: + +```csharp +public class MyCommand : JasperFxCommand +{ + public MyCommand() + { + Usage("Default usage").Arguments(x => x.Name); + } + + public override bool Execute(MyInput input) => true; +} +``` + +## Next Steps + +- [Arguments and Flags](/cli/arguments-flags) -- Detailed attribute reference +- [Environment Checks](/cli/environment-checks) -- Register startup validations diff --git a/docs/codegen/built-in-frames.md b/docs/codegen/built-in-frames.md new file mode 100644 index 0000000..07584f9 --- /dev/null +++ b/docs/codegen/built-in-frames.md @@ -0,0 +1,242 @@ +# Built-in Frames + +JasperFx ships with several ready-to-use `Frame` implementations. These cover the most common code generation patterns so you rarely need to write custom frames for straightforward scenarios. + +## CommentFrame + +Writes a single-line C# comment into the generated code. Useful for making generated source more readable. + + + +```cs +public static void UsingCommentFrame() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Worker", typeof(IWorker)); + var method = type.MethodFor(nameof(IWorker.Execute)); + + // CommentFrame writes a C# comment line + method.Frames.Add(new CommentFrame("Begin processing")); + method.Frames.Code("Console.WriteLine(\"Working...\");"); +} + +public interface IWorker +{ + void Execute(); +} +``` +snippet source | anchor + + +Generated output: + +``` +// Begin processing +``` + +## CodeFrame + +A general-purpose frame that writes a single statement from a format string. Variable placeholders are resolved automatically. + + + +```cs +public static void UsingCodeFrame() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Processor", typeof(IProcessor)); + var method = type.MethodFor(nameof(IProcessor.Process)); + + // CodeFrame uses a format string with variable placeholders + method.Frames.Code("Console.WriteLine({0});", Use.Type()); +} + +public interface IProcessor +{ + void Process(string input); +} +``` +snippet source | anchor + + +The `{0}` placeholder is replaced by the resolved variable's `Usage` name. You can reference multiple variables with `{1}`, `{2}`, etc. + +## ReturnFrame + +Generates a `return` statement, optionally returning a resolved variable. + + + +```cs +public static void UsingReturnFrame() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Checker", typeof(IChecker)); + var method = type.MethodFor(nameof(IChecker.IsValid)); + + method.Frames.Code("var result = {0} != null;", Use.Type()); + + // ReturnFrame generates "return ;" + method.Frames.Add(new ReturnFrame(typeof(bool))); +} + +public interface IChecker +{ + bool IsValid(object input); +} +``` +snippet source | anchor + + +- `new ReturnFrame()` -- generates `return;` for void methods. +- `new ReturnFrame(typeof(bool))` -- resolves a `bool` variable and generates `return ;`. +- `new ReturnFrame(variable)` -- generates `return ;` for a specific variable. + +## MethodCall + +Generates a call to an existing method with full argument and return value resolution. This is the most commonly used frame and has its own dedicated page. + + + +```cs +public static void UsingMethodCallFrame() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Invoker", typeof(IInvoker)); + var method = type.MethodFor(nameof(IInvoker.Invoke)); + + // MethodCall generates a call to a static or instance method + var call = new MethodCall(typeof(Console), nameof(Console.WriteLine)); + method.Frames.Add(call); +} + +public interface IInvoker +{ + void Invoke(string message); +} +``` +snippet source | anchor + + +See [MethodCall](./method-call) for the full reference. + +## ConstructorFrame + +Generates a `new` expression for a given type, resolving constructor arguments through the variable system. + + + +```cs +public static void UsingConstructorFrame() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("ServiceBuilder", typeof(IServiceBuilder)); + var method = type.MethodFor(nameof(IServiceBuilder.Build)); + + // ConstructorFrame generates "var widget = new Widget();" + var ctor = new ConstructorFrame(() => new Widget()); + method.Frames.Add(ctor); +} + +public interface IServiceBuilder +{ + Widget Build(); +} + +public class Widget; +``` +snippet source | anchor + + +The generic `ConstructorFrame` variant accepts a lambda expression to identify the constructor. The generated code will be something like: + +``` +var widget = new Widget(); +``` + +### ConstructorCallMode + +| Mode | Generated Code | +|------|---------------| +| `Variable` | `var x = new T(...);` (default) | +| `ReturnValue` | `return new T(...);` | +| `UsingNestedVariable` | `using var x = new T(...);` | + +## IfBlock + +Wraps inner frames in a conditional `if` block. + + + +```cs +public static void UsingIfBlock() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Guard", typeof(IGuard)); + var method = type.MethodFor(nameof(IGuard.Check)); + + // IfBlock wraps inner frames in an if statement + var inner = new CodeFrame(false, "Console.WriteLine(\"Input is not null\");"); + method.Frames.Add(new IfBlock("input != null", inner)); +} + +public interface IGuard +{ + void Check(object input); +} +``` +snippet source | anchor + + +You can pass a string condition or a `Variable` (uses the variable's `Usage` property as the condition). + +## ThrowExceptionFrame + +Generates a `throw new ExceptionType(...)` statement. + +```csharp +var frame = new ThrowExceptionFrame(someVariable); +// Generates: throw new System.InvalidOperationException(someVariable); +``` + +## TemplateFrame + +An abstract base for frames that use a template string with typed variable placeholders. Subclass it and override `Template()`: + +```csharp +public class MyFrame : TemplateFrame +{ + protected override string Template() + { + var input = Arg(); + return $"Console.WriteLine({input});"; + } +} +``` + +The `Arg()` method creates a placeholder that the engine resolves to a real variable during code arrangement. + +## Summary + +| Frame | Purpose | +|-------|---------| +| `CommentFrame` | Writes a `// comment` line | +| `CodeFrame` | Writes a single statement from a format string | +| `ReturnFrame` | Writes `return;` or `return variable;` | +| `MethodCall` | Calls an existing method | +| `ConstructorFrame` | Calls `new T(...)` | +| `IfBlock` | Wraps frames in `if (condition) { }` | +| `ThrowExceptionFrame` | Throws an exception | +| `TemplateFrame` | Template-based code with typed placeholders | diff --git a/docs/codegen/cli.md b/docs/codegen/cli.md new file mode 100644 index 0000000..5410fe1 --- /dev/null +++ b/docs/codegen/cli.md @@ -0,0 +1,141 @@ +# CLI: codegen Command + +JasperFx provides a `codegen` command through its CLI tooling that lets you manage generated code ahead of time. This is essential for production deployments where you want the fastest possible startup by avoiding runtime compilation. + +## Setup + +To use the `codegen` command, your application must integrate the JasperFx command line extensions: + + + +```cs +public static async Task SetupWithCodegenCommand(string[] args) +{ + return await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); + + // Run with: dotnet run -- codegen preview + // Run with: dotnet run -- codegen write + // Run with: dotnet run -- codegen delete +} +``` +snippet source | anchor + + +## TypeLoadMode + +The `TypeLoadMode` enum on `GenerationRules` controls how generated types are loaded at runtime: + +### Dynamic + + + +```cs +public static void ConfigureDynamicMode() +{ + // Always generate types at runtime. Best for development. + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Dynamic + }; +} +``` +snippet source | anchor + + +Always generates and compiles types at runtime. This is the default and is the best choice during development because changes to configuration are immediately reflected without a separate build step. + +### Auto + + + +```cs +public static void ConfigureAutoMode() +{ + // Try to load pre-built types first, fall back to runtime generation + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Auto + }; +} +``` +snippet source | anchor + + +Tries to load pre-built types from the application assembly first. If the types are not found, falls back to runtime generation and exports the new source code. This is a good middle ground for staging environments. + +### Static + + + +```cs +public static void ConfigureStaticMode() +{ + // Types must be pre-built in the application assembly. + // Throws if generated types are missing. + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Static + }; +} +``` +snippet source | anchor + + +Types must already exist in the pre-built application assembly. If any generated type is missing, the application throws an exception at startup. This provides the fastest startup time and is recommended for production. + +## Commands + +### codegen preview + +```bash +dotnet run -- codegen preview +``` + +Generates all source code and writes it to the console without modifying any files. Use this to inspect the generated code before committing it. + +### codegen write + +```bash +dotnet run -- codegen write +``` + +Generates all source code and writes the files into the project directory. The generated files are then compiled into the assembly on the next `dotnet build`. After writing, you can switch to `TypeLoadMode.Static` or `TypeLoadMode.Auto` to load the pre-built types. + +### codegen delete + +```bash +dotnet run -- codegen delete +``` + +Removes all previously generated source files from the project directory. Use this to clean up before regenerating or when switching back to `TypeLoadMode.Dynamic`. + +## Recommended Workflow + +1. **During development**, use `TypeLoadMode.Dynamic` so types are always regenerated as you change configuration. +2. **Before deploying**, run `dotnet run -- codegen write` to persist the generated source files. +3. **In production**, switch to `TypeLoadMode.Static` for the fastest startup. The pre-built types load directly from the compiled assembly with no Roslyn overhead. + +```mermaid +graph LR + Dev["Development
Dynamic"] -->|codegen write| Build["CI Build
Auto"] + Build -->|deploy| Prod["Production
Static"] + Prod -->|codegen delete| Dev +``` + +## Environment-Based Configuration + +A common pattern is to select the `TypeLoadMode` based on the hosting environment: + +```csharp +var rules = new GenerationRules("MyApp.Generated") +{ + TypeLoadMode = builder.Environment.IsDevelopment() + ? TypeLoadMode.Dynamic + : TypeLoadMode.Static +}; +``` + +This gives you runtime generation during development and pre-built types in production without any manual switching. diff --git a/docs/codegen/frames.md b/docs/codegen/frames.md new file mode 100644 index 0000000..552bec3 --- /dev/null +++ b/docs/codegen/frames.md @@ -0,0 +1,159 @@ +# Frames + +Frames are the fundamental building blocks of the JasperFx code generation model. Each `Frame` is responsible for writing one or more lines of C# source code into a generated method body. + +## The Frame Base Class + +All frames derive from the abstract `Frame` class in `JasperFx.CodeGeneration.Frames`. A frame declares: + +- Whether it is **async** (its constructor receives a `bool isAsync` flag). +- Which **Variables** it creates (the `creates` list). +- Which **Variables** it uses/depends on (the `uses` list). +- An optional **Next** frame in the chain. + +The single abstract method every frame must implement: + +``` +void GenerateCode(GeneratedMethod method, ISourceWriter writer) +``` + +Inside `GenerateCode`, the frame writes C# text through the `ISourceWriter` and then typically calls `Next?.GenerateCode(method, writer)` to continue the chain. + +## SyncFrame and AsyncFrame + +JasperFx provides two convenience base classes so you do not have to pass the `isAsync` flag manually: + +- **`SyncFrame`** -- sets `isAsync` to `false`. Use for frames that produce synchronous code. +- **`AsyncFrame`** -- sets `isAsync` to `true`. Use when the generated code must `await` something. + +## Writing a Custom Sync Frame + + + +```cs +public class LogMessageFrame : SyncFrame +{ + private readonly string _message; + private Variable? _logger; + + public LogMessageFrame(string message) + { + _message = message; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + writer.Write($"Console.WriteLine(\"{_message}\");"); + + // Always call through to the next frame in the chain + Next?.GenerateCode(method, writer); + } +} +``` +snippet source | anchor + + +Key points: + +1. Inherit from `SyncFrame` (or `AsyncFrame` for async code). +2. Override `GenerateCode` to write your C# lines through the `ISourceWriter`. +3. Always call `Next?.GenerateCode(method, writer)` at the end so the next frame in the chain can emit its code. + +## Writing a Custom Async Frame + + + +```cs +public class LoadEntityFrame : AsyncFrame +{ + private readonly Type _entityType; + private Variable? _id; + + public LoadEntityFrame(Type entityType) + { + _entityType = entityType; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + var entityVariable = Create(_entityType); + + writer.Write( + $"var {entityVariable.Usage} = await repository.LoadAsync<{_entityType.Name}>({_id?.Usage ?? "id"});"); + + Next?.GenerateCode(method, writer); + } +} +``` +snippet source | anchor + + +Async frames work identically except they extend `AsyncFrame` and typically emit `await` expressions. + +## Wrapping Frames + +A frame can wrap subsequent frames by setting `Wraps = true`. This is useful for try/catch blocks, using blocks, timing wrappers, and similar patterns. + + + +```cs +public class StopwatchFrame : SyncFrame +{ + public StopwatchFrame() + { + // Mark this frame as wrapping inner frames + Wraps = true; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + writer.Write("var stopwatch = System.Diagnostics.Stopwatch.StartNew();"); + writer.Write("BLOCK:try"); + + // Let the inner frames generate their code + Next?.GenerateCode(method, writer); + + writer.FinishBlock(); // end try + writer.Write("BLOCK:finally"); + writer.Write("stopwatch.Stop();"); + writer.Write("Console.WriteLine($\"Elapsed: {stopwatch.ElapsedMilliseconds}ms\");"); + writer.FinishBlock(); // end finally + } +} +``` +snippet source | anchor + + +When `Wraps` is `true`, the code generation engine knows that this frame opens a scope that encloses the next frame(s). + +## Creating Variables from a Frame + +Frames can declare that they "create" a variable. This is how the variable resolution system knows which frame must run before another: + +```csharp +// Inside a Frame subclass +var result = Create(); // registers the variable in this.creates +``` + +Any downstream frame that needs a `MyService` variable will automatically depend on this frame. + +## Variable Dependencies + +Frames can also declare variables they "use": + +```csharp +uses.Add(someVariable); +``` + +The code generation engine uses these `creates` and `uses` declarations to determine the correct ordering of frames and to resolve variables across the method. + +## Frame Ordering + +When you add frames to a `GeneratedMethod`, the engine: + +1. Collects all frames and their variable dependencies. +2. Topologically sorts frames so that a frame producing a variable always appears before frames consuming it. +3. Chains frames together via their `Next` property. +4. Calls `GenerateCode` on the first frame, which cascades through the chain. + +You do not need to worry about insertion order for most cases -- the dependency graph handles it. However, if two frames have no dependency relationship, they will appear in the order you added them. diff --git a/docs/codegen/generated-types.md b/docs/codegen/generated-types.md new file mode 100644 index 0000000..09e918d --- /dev/null +++ b/docs/codegen/generated-types.md @@ -0,0 +1,205 @@ +# Generated Types & Methods + +The `GeneratedAssembly`, `GeneratedType`, and `GeneratedMethod` classes form the structural backbone of the JasperFx code generation system. Together they define what classes and methods will be generated, compiled, and optionally persisted. + +## GeneratedAssembly + +`GeneratedAssembly` is the top-level container. It holds a collection of `GeneratedType` instances and produces a single C# source file when `GenerateCode()` is called. + +```csharp +var rules = new GenerationRules("MyApp.Generated"); +var assembly = new GeneratedAssembly(rules); +``` + +Key members: + +| Member | Description | +|--------|-------------| +| `Rules` | The `GenerationRules` governing namespace, type load mode, and variable sources. | +| `Namespace` | The C# namespace for all generated types. | +| `GeneratedTypes` | Read-only list of types added to this assembly. | +| `AddType(name, baseType)` | Creates a new `GeneratedType` that inherits from or implements the given type. | +| `GenerateCode()` | Arranges all frames and returns the complete C# source code. | + +## GeneratedType + +A `GeneratedType` represents a single class to be generated. It can inherit from a base class, implement interfaces, and hold injected fields. + +### Inheriting from a Base Class + + + +```cs +public static string BuildGeneratedType() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Create a type that inherits from a base class + var type = assembly.AddType("MyMessageHandler", typeof(MessageHandlerBase)); + + // The method defined on the base class is discovered automatically. + // Retrieve it by name. + var handleMethod = type.MethodFor("Handle"); + + // Add frames to define the method body + handleMethod.Frames.Code("Console.WriteLine(\"Handling message...\");"); + handleMethod.Frames.Code("return Task.CompletedTask;"); + + // Generate all source code for the assembly + var code = assembly.GenerateCode(); + + return code; +} + +public abstract class MessageHandlerBase +{ + public abstract Task Handle(Message message); +} + +public class Message; +``` +snippet source | anchor + + +When a type inherits from a base class, the engine: + +1. Discovers all overridable methods on the base and adds them as `GeneratedMethod` entries. +2. Reads the base class constructor parameters and registers them as `InjectedField` entries on the generated type. + +### Implementing an Interface + + + +```cs +public static string ImplementInterface() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Create a type that implements an interface + var type = assembly.AddType("WidgetValidator", typeof(IValidator)); + + var method = type.MethodFor(nameof(IValidator.Validate)); + method.Frames.Code("return {0} != null;", Use.Type()); + + return assembly.GenerateCode(); +} + +public interface IValidator +{ + bool Validate(object input); +} +``` +snippet source | anchor + + +All methods declared on the interface are added as `GeneratedMethod` instances that you populate with frames. + +### Injected Fields + + + +```cs +public static string TypeWithInjectedFields() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("NotificationSender", typeof(NotificationSenderBase)); + + // The InjectedField appears as a constructor argument and private field + var loggerField = new InjectedField(typeof(ILogger)); + type.AllInjectedFields.Add(loggerField); + + var method = type.MethodFor("Send"); + method.Frames.Code("Console.WriteLine(\"Sending notification\");"); + + return assembly.GenerateCode(); +} + +public abstract class NotificationSenderBase +{ + public abstract void Send(string recipient, string body); +} + +public interface ILogger +{ + void Log(string message); +} +``` +snippet source | anchor + + +An `InjectedField` generates: +- A constructor parameter. +- A `private readonly` field. +- An assignment in the constructor body. + +Any frame that needs the field's type will resolve to the injected field automatically. + +## GeneratedMethod + +A `GeneratedMethod` holds the `Frames` collection that defines the method body. Methods are either discovered from a base class / interface or added manually. + +### Discovered Methods + +When you call `assembly.AddType("Name", typeof(SomeBase))`, all overridable methods on `SomeBase` become `GeneratedMethod` entries. Retrieve them with: + +```csharp +var method = type.MethodFor("Handle"); +``` + +### Custom Methods + + + +```cs +public static string AddCustomMethod() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Calculator", typeof(object)); + + // Add a custom void method + var method = type.AddVoidMethod("PrintSum", + new Argument(typeof(int), "a"), + new Argument(typeof(int), "b")); + + method.Frames.Code("Console.WriteLine(a + b);"); + + // Add a method that returns a value + var multiply = type.AddMethodThatReturns("Multiply", + new Argument(typeof(int), "x"), + new Argument(typeof(int), "y")); + + multiply.Frames.Code("return x * y;"); + + return assembly.GenerateCode(); +} +``` +snippet source | anchor + + +`AddVoidMethod` and `AddMethodThatReturns` let you define methods that do not come from a base class or interface. + +## Frames Collection + +The `Frames` property on `GeneratedMethod` is a `FramesCollection`. You interact with it primarily through: + +- `Frames.Add(frame)` -- add any `Frame` instance. +- `Frames.Code(format, args)` -- shorthand to add a `CodeFrame` with a format string. + +During `GenerateCode()`, the engine arranges frames by resolving variable dependencies, chains them together, and invokes `GenerateCode` on each frame in order. + +## GenerationRules + +`GenerationRules` controls assembly-wide settings: + +| Property | Description | +|----------|-------------| +| `GeneratedNamespace` | Default namespace for generated types. | +| `TypeLoadMode` | `Dynamic`, `Auto`, or `Static`. See [CLI: codegen Command](./cli). | +| `Sources` | Collection of `IVariableSource` implementations for custom variable resolution. | +| `Assemblies` | Referenced assemblies available during compilation. | diff --git a/docs/codegen/index.md b/docs/codegen/index.md new file mode 100644 index 0000000..61b1ce4 --- /dev/null +++ b/docs/codegen/index.md @@ -0,0 +1,99 @@ +# Code Generation Overview + +JasperFx includes a runtime code generation framework that builds and compiles C# classes on the fly. This is the same engine that powers the middleware pipelines in [Wolverine](https://wolverinefx.io) and the document session internals in [Marten](https://martendb.io). + +## Why Runtime Code Generation? + +Many frameworks rely on reflection or expression trees to wire up handlers, middleware, and data access at runtime. JasperFx takes a different approach: it generates actual C# source code, then compiles it using Roslyn. The result is code that runs at the same speed as hand-written C# with full debuggability -- you can inspect the generated source and set breakpoints in it. + +Key benefits: + +- **Performance** -- generated code compiles to native IL with no reflection overhead at invocation time. +- **Transparency** -- you can preview the exact C# that will be generated before it runs. +- **Extensibility** -- the frame model lets library authors compose code from reusable building blocks. + +## Architecture + +The code generation system is organized around a small set of core concepts: + +```mermaid +graph TD + GA[GeneratedAssembly] -->|contains| GT[GeneratedType] + GT -->|contains| GM[GeneratedMethod] + GM -->|contains| F[Frames] + F -->|produces/consumes| V[Variables] + F -->|specialized| MC[MethodCall] + F -->|specialized| CF[ConstructorFrame] + F -->|specialized| CdF[CodeFrame] +``` + +| Concept | Purpose | +|---------|---------| +| **GeneratedAssembly** | Top-level container. Holds one or more types and produces the final C# source file. | +| **GeneratedType** | A single class to be generated. Can inherit from a base class or implement interfaces. | +| **GeneratedMethod** | A method within a generated type. Holds the ordered collection of Frames. | +| **Frame** | A unit of code generation. Each frame writes one or more lines of C# into the method body. | +| **Variable** | Represents a C# variable flowing through frames. Tracks type, name, and which frame creates it. | + +## Quick Example + + + +```cs +public static string GenerateGreeterCode() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Add a new type that implements IGreeter + var type = assembly.AddType("HelloGreeter", typeof(IGreeter)); + + // Get the method defined by the interface + var method = type.MethodFor("Greet"); + + // Add a frame that writes a line of code + method.Frames.Code("return \"Hello, \" + {0};", Use.Type()); + + // Generate the C# source code + var code = assembly.GenerateCode(); + + return code; +} + +public interface IGreeter +{ + string Greet(string name); +} +``` +snippet source | anchor + + +## How It Works + +1. Create a `GeneratedAssembly` with a set of `GenerationRules`. +2. Add one or more `GeneratedType` entries, specifying base classes or interfaces. +3. Retrieve `GeneratedMethod` instances (discovered from the base type or added manually). +4. Populate each method with `Frame` objects that describe the code to generate. +5. Call `GenerateCode()` to produce the C# source text. +6. Optionally compile the assembly at runtime to get live `Type` instances. + +## TypeLoadMode + +JasperFx supports three strategies for loading generated types, controlled by the `TypeLoadMode` enum on `GenerationRules`: + +| Mode | Behavior | +|------|----------| +| `Dynamic` | Always generate and compile at runtime. Best for development. | +| `Auto` | Try to load pre-built types from the application assembly; fall back to runtime generation. | +| `Static` | Types must exist in the pre-built assembly. Throws if missing. Fastest startup. | + +See [CLI: codegen Command](./cli) for tooling that writes generated code ahead of time. + +## Next Steps + +- [Frames](./frames) -- learn how the Frame model works and how to write custom frames. +- [Variables](./variables) -- understand how variables flow between frames. +- [MethodCall](./method-call) -- the most commonly used frame for calling existing methods. +- [Generated Types & Methods](./generated-types) -- assembling complete types. +- [Built-in Frames](./built-in-frames) -- catalog of frames shipped with JasperFx. +- [CLI: codegen Command](./cli) -- ahead-of-time code generation tooling. diff --git a/docs/codegen/method-call.md b/docs/codegen/method-call.md new file mode 100644 index 0000000..70804a8 --- /dev/null +++ b/docs/codegen/method-call.md @@ -0,0 +1,161 @@ +# MethodCall + +`MethodCall` is the most commonly used `Frame` in the JasperFx code generation system. It generates a call to an existing .NET method -- either static or instance -- and automatically wires up arguments and return values through the variable resolution system. + +## Basic Usage + + + +```cs +public static void BasicMethodCall() +{ + // Create a MethodCall by type and method name + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + + // The ReturnVariable is automatically created from the method's return type + Console.WriteLine(call.ReturnVariable!.VariableType); // typeof(OrderResult) + + // Arguments array matches the method's parameters + Console.WriteLine(call.Arguments.Length); // matches parameter count +} +``` +snippet source | anchor + + +When you create a `MethodCall`, the frame inspects the target method via reflection and: + +1. Sets `IsAsync` based on whether the method returns `Task` or `ValueTask`. +2. Creates a `ReturnVariable` if the method has a non-void return type (unwrapping `Task` to `T`). +3. Allocates an `Arguments` array matching the method's parameters. + +## Async Methods + + + +```cs +public static void AsyncMethodCall() +{ + // Async methods are automatically detected + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrderAsync)); + + // The frame knows it is async + Console.WriteLine(call.IsAsync); // true + + // ReturnType unwraps Task to T + Console.WriteLine(call.ReturnVariable!.VariableType); // typeof(OrderResult) +} +``` +snippet source | anchor + + +Async methods are detected automatically. The generated code will emit `await` before the method call, and the enclosing generated method will be marked as `async`. + +## ReturnAction + +The `ReturnAction` property controls how the method call's return value is rendered in the generated code: + + + +```cs +public static void ReturnActions() +{ + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + + // Initialize: generates "var orderResult = ProcessOrder(...);" + call.ReturnAction = ReturnAction.Initialize; + + // Assign: generates "orderResult = ProcessOrder(...);" + call.ReturnAction = ReturnAction.Assign; + + // Return: generates "return ProcessOrder(...);" + call.ReturnAction = ReturnAction.Return; +} +``` +snippet source | anchor + + +| Value | Generated Code | +|-------|---------------| +| `Initialize` | `var result = Method(...);` | +| `Assign` | `result = Method(...);` | +| `Return` | `return Method(...);` | + +The default is `Initialize`. + +## DisposalMode + +When a method returns an `IDisposable` or `IAsyncDisposable`, you can wrap it in a using block: + + + +```cs +public static void disposal_mode_example() +{ + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.CreateConnection)); + + // Wrap the return value in a using block + call.DisposalMode = DisposalMode.UsingBlock; +} +``` +snippet source | anchor + + +| Value | Behavior | +|-------|----------| +| `None` | No disposal handling (default). | +| `UsingBlock` | Wraps the call in a `using` statement so the return value is disposed at the end of scope. | + +## Arguments + +The `Arguments` array on a `MethodCall` holds one `Variable` per method parameter. By default, arguments are left `null` and resolved automatically by the variable system during code arrangement. You can also pin a specific variable to an argument slot: + +```csharp +var call = new MethodCall(typeof(Service), nameof(Service.DoWork)); +call.Arguments[0] = someSpecificVariable; +``` + +This is useful when you need to override the default resolution for a particular parameter. + +## Using MethodCall in a Generated Type + + + +```cs +public static string UseMethodCallInGeneratedType() +{ + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("OrderHandler", typeof(IOrderHandler)); + var method = type.MethodFor(nameof(IOrderHandler.Handle)); + + // Add a MethodCall frame + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + method.Frames.Add(call); + + return assembly.GenerateCode(); +} +``` +snippet source | anchor + + +## Instance vs. Static Methods + +- **Static methods** -- the generated code calls the method directly on the type (e.g., `OrderProcessor.ProcessOrder(...)`). +- **Instance methods** -- the code generation engine resolves a variable of the handler type and calls the method on that instance (e.g., `orderProcessor.ProcessOrder(...)`). The instance variable is resolved through the same mechanism as any other variable (injected field, method argument, or variable source). + +## HandlerType + +The `HandlerType` property identifies the type that owns the method. For instance methods, a variable of this type will be resolved or created so the call can be made. + +## Tuple Return Values + +If the target method returns a `ValueTuple`, `MethodCall` automatically deconstructs the tuple into individual variables: + +```csharp +// If the method returns (string Name, int Age) +// the generated code will be: +// var (name, age) = Method(...); +``` + +Each element becomes a separate `Variable` that downstream frames can reference. diff --git a/docs/codegen/variables.md b/docs/codegen/variables.md new file mode 100644 index 0000000..cb5b5dd --- /dev/null +++ b/docs/codegen/variables.md @@ -0,0 +1,100 @@ +# Variables + +The `Variable` class in `JasperFx.CodeGeneration.Model` represents a named, typed value flowing through generated code. Variables are the primary mechanism frames use to declare their inputs and outputs, enabling the code generation engine to resolve dependencies and order frames automatically. + +## Creating Variables + + + +```cs +public static void CreateVariables() +{ + // Create a variable with an auto-generated name based on the type + var widget = new Variable(typeof(Widget), "widget"); + + // The Usage property is the C# identifier used in generated code + Console.WriteLine(widget.Usage); // "widget" + + // DefaultArgName generates a camelCase name from the type + var defaultName = Variable.DefaultArgName(typeof(Widget)); + Console.WriteLine(defaultName); // "widget" + + // Variable tied to a creating Frame + var frame = new MethodCall(typeof(WidgetFactory), nameof(WidgetFactory.Build)); + var returnVar = frame.ReturnVariable; + Console.WriteLine(returnVar!.Creator == frame); // true +} +``` +snippet source | anchor + + +## Key Properties + +| Property | Type | Description | +|----------|------|-------------| +| `VariableType` | `Type` | The .NET type of the variable. | +| `Usage` | `string` | The C# identifier used in generated source code. | +| `Creator` | `Frame?` | The frame that creates this variable, if any. | + +## Default Naming + +`Variable.DefaultArgName(Type)` produces a conventional camelCase name from a type: + + + +```cs +public static void DefaultArgNameExamples() +{ + // Simple types use lowercase type name + Console.WriteLine(Variable.DefaultArgName(typeof(Widget))); // "widget" + + // Arrays get "Array" suffix + Console.WriteLine(Variable.DefaultArgName(typeof(int[]))); // "intArray" + + // Generic types include inner type + Console.WriteLine(Variable.DefaultArgName(typeof(List))); // "listOfString" + + // Reserved C# keywords get an @ prefix + Console.WriteLine(Variable.DefaultArgName(typeof(Event))); // "@event" +} +``` +snippet source | anchor + + +The naming rules are: + +- Simple types use the lowercase type name (e.g., `Widget` becomes `widget`). +- Array types append `Array` (e.g., `int[]` becomes `intArray`). +- Generic types include the inner type (e.g., `List` becomes `listOfString`). +- If the resulting name is a C# reserved keyword, it is prefixed with `@` (e.g., `Event` becomes `@event`). + +## Variables and Frames + +Every `Frame` maintains two lists: + +- **`creates`** -- variables this frame produces. Downstream frames that need this type will depend on this frame. +- **`uses`** -- variables this frame consumes. The engine will find or create the producing frame automatically. + +When a frame calls `Create()` or `Create(Type)`, the returned `Variable` has its `Creator` set to that frame and is added to the frame's `creates` list. + +## Variable Resolution + +During code arrangement, the engine resolves variables in this order: + +1. **Locally created variables** -- a variable created by a frame earlier in the chain. +2. **Method arguments** -- parameters declared on the `GeneratedMethod`. +3. **Injected fields** -- fields declared on the `GeneratedType` (constructor-injected dependencies). +4. **Variable sources** -- custom `IVariableSource` implementations registered on the `GenerationRules`. + +If a variable cannot be resolved through any of these sources, the code generation will throw an exception describing the missing dependency. + +## InjectedField + +`InjectedField` is a specialized `Variable` that represents a constructor parameter and corresponding private field on the generated type: + +```csharp +var field = new InjectedField(typeof(ILogger)); +type.AllInjectedFields.Add(field); +``` + +This produces a constructor parameter and a `private readonly` field assignment in the generated class. Any frame that needs an `ILogger` variable will automatically resolve to this injected field. diff --git a/docs/configuration/critter-stack-defaults.md b/docs/configuration/critter-stack-defaults.md new file mode 100644 index 0000000..732990e --- /dev/null +++ b/docs/configuration/critter-stack-defaults.md @@ -0,0 +1,76 @@ +# Critter Stack Defaults + +JasperFx provides a set of opinionated defaults for applications built on the Critter Stack (Marten, Wolverine, and related libraries). + +## Applying Defaults + +Use `AddJasperFx` on `IServiceCollection` to register JasperFx services with configuration: + + + +```cs +public static IHostBuilder ConfigureWithDefaults() +{ + return Host.CreateDefaultBuilder() + .ConfigureServices(services => + { + services.AddJasperFx(opts => + { + // Require a file to exist at application startup + opts.RequireFile("appsettings.json"); + + // Set the development environment name if non-standard + opts.DevelopmentEnvironmentName = "Local"; + }); + }); +} +``` +snippet source | anchor + + +## What Gets Registered + +Calling `AddJasperFx` registers: + +- `JasperFxOptions` as a singleton +- Environment check infrastructure +- System part discovery for the `describe` command +- Assembly scanning for command discovery + +## Profiles + +JasperFx supports named profiles to vary behavior by environment: + +| Profile | Typical Use | +|---------|-------------| +| `Development` | Local development with verbose logging | +| `Staging` | Pre-production validation | +| `Production` | Optimized for reliability | + +Set the active profile in configuration: + +```csharp +services.AddJasperFx(opts => +{ + opts.ActiveProfile = "Production"; +}); +``` + +## Required Files + +Register files that must exist for the application to start: + +```csharp +services.AddJasperFx(opts => +{ + opts.RequireFile("appsettings.json"); + opts.RequireFile("keys/signing.key"); +}); +``` + +These are automatically verified by the `check-env` command. + +## Next Steps + +- [JasperFx Options](/configuration/jasperfx-options) -- Detailed options reference +- [Environment Checks](/cli/environment-checks) -- Runtime dependency validation diff --git a/docs/configuration/jasperfx-options.md b/docs/configuration/jasperfx-options.md new file mode 100644 index 0000000..717d291 --- /dev/null +++ b/docs/configuration/jasperfx-options.md @@ -0,0 +1,70 @@ +# JasperFx Options + +`JasperFxOptions` is the central configuration class for JasperFx. It extends `SystemPartBase` and participates in the describe command output. + +## Registering Options + + + +```cs +public static void ConfigureOptions(IServiceCollection services) +{ + services.AddJasperFx(opts => + { + // Register an environment check inline + opts.RegisterEnvironmentCheck( + "Database connectivity", + async (sp, ct) => + { + // Verify your database is accessible + await Task.CompletedTask; + }); + }); +} +``` +snippet source | anchor + + +## Key Properties + +| Property | Type | Default | Description | +|----------|------|---------|-------------| +| `ActiveProfile` | `string` | `"Development"` | The current application profile | +| `RequiredFiles` | `string[]` | `[]` | Files that must exist at startup | +| `RememberedApplicationAssembly` | `Assembly?` | `null` | Override the detected application assembly | + +## RequireFile + +Tell JasperFx that a file path is required. This adds a file-exists check to environment tests: + +```csharp +opts.RequireFile("appsettings.json"); +``` + +## RegisterEnvironmentCheck + +Register an inline environment check: + +```csharp +opts.RegisterEnvironmentCheck( + "Redis is reachable", + async (sp, ct) => + { + // throw on failure + }); +``` + +## Application Assembly Detection + +JasperFx automatically detects the main application assembly for scanning. In test scenarios, you can override this: + +```csharp +JasperFxOptions.RememberedApplicationAssembly = typeof(MyApp).Assembly; +``` + +This is useful when test runners or IDEs change the entry assembly. + +## Next Steps + +- [Critter Stack Defaults](/configuration/critter-stack-defaults) -- Opinionated setup +- [Environment Checks](/cli/environment-checks) -- Startup validation diff --git a/docs/extensions/enumerable-extensions.md b/docs/extensions/enumerable-extensions.md new file mode 100644 index 0000000..3eff127 --- /dev/null +++ b/docs/extensions/enumerable-extensions.md @@ -0,0 +1,68 @@ +# Enumerable Extensions + +JasperFx.Core provides extension methods for working with collections and enumerables. + +## Usage + +```csharp +using JasperFx.Core; +``` + +## Examples + + + +```cs +public void EnumerableHelpers() +{ + var items = new List { "a", "b", "c", "a" }; + + // AddRange that works on IList + items.Fill("d"); + + // Add only if not already present + items.Fill("a"); // no-op if already present + + // Each / EachAsync for side effects + items.Each(item => Console.WriteLine(item)); +} +``` +snippet source | anchor + + +## Available Methods + +| Method | Description | +|--------|-------------| +| `Fill(item)` | Adds an item to a list (alias for `Add`) | +| `FillWithUnique(item)` | Adds only if the item is not already in the list | +| `Each(action)` | Executes an action for each item | +| `EachAsync(func)` | Executes an async function for each item sequentially | +| `AddRange(items)` | Adds multiple items to an `IList` | +| `IsEmpty()` | Returns true if the enumerable has no elements | +| `Top(n)` | Returns the first N items | +| `As()` | Casts each element to type T | + +## Fill vs Add + +`Fill` is semantically equivalent to `Add` but reads better in fluent chains. `FillWithUnique` is useful for building distinct collections without using `HashSet`: + +```csharp +var tags = new List(); +tags.FillWithUnique("dotnet"); +tags.FillWithUnique("dotnet"); // no duplicate added +``` + +## Each vs ForEach + +`Each` works on any `IEnumerable`, not just `List`: + +```csharp +IEnumerable items = GetItems(); +items.Each(item => Process(item)); +``` + +## Next Steps + +- [String Extensions](/extensions/string-extensions) +- [Reflection Extensions](/extensions/reflection-extensions) diff --git a/docs/extensions/index.md b/docs/extensions/index.md new file mode 100644 index 0000000..7e10514 --- /dev/null +++ b/docs/extensions/index.md @@ -0,0 +1,46 @@ +# Utility Extensions + +JasperFx.Core provides a collection of extension methods used throughout the Critter Stack. These are general-purpose helpers available in any .NET project. + +## Installation + +If you only need the extensions without the full JasperFx framework: + +```bash +dotnet add package JasperFx.Core +``` + +## Categories + +### String Extensions + +Helpers for case conversion, empty checks, joining, and common string operations. + +[Read more](/extensions/string-extensions) + +### Enumerable Extensions + +Methods for working with collections including `Fill`, `Each`, and `AddRange` variants. + +[Read more](/extensions/enumerable-extensions) + +### Reflection Extensions + +Type inspection helpers for checking interface implementation, generating readable type names, and working with generics. + +[Read more](/extensions/reflection-extensions) + +## Namespace + +All extension methods live in the `JasperFx.Core` or `JasperFx.Core.Reflection` namespaces: + +```csharp +using JasperFx.Core; +using JasperFx.Core.Reflection; +``` + +## Next Steps + +- [String Extensions](/extensions/string-extensions) +- [Enumerable Extensions](/extensions/enumerable-extensions) +- [Reflection Extensions](/extensions/reflection-extensions) diff --git a/docs/extensions/reflection-extensions.md b/docs/extensions/reflection-extensions.md new file mode 100644 index 0000000..4c70b3c --- /dev/null +++ b/docs/extensions/reflection-extensions.md @@ -0,0 +1,68 @@ +# Reflection Extensions + +JasperFx.Core.Reflection provides helpers for type inspection, generic type manipulation, and readable type name generation. + +## Usage + +```csharp +using JasperFx.Core.Reflection; +``` + +## Examples + + + +```cs +public void ReflectionHelpers() +{ + // Check if a type implements an interface + var implements = typeof(List).CanBeCastTo>(); + + // Get a human-readable type name + var name = typeof(Dictionary).FullNameInCode(); + + // Close an open generic type + var closed = typeof(List<>).CloseAndBuildAs(typeof(string)); +} +``` +snippet source | anchor + + +## Available Methods + +| Method | Description | +|--------|-------------| +| `Implements()` | Checks if a type implements an interface or base class | +| `Implements(type)` | Non-generic overload of the above | +| `FullNameInCode()` | Returns a C#-readable full type name with generics | +| `NameInCode()` | Returns a short C#-readable type name | +| `CloseAndBuildAs(params)` | Closes an open generic and creates an instance | +| `HasAttribute()` | Checks if a member has a specific attribute | +| `GetAttribute()` | Gets a specific attribute from a member | +| `IsConcreteTypeOf()` | Checks if a type is a non-abstract implementation | + +## Readable Type Names + +`FullNameInCode()` produces names that look like actual C# code: + +```csharp +typeof(int).FullNameInCode(); // "int" +typeof(string[]).FullNameInCode(); // "string[]" +typeof(Dictionary).FullNameInCode(); // "System.Collections.Generic.Dictionary" +typeof(int?).FullNameInCode(); // "int?" +``` + +## Closing Open Generics + +`CloseAndBuildAs` is useful for plugin architectures: + +```csharp +// Given: public class Repository : IRepository { } +var repo = typeof(Repository<>) + .CloseAndBuildAs>(typeof(Order)); +``` + +## Next Steps + +- [String Extensions](/extensions/string-extensions) +- [Enumerable Extensions](/extensions/enumerable-extensions) diff --git a/docs/extensions/string-extensions.md b/docs/extensions/string-extensions.md new file mode 100644 index 0000000..7fa0896 --- /dev/null +++ b/docs/extensions/string-extensions.md @@ -0,0 +1,60 @@ +# String Extensions + +JasperFx.Core provides several extension methods for common string operations. + +## Usage + +```csharp +using JasperFx.Core; +``` + +## Examples + + + +```cs +public void StringHelpers() +{ + // Convert to camel case + var camel = "SomePropertyName".ToCamelCase(); + // => "somePropertyName" + + // Check if a string is empty or whitespace + var isEmpty = "".IsEmpty(); + var isNotEmpty = "hello".IsNotEmpty(); + + // Joining strings + var joined = new[] { "one", "two", "three" }.Join(", "); +} +``` +snippet source | anchor + + +## Available Methods + +| Method | Description | +|--------|-------------| +| `ToCamelCase()` | Converts PascalCase to camelCase | +| `IsEmpty()` | Returns true if the string is null, empty, or whitespace | +| `IsNotEmpty()` | Inverse of `IsEmpty()` | +| `Join(separator)` | Joins an enumerable of strings with a separator | +| `ToDelimitedString(delimiter)` | Converts a collection to a delimited string | +| `EqualsIgnoreCase(other)` | Case-insensitive string comparison | +| `Matches(pattern)` | Regex match helper | +| `SplitOnNewLine()` | Splits on `\n` and `\r\n` | +| `ToFullPath()` | Resolves a relative path to a full filesystem path | + +## Null Safety + +Most string extensions handle null input gracefully: + +```csharp +string? value = null; +value.IsEmpty(); // true +value.IsNotEmpty(); // false +``` + +## Next Steps + +- [Enumerable Extensions](/extensions/enumerable-extensions) +- [Reflection Extensions](/extensions/reflection-extensions) diff --git a/docs/guide/index.md b/docs/guide/index.md new file mode 100644 index 0000000..e1d80fd --- /dev/null +++ b/docs/guide/index.md @@ -0,0 +1,31 @@ +# Introduction + +JasperFx is the shared infrastructure library that underpins the Critter Stack family of .NET libraries, including [Marten](https://martendb.io) and [Wolverine](https://wolverine.netlify.app). + +## What Does JasperFx Provide? + +JasperFx gives you: + +- **Command line tooling** -- A lightweight framework for building CLI commands with argument parsing, flag support, and automatic help generation. +- **Environment checks** -- Register checks that run at application startup to verify external dependencies are available. +- **Describe command** -- A built-in command that outputs a summary of your application's configuration and registered components. +- **Configuration** -- `JasperFxOptions` and Critter Stack defaults for consistent application setup. +- **Utility extensions** -- String, enumerable, and reflection helpers used throughout the Critter Stack. + +## Target Frameworks + +JasperFx targets .NET 8.0, 9.0, and 10.0. + +## Source Code + +The source code is available on [GitHub](https://github.com/JasperFx/jasperfx). + +## Getting Help + +File issues on the [GitHub issue tracker](https://github.com/JasperFx/jasperfx/issues) or join the [Critter Stack Discord](https://discord.gg/WMxrvegf8H). + +## Next Steps + +- [Installation](/guide/installation) -- Add JasperFx to your project +- [Quick Start](/guide/quickstart) -- Get running in minutes +- [CLI Commands](/cli/) -- Build custom commands diff --git a/docs/guide/installation.md b/docs/guide/installation.md new file mode 100644 index 0000000..4965f02 --- /dev/null +++ b/docs/guide/installation.md @@ -0,0 +1,47 @@ +# Installation + +## NuGet Package + +Install the main JasperFx package from NuGet: + +```bash +dotnet add package JasperFx +``` + +This brings in the core library including command line tooling, environment checks, and configuration support. + +## Core Extensions Only + +If you only need the utility extension methods (string, enumerable, reflection), you can install the lighter-weight core package: + +```bash +dotnet add package JasperFx.Core +``` + +## Prerequisites + +- .NET 8.0 SDK or later +- A `Microsoft.Extensions.Hosting` compatible application (for CLI and environment check features) + +## Verifying Installation + +After installing, verify the package is available by adding JasperFx to your host builder: + +```csharp +using Microsoft.Extensions.Hosting; + +await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions(args); +``` + +Run your application with the `help` command to see available commands: + +```bash +dotnet run -- help +``` + +## Next Steps + +- [Quick Start](/guide/quickstart) -- Wire up JasperFx in a minimal application +- [CLI Commands](/cli/) -- Learn about the command line framework diff --git a/docs/guide/quickstart.md b/docs/guide/quickstart.md new file mode 100644 index 0000000..6280ae9 --- /dev/null +++ b/docs/guide/quickstart.md @@ -0,0 +1,84 @@ +# Quick Start + +Get a JasperFx-enabled application running in under a minute. + +## Minimal Setup + +Create a new console application and install JasperFx: + +```bash +dotnet new console -n MyApp +cd MyApp +dotnet add package JasperFx +``` + +Replace the contents of `Program.cs`: + + + +```cs +await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); +``` +snippet source | anchor + + +## Running Commands + +With this setup you immediately get access to built-in commands: + +```bash +# Show all available commands +dotnet run -- help + +# Describe the application configuration +dotnet run -- describe + +# Run environment checks +dotnet run -- check-env +``` + +## Adding Custom Commands + +You can register your own commands by creating classes that extend `JasperFxCommand` or `JasperFxAsyncCommand`. See [Writing Commands](/cli/writing-commands) for details. + +## Adding Environment Checks + +Register checks to verify your application's external dependencies at startup: + + + +```cs +public static void RegisterChecks(IServiceCollection services) +{ + // Async check with IServiceProvider access + services.CheckEnvironment( + "Database is reachable", + async (IServiceProvider sp, CancellationToken ct) => + { + // Throw an exception to indicate failure + await Task.CompletedTask; + }); + + // Synchronous check + services.CheckEnvironment( + "Configuration file exists", + (IServiceProvider sp) => + { + if (!File.Exists("appsettings.json")) + { + throw new FileNotFoundException("Missing configuration file"); + } + }); +} +``` +snippet source | anchor + + +## What Next? + +- [Writing Commands](/cli/writing-commands) -- Create custom CLI commands +- [Environment Checks](/cli/environment-checks) -- Validate your runtime environment +- [Configuration](/configuration/critter-stack-defaults) -- Configure JasperFx options diff --git a/docs/index.md b/docs/index.md new file mode 100644 index 0000000..c94cb03 --- /dev/null +++ b/docs/index.md @@ -0,0 +1,29 @@ +--- +layout: home + +hero: + name: JasperFx + text: Shared Infrastructure for the Critter Stack + tagline: Command line tooling, configuration, environment checks, and utility extensions for .NET applications + actions: + - theme: brand + text: Get Started + link: /guide/quickstart + - theme: alt + text: View on GitHub + link: https://github.com/JasperFx/jasperfx + +features: + - title: Command Line Tooling + details: Build robust CLI commands with argument parsing, flags, and built-in help generation. + link: /cli/ + - title: Environment Checks + details: Register startup checks to verify database connectivity, required files, and service availability. + link: /cli/environment-checks + - title: Configuration + details: Opinionated defaults and options for the Critter Stack ecosystem including Wolverine and Marten. + link: /configuration/critter-stack-defaults + - title: Utility Extensions + details: Helpful extension methods for strings, enumerables, and reflection used across the Critter Stack. + link: /extensions/ +--- diff --git a/docs/package.json b/docs/package.json new file mode 100644 index 0000000..c6e84bc --- /dev/null +++ b/docs/package.json @@ -0,0 +1,15 @@ +{ + "name": "jasperfx-docs", + "private": true, + "type": "module", + "scripts": { + "dev": "vitepress dev", + "build": "vitepress build", + "preview": "vitepress preview" + }, + "devDependencies": { + "vitepress": "^1.6.3", + "vitepress-plugin-mermaid": "^2.0.17", + "mermaid": "^11.4.1" + } +} diff --git a/docs/public/jasperfx-logo.png b/docs/public/jasperfx-logo.png new file mode 100644 index 0000000..3c25f0a Binary files /dev/null and b/docs/public/jasperfx-logo.png differ diff --git a/mdsnippets.json b/mdsnippets.json new file mode 100644 index 0000000..0940249 --- /dev/null +++ b/mdsnippets.json @@ -0,0 +1,8 @@ +{ + "Convention": "InPlaceOverwrite", + "LinkFormat": "GitHub", + "UrlPrefix": "https://github.com/JasperFx/jasperfx/blob/master", + "ExcludeMarkdownDirectories": [], + "ExcludeSnippetDirectories": [], + "TreatMissingAsWarning": false +} diff --git a/netlify.toml b/netlify.toml new file mode 100644 index 0000000..1d962cd --- /dev/null +++ b/netlify.toml @@ -0,0 +1,7 @@ +[build] + base = "docs" + publish = ".vitepress/dist" + command = "npm install && npm run build" + +[build.environment] + NODE_VERSION = "20" diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..001117f --- /dev/null +++ b/package-lock.json @@ -0,0 +1,3936 @@ +{ + "name": "jasperfx", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "devDependencies": { + "concurrently": "^9.1.2", + "mermaid": "^11.4.1", + "vitepress": "^1.6.3", + "vitepress-plugin-mermaid": "^2.0.17" + } + }, + "node_modules/@algolia/abtesting": { + "version": "1.16.1", + "resolved": "https://registry.npmjs.org/@algolia/abtesting/-/abtesting-1.16.1.tgz", + "integrity": "sha512-Xxk4l00pYI+jE0PNw8y0MvsQWh5278WRtZQav8/BMMi3HKi2xmeuqe11WJ3y8/6nuBHdv39w76OpJb09TMfAVQ==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/autocomplete-core": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-core/-/autocomplete-core-1.17.7.tgz", + "integrity": "sha512-BjiPOW6ks90UKl7TwMv7oNQMnzU+t/wk9mgIDi6b1tXpUek7MW0lbNOUHpvam9pe3lVCf4xPFT+lK7s+e+fs7Q==", + "dev": true, + "dependencies": { + "@algolia/autocomplete-plugin-algolia-insights": "1.17.7", + "@algolia/autocomplete-shared": "1.17.7" + } + }, + "node_modules/@algolia/autocomplete-plugin-algolia-insights": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-plugin-algolia-insights/-/autocomplete-plugin-algolia-insights-1.17.7.tgz", + "integrity": "sha512-Jca5Ude6yUOuyzjnz57og7Et3aXjbwCSDf/8onLHSQgw1qW3ALl9mrMWaXb5FmPVkV3EtkD2F/+NkT6VHyPu9A==", + "dev": true, + "dependencies": { + "@algolia/autocomplete-shared": "1.17.7" + }, + "peerDependencies": { + "search-insights": ">= 1 < 3" + } + }, + "node_modules/@algolia/autocomplete-preset-algolia": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-preset-algolia/-/autocomplete-preset-algolia-1.17.7.tgz", + "integrity": "sha512-ggOQ950+nwbWROq2MOCIL71RE0DdQZsceqrg32UqnhDz8FlO9rL8ONHNsI2R1MH0tkgVIDKI/D0sMiUchsFdWA==", + "dev": true, + "dependencies": { + "@algolia/autocomplete-shared": "1.17.7" + }, + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/autocomplete-shared": { + "version": "1.17.7", + "resolved": "https://registry.npmjs.org/@algolia/autocomplete-shared/-/autocomplete-shared-1.17.7.tgz", + "integrity": "sha512-o/1Vurr42U/qskRSuhBH+VKxMvkkUVTLU6WZQr+L5lGZZLYWyhdzWjW0iGXY7EkwRTjBqvN2EsR81yCTGV/kmg==", + "dev": true, + "peerDependencies": { + "@algolia/client-search": ">= 4.9.1 < 6", + "algoliasearch": ">= 4.9.1 < 6" + } + }, + "node_modules/@algolia/client-abtesting": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-abtesting/-/client-abtesting-5.50.1.tgz", + "integrity": "sha512-4peZlPXMwTOey9q1rQKMdCnwZb/E95/1e+7KujXpLLSh0FawJzg//U2NM+r4AiJy4+naT2MTBhj0K30yshnVTA==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-analytics": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-analytics/-/client-analytics-5.50.1.tgz", + "integrity": "sha512-i+aWHHG8NZvGFHtPeMZkxL2Loc6Fm7iaRo15lYSMx8gFL+at9vgdWxhka7mD1fqxkrxXsQstUBCIsSY8FvkEOw==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-common": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-common/-/client-common-5.50.1.tgz", + "integrity": "sha512-Hw52Fwapyk/7hMSV/fI4+s3H9MGZEUcRh4VphyXLAk2oLYdndVUkc6KBi0zwHSzwPAr+ZBwFPe2x6naUt9mZGw==", + "dev": true, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-insights": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-insights/-/client-insights-5.50.1.tgz", + "integrity": "sha512-Bn/wtwhJ7p1OD/6pY+Zzn+zlu2N/SJnH46md/PAbvqIzmjVuwjNwD4y0vV5Ov8naeukXdd7UU9v550+v8+mtlg==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-personalization": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-personalization/-/client-personalization-5.50.1.tgz", + "integrity": "sha512-0V4Tu0RWR8YxkgI9EPVOZHGE4K5pEIhkLNN0CTkP/rnPsqaaSQpNMYW3/mGWdiKOWbX0iVmwLB9QESk3H0jS5g==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-query-suggestions": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-query-suggestions/-/client-query-suggestions-5.50.1.tgz", + "integrity": "sha512-jofcWNYMXJDDr87Z2eivlWY6o71Zn7F7aOvQCXSDAo9QTlyf7BhXEsZymLUvF0O1yU9Q9wvrjAWn8uVHYnAvgw==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/client-search": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/client-search/-/client-search-5.50.1.tgz", + "integrity": "sha512-OteRb8WubcmEvU0YlMJwCXs3Q6xrdkb0v50/qZBJP1TF0CvujFZQM++9BjEkTER/Jr9wbPHvjSFKnbMta0b4dQ==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/ingestion": { + "version": "1.50.1", + "resolved": "https://registry.npmjs.org/@algolia/ingestion/-/ingestion-1.50.1.tgz", + "integrity": "sha512-0GmfSgDQK6oiIVXnJvGxtNFOfosBspRTR7csCOYCTL1P8QtxX2vDCIKwTM7xdSAEbJaZ43QlWg25q0Qdsndz8Q==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/monitoring": { + "version": "1.50.1", + "resolved": "https://registry.npmjs.org/@algolia/monitoring/-/monitoring-1.50.1.tgz", + "integrity": "sha512-ySuigKEe4YjYV3si8NVk9BHQpFj/1B+ON7DhhvTvbrZJseHQQloxzq0yHwKmznSdlO6C956fx4pcfOKkZClsyg==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/recommend": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/recommend/-/recommend-5.50.1.tgz", + "integrity": "sha512-Cp8T/B0gVmjFlzzp6eP47hwKh5FGyeqQp1N48/ANDdvdiQkPqLyFHQVDwLBH0LddfIPQE+yqmZIgmKc82haF4A==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-browser-xhr": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-browser-xhr/-/requester-browser-xhr-5.50.1.tgz", + "integrity": "sha512-XKdGGLikfrlK66ZSXh/vWcXZZ8Vg3byDFbJD8pwEvN1FoBRGxhxya476IY2ohoTymLa4qB5LBRlIa+2TLHx3Uw==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-fetch": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-fetch/-/requester-fetch-5.50.1.tgz", + "integrity": "sha512-mBAU6WyVsDwhHyGM+nodt1/oebHxgvuLlOAoMGbj/1i6LygDHZWDgL1t5JEs37x9Aywv7ZGhqbM1GsfZ54sU6g==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@algolia/requester-node-http": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/@algolia/requester-node-http/-/requester-node-http-5.50.1.tgz", + "integrity": "sha512-qmo1LXrNKLHvJE6mdQbLnsZAoZvj7VyF2ft4xmbSGWI2WWm87fx/CjUX4kEExt4y0a6T6nEts6ofpUfH5TEE1A==", + "dev": true, + "dependencies": { + "@algolia/client-common": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/@antfu/install-pkg": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@antfu/install-pkg/-/install-pkg-1.1.0.tgz", + "integrity": "sha512-MGQsmw10ZyI+EJo45CdSER4zEb+p31LpDAFp2Z3gkSd1yqVZGi0Ebx++YTEMonJy4oChEMLsxZ64j8FH6sSqtQ==", + "dev": true, + "dependencies": { + "package-manager-detector": "^1.3.0", + "tinyexec": "^1.0.1" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.27.1", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.27.1.tgz", + "integrity": "sha512-qMlSxKbpRlAridDExk92nSobyDdpPijUq2DW6oDnUqd0iOGxmQjyqhMIihI9+zv4LPyZdRje2cavWPbCbWm3eA==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.28.5", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.28.5.tgz", + "integrity": "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q==", + "dev": true, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.2", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.2.tgz", + "integrity": "sha512-4GgRzy/+fsBa72/RZVJmGKPmZu9Byn8o4MoLpmNe1m8ZfYnz5emHLQz3U4gLud6Zwl0RZIcgiLD7Uq7ySFuDLA==", + "dev": true, + "dependencies": { + "@babel/types": "^7.29.0" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.0", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.0.tgz", + "integrity": "sha512-LwdZHpScM4Qz8Xw2iKSzS+cfglZzJGvofQICy7W7v4caru4EaAmyUuO6BGrbyQ2mYV11W0U8j5mBhd14dd3B0A==", + "dev": true, + "dependencies": { + "@babel/helper-string-parser": "^7.27.1", + "@babel/helper-validator-identifier": "^7.28.5" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@braintree/sanitize-url": { + "version": "7.1.2", + "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-7.1.2.tgz", + "integrity": "sha512-jigsZK+sMF/cuiB7sERuo9V7N9jx+dhmHHnQyDSVdpZwVutaBu7WvNYqMDLSgFgfB30n452TP3vjDAvFC973mA==", + "dev": true + }, + "node_modules/@chevrotain/cst-dts-gen": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/cst-dts-gen/-/cst-dts-gen-11.1.2.tgz", + "integrity": "sha512-XTsjvDVB5nDZBQB8o0o/0ozNelQtn2KrUVteIHSlPd2VAV2utEb6JzyCJaJ8tGxACR4RiBNWy5uYUHX2eji88Q==", + "dev": true, + "dependencies": { + "@chevrotain/gast": "11.1.2", + "@chevrotain/types": "11.1.2", + "lodash-es": "4.17.23" + } + }, + "node_modules/@chevrotain/cst-dts-gen/node_modules/lodash-es": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz", + "integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==", + "dev": true + }, + "node_modules/@chevrotain/gast": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/gast/-/gast-11.1.2.tgz", + "integrity": "sha512-Z9zfXR5jNZb1Hlsd/p+4XWeUFugrHirq36bKzPWDSIacV+GPSVXdk+ahVWZTwjhNwofAWg/sZg58fyucKSQx5g==", + "dev": true, + "dependencies": { + "@chevrotain/types": "11.1.2", + "lodash-es": "4.17.23" + } + }, + "node_modules/@chevrotain/gast/node_modules/lodash-es": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz", + "integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==", + "dev": true + }, + "node_modules/@chevrotain/regexp-to-ast": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/regexp-to-ast/-/regexp-to-ast-11.1.2.tgz", + "integrity": "sha512-nMU3Uj8naWer7xpZTYJdxbAs6RIv/dxYzkYU8GSwgUtcAAlzjcPfX1w+RKRcYG8POlzMeayOQ/znfwxEGo5ulw==", + "dev": true + }, + "node_modules/@chevrotain/types": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/types/-/types-11.1.2.tgz", + "integrity": "sha512-U+HFai5+zmJCkK86QsaJtoITlboZHBqrVketcO2ROv865xfCMSFpELQoz1GkX5GzME8pTa+3kbKrZHQtI0gdbw==", + "dev": true + }, + "node_modules/@chevrotain/utils": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/@chevrotain/utils/-/utils-11.1.2.tgz", + "integrity": "sha512-4mudFAQ6H+MqBTfqLmU7G1ZwRzCLfJEooL/fsF6rCX5eePMbGhoy5n4g+G4vlh2muDcsCTJtL+uKbOzWxs5LHA==", + "dev": true + }, + "node_modules/@docsearch/css": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.8.2.tgz", + "integrity": "sha512-y05ayQFyUmCXze79+56v/4HpycYF3uFqB78pLPrSV5ZKAlDuIAAJNhaRi8tTdRNXh05yxX/TyNnzD6LwSM89vQ==", + "dev": true + }, + "node_modules/@docsearch/js": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/js/-/js-3.8.2.tgz", + "integrity": "sha512-Q5wY66qHn0SwA7Taa0aDbHiJvaFJLOJyHmooQ7y8hlwwQLQ/5WwCcoX0g7ii04Qi2DJlHsd0XXzJ8Ypw9+9YmQ==", + "dev": true, + "dependencies": { + "@docsearch/react": "3.8.2", + "preact": "^10.0.0" + } + }, + "node_modules/@docsearch/react": { + "version": "3.8.2", + "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.8.2.tgz", + "integrity": "sha512-xCRrJQlTt8N9GU0DG4ptwHRkfnSnD/YpdeaXe02iKfqs97TkZJv60yE+1eq/tjPcVnTW8dP5qLP7itifFVV5eg==", + "dev": true, + "dependencies": { + "@algolia/autocomplete-core": "1.17.7", + "@algolia/autocomplete-preset-algolia": "1.17.7", + "@docsearch/css": "3.8.2", + "algoliasearch": "^5.14.2" + }, + "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/@esbuild/aix-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.21.5.tgz", + "integrity": "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "aix" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.21.5.tgz", + "integrity": "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.21.5.tgz", + "integrity": "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/android-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.21.5.tgz", + "integrity": "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.21.5.tgz", + "integrity": "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/darwin-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.21.5.tgz", + "integrity": "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.21.5.tgz", + "integrity": "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/freebsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.21.5.tgz", + "integrity": "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.21.5.tgz", + "integrity": "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.21.5.tgz", + "integrity": "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.21.5.tgz", + "integrity": "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-loong64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.21.5.tgz", + "integrity": "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-mips64el": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.21.5.tgz", + "integrity": "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg==", + "cpu": [ + "mips64el" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-ppc64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.21.5.tgz", + "integrity": "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-riscv64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.21.5.tgz", + "integrity": "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-s390x": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.21.5.tgz", + "integrity": "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/linux-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.21.5.tgz", + "integrity": "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/netbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.21.5.tgz", + "integrity": "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "netbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/openbsd-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.21.5.tgz", + "integrity": "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/sunos-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.21.5.tgz", + "integrity": "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "sunos" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-arm64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.21.5.tgz", + "integrity": "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-ia32": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.21.5.tgz", + "integrity": "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@esbuild/win32-x64": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.21.5.tgz", + "integrity": "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">=12" + } + }, + "node_modules/@iconify-json/simple-icons": { + "version": "1.2.76", + "resolved": "https://registry.npmjs.org/@iconify-json/simple-icons/-/simple-icons-1.2.76.tgz", + "integrity": "sha512-lLRlA8yaf+1L5VCPRvR9lynoSklsddKHEylchmZJKdj/q2xVQ1ZAEJ8SCQlv9cbgtMefnlyM98U+8Si2aoFZPA==", + "dev": true, + "dependencies": { + "@iconify/types": "*" + } + }, + "node_modules/@iconify/types": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@iconify/types/-/types-2.0.0.tgz", + "integrity": "sha512-+wluvCrRhXrhyOmRDJ3q8mux9JkKy5SJ/v8ol2tu4FVjyYvtEzkc/3pK15ET6RKg4b4w4BmTk1+gsCUhf21Ykg==", + "dev": true + }, + "node_modules/@iconify/utils": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@iconify/utils/-/utils-3.1.0.tgz", + "integrity": "sha512-Zlzem1ZXhI1iHeeERabLNzBHdOa4VhQbqAcOQaMKuTuyZCpwKbC2R4Dd0Zo3g9EAc+Y4fiarO8HIHRAth7+skw==", + "dev": true, + "dependencies": { + "@antfu/install-pkg": "^1.1.0", + "@iconify/types": "^2.0.0", + "mlly": "^1.8.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "dev": true + }, + "node_modules/@mermaid-js/mermaid-mindmap": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mermaid-js/mermaid-mindmap/-/mermaid-mindmap-9.3.0.tgz", + "integrity": "sha512-IhtYSVBBRYviH1Ehu8gk69pMDF8DSRqXBRDMWrEfHoaMruHeaP2DXA3PBnuwsMaCdPQhlUUcy/7DBLAEIXvCAw==", + "dev": true, + "optional": true, + "dependencies": { + "@braintree/sanitize-url": "^6.0.0", + "cytoscape": "^3.23.0", + "cytoscape-cose-bilkent": "^4.1.0", + "cytoscape-fcose": "^2.1.0", + "d3": "^7.0.0", + "khroma": "^2.0.0", + "non-layered-tidy-tree-layout": "^2.0.2" + } + }, + "node_modules/@mermaid-js/mermaid-mindmap/node_modules/@braintree/sanitize-url": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@braintree/sanitize-url/-/sanitize-url-6.0.4.tgz", + "integrity": "sha512-s3jaWicZd0pkP0jf5ysyHUI/RE7MHos6qlToFcGWXVp+ykHOy77OUMrfbgJ9it2C5bow7OIQwYYaHjk9XlBQ2A==", + "dev": true, + "optional": true + }, + "node_modules/@mermaid-js/parser": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/@mermaid-js/parser/-/parser-1.1.0.tgz", + "integrity": "sha512-gxK9ZX2+Fex5zu8LhRQoMeMPEHbc73UKZ0FQ54YrQtUxE1VVhMwzeNtKRPAu5aXks4FasbMe4xB4bWrmq6Jlxw==", + "dev": true, + "dependencies": { + "langium": "^4.0.0" + } + }, + "node_modules/@rollup/rollup-android-arm-eabi": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.60.1.tgz", + "integrity": "sha512-d6FinEBLdIiK+1uACUttJKfgZREXrF0Qc2SmLII7W2AD8FfiZ9Wjd+rD/iRuf5s5dWrr1GgwXCvPqOuDquOowA==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-android-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.60.1.tgz", + "integrity": "sha512-YjG/EwIDvvYI1YvYbHvDz/BYHtkY4ygUIXHnTdLhG+hKIQFBiosfWiACWortsKPKU/+dUwQQCKQM3qrDe8c9BA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "android" + ] + }, + "node_modules/@rollup/rollup-darwin-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.1.tgz", + "integrity": "sha512-mjCpF7GmkRtSJwon+Rq1N8+pI+8l7w5g9Z3vWj4T7abguC4Czwi3Yu/pFaLvA3TTeMVjnu3ctigusqWUfjZzvw==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-darwin-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.60.1.tgz", + "integrity": "sha512-haZ7hJ1JT4e9hqkoT9R/19XW2QKqjfJVv+i5AGg57S+nLk9lQnJ1F/eZloRO3o9Scy9CM3wQ9l+dkXtcBgN5Ew==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "darwin" + ] + }, + "node_modules/@rollup/rollup-freebsd-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.60.1.tgz", + "integrity": "sha512-czw90wpQq3ZsAVBlinZjAYTKduOjTywlG7fEeWKUA7oCmpA8xdTkxZZlwNJKWqILlq0wehoZcJYfBvOyhPTQ6w==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-freebsd-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.60.1.tgz", + "integrity": "sha512-KVB2rqsxTHuBtfOeySEyzEOB7ltlB/ux38iu2rBQzkjbwRVlkhAGIEDiiYnO2kFOkJp+Z7pUXKyrRRFuFUKt+g==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "freebsd" + ] + }, + "node_modules/@rollup/rollup-linux-arm-gnueabihf": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.60.1.tgz", + "integrity": "sha512-L+34Qqil+v5uC0zEubW7uByo78WOCIrBvci69E7sFASRl0X7b/MB6Cqd1lky/CtcSVTydWa2WZwFuWexjS5o6g==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm-musleabihf": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.60.1.tgz", + "integrity": "sha512-n83O8rt4v34hgFzlkb1ycniJh7IR5RCIqt6mz1VRJD6pmhRi0CXdmfnLu9dIUS6buzh60IvACM842Ffb3xd6Gg==", + "cpu": [ + "arm" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.60.1.tgz", + "integrity": "sha512-Nql7sTeAzhTAja3QXeAI48+/+GjBJ+QmAH13snn0AJSNL50JsDqotyudHyMbO2RbJkskbMbFJfIJKWA6R1LCJQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-arm64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.60.1.tgz", + "integrity": "sha512-+pUymDhd0ys9GcKZPPWlFiZ67sTWV5UU6zOJat02M1+PiuSGDziyRuI/pPue3hoUwm2uGfxdL+trT6Z9rxnlMA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-gnu/-/rollup-linux-loong64-gnu-4.60.1.tgz", + "integrity": "sha512-VSvgvQeIcsEvY4bKDHEDWcpW4Yw7BtlKG1GUT4FzBUlEKQK0rWHYBqQt6Fm2taXS+1bXvJT6kICu5ZwqKCnvlQ==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-loong64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loong64-musl/-/rollup-linux-loong64-musl-4.60.1.tgz", + "integrity": "sha512-4LqhUomJqwe641gsPp6xLfhqWMbQV04KtPp7/dIp0nzPxAkNY1AbwL5W0MQpcalLYk07vaW9Kp1PBhdpZYYcEw==", + "cpu": [ + "loong64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-gnu/-/rollup-linux-ppc64-gnu-4.60.1.tgz", + "integrity": "sha512-tLQQ9aPvkBxOc/EUT6j3pyeMD6Hb8QF2BTBnCQWP/uu1lhc9AIrIjKnLYMEroIz/JvtGYgI9dF3AxHZNaEH0rw==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-ppc64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-ppc64-musl/-/rollup-linux-ppc64-musl-4.60.1.tgz", + "integrity": "sha512-RMxFhJwc9fSXP6PqmAz4cbv3kAyvD1etJFjTx4ONqFP9DkTkXsAMU4v3Vyc5BgzC+anz7nS/9tp4obsKfqkDHg==", + "cpu": [ + "ppc64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.60.1.tgz", + "integrity": "sha512-QKgFl+Yc1eEk6MmOBfRHYF6lTxiiiV3/z/BRrbSiW2I7AFTXoBFvdMEyglohPj//2mZS4hDOqeB0H1ACh3sBbg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-riscv64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-musl/-/rollup-linux-riscv64-musl-4.60.1.tgz", + "integrity": "sha512-RAjXjP/8c6ZtzatZcA1RaQr6O1TRhzC+adn8YZDnChliZHviqIjmvFwHcxi4JKPSDAt6Uhf/7vqcBzQJy0PDJg==", + "cpu": [ + "riscv64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-s390x-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.60.1.tgz", + "integrity": "sha512-wcuocpaOlaL1COBYiA89O6yfjlp3RwKDeTIA0hM7OpmhR1Bjo9j31G1uQVpDlTvwxGn2nQs65fBFL5UFd76FcQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.60.1.tgz", + "integrity": "sha512-77PpsFQUCOiZR9+LQEFg9GClyfkNXj1MP6wRnzYs0EeWbPcHs02AXu4xuUbM1zhwn3wqaizle3AEYg5aeoohhg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-linux-x64-musl": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-musl/-/rollup-linux-x64-musl-4.60.1.tgz", + "integrity": "sha512-5cIATbk5vynAjqqmyBjlciMJl1+R/CwX9oLk/EyiFXDWd95KpHdrOJT//rnUl4cUcskrd0jCCw3wpZnhIHdD9w==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "linux" + ] + }, + "node_modules/@rollup/rollup-openbsd-x64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openbsd-x64/-/rollup-openbsd-x64-4.60.1.tgz", + "integrity": "sha512-cl0w09WsCi17mcmWqqglez9Gk8isgeWvoUZ3WiJFYSR3zjBQc2J5/ihSjpl+VLjPqjQ/1hJRcqBfLjssREQILw==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "openbsd" + ] + }, + "node_modules/@rollup/rollup-openharmony-arm64": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-openharmony-arm64/-/rollup-openharmony-arm64-4.60.1.tgz", + "integrity": "sha512-4Cv23ZrONRbNtbZa37mLSueXUCtN7MXccChtKpUnQNgF010rjrjfHx3QxkS2PI7LqGT5xXyYs1a7LbzAwT0iCA==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "openharmony" + ] + }, + "node_modules/@rollup/rollup-win32-arm64-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.60.1.tgz", + "integrity": "sha512-i1okWYkA4FJICtr7KpYzFpRTHgy5jdDbZiWfvny21iIKky5YExiDXP+zbXzm3dUcFpkEeYNHgQ5fuG236JPq0g==", + "cpu": [ + "arm64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-ia32-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.60.1.tgz", + "integrity": "sha512-u09m3CuwLzShA0EYKMNiFgcjjzwqtUMLmuCJLeZWjjOYA3IT2Di09KaxGBTP9xVztWyIWjVdsB2E9goMjZvTQg==", + "cpu": [ + "ia32" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-gnu": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-gnu/-/rollup-win32-x64-gnu-4.60.1.tgz", + "integrity": "sha512-k+600V9Zl1CM7eZxJgMyTUzmrmhB/0XZnF4pRypKAlAgxmedUA+1v9R+XOFv56W4SlHEzfeMtzujLJD22Uz5zg==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@rollup/rollup-win32-x64-msvc": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.60.1.tgz", + "integrity": "sha512-lWMnixq/QzxyhTV6NjQJ4SFo1J6PvOX8vUx5Wb4bBPsEb+8xZ89Bz6kOXpfXj9ak9AHTQVQzlgzBEc1SyM27xQ==", + "cpu": [ + "x64" + ], + "dev": true, + "optional": true, + "os": [ + "win32" + ] + }, + "node_modules/@shikijs/core": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/core/-/core-2.5.0.tgz", + "integrity": "sha512-uu/8RExTKtavlpH7XqnVYBrfBkUc20ngXiX9NSrBhOVZYv/7XQRKUyhtkeflY5QsxC0GbJThCerruZfsUaSldg==", + "dev": true, + "dependencies": { + "@shikijs/engine-javascript": "2.5.0", + "@shikijs/engine-oniguruma": "2.5.0", + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4", + "hast-util-to-html": "^9.0.4" + } + }, + "node_modules/@shikijs/engine-javascript": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/engine-javascript/-/engine-javascript-2.5.0.tgz", + "integrity": "sha512-VjnOpnQf8WuCEZtNUdjjwGUbtAVKuZkVQ/5cHy/tojVVRIRtlWMYVjyWhxOmIq05AlSOv72z7hRNRGVBgQOl0w==", + "dev": true, + "dependencies": { + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "oniguruma-to-es": "^3.1.0" + } + }, + "node_modules/@shikijs/engine-oniguruma": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/engine-oniguruma/-/engine-oniguruma-2.5.0.tgz", + "integrity": "sha512-pGd1wRATzbo/uatrCIILlAdFVKdxImWJGQ5rFiB5VZi2ve5xj3Ax9jny8QvkaV93btQEwR/rSz5ERFpC5mKNIw==", + "dev": true, + "dependencies": { + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2" + } + }, + "node_modules/@shikijs/langs": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/langs/-/langs-2.5.0.tgz", + "integrity": "sha512-Qfrrt5OsNH5R+5tJ/3uYBBZv3SuGmnRPejV9IlIbFH3HTGLDlkqgHymAlzklVmKBjAaVmkPkyikAV/sQ1wSL+w==", + "dev": true, + "dependencies": { + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/themes": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/themes/-/themes-2.5.0.tgz", + "integrity": "sha512-wGrk+R8tJnO0VMzmUExHR+QdSaPUl/NKs+a4cQQRWyoc3YFbUzuLEi/KWK1hj+8BfHRKm2jNhhJck1dfstJpiw==", + "dev": true, + "dependencies": { + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/transformers": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/transformers/-/transformers-2.5.0.tgz", + "integrity": "sha512-SI494W5X60CaUwgi8u4q4m4s3YAFSxln3tzNjOSYqq54wlVgz0/NbbXEb3mdLbqMBztcmS7bVTaEd2w0qMmfeg==", + "dev": true, + "dependencies": { + "@shikijs/core": "2.5.0", + "@shikijs/types": "2.5.0" + } + }, + "node_modules/@shikijs/types": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/@shikijs/types/-/types-2.5.0.tgz", + "integrity": "sha512-ygl5yhxki9ZLNuNpPitBWvcy9fsSKKaRuO4BAlMyagszQidxcpLAr0qiW/q43DtSIDxO6hEbtYLiFZNXO/hdGw==", + "dev": true, + "dependencies": { + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4" + } + }, + "node_modules/@shikijs/vscode-textmate": { + "version": "10.0.2", + "resolved": "https://registry.npmjs.org/@shikijs/vscode-textmate/-/vscode-textmate-10.0.2.tgz", + "integrity": "sha512-83yeghZ2xxin3Nj8z1NMd/NCuca+gsYXswywDy5bHvwlWL8tpTQmzGeUuHd9FC3E/SBEMvzJRwWEOz5gGes9Qg==", + "dev": true + }, + "node_modules/@types/d3": { + "version": "7.4.3", + "resolved": "https://registry.npmjs.org/@types/d3/-/d3-7.4.3.tgz", + "integrity": "sha512-lZXZ9ckh5R8uiFVt8ogUNf+pIrK4EsWrx2Np75WvF/eTpJ0FMHNhjXk8CKEx/+gpHbNQyJWehbFaTvqmHWB3ww==", + "dev": true, + "dependencies": { + "@types/d3-array": "*", + "@types/d3-axis": "*", + "@types/d3-brush": "*", + "@types/d3-chord": "*", + "@types/d3-color": "*", + "@types/d3-contour": "*", + "@types/d3-delaunay": "*", + "@types/d3-dispatch": "*", + "@types/d3-drag": "*", + "@types/d3-dsv": "*", + "@types/d3-ease": "*", + "@types/d3-fetch": "*", + "@types/d3-force": "*", + "@types/d3-format": "*", + "@types/d3-geo": "*", + "@types/d3-hierarchy": "*", + "@types/d3-interpolate": "*", + "@types/d3-path": "*", + "@types/d3-polygon": "*", + "@types/d3-quadtree": "*", + "@types/d3-random": "*", + "@types/d3-scale": "*", + "@types/d3-scale-chromatic": "*", + "@types/d3-selection": "*", + "@types/d3-shape": "*", + "@types/d3-time": "*", + "@types/d3-time-format": "*", + "@types/d3-timer": "*", + "@types/d3-transition": "*", + "@types/d3-zoom": "*" + } + }, + "node_modules/@types/d3-array": { + "version": "3.2.2", + "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.2.tgz", + "integrity": "sha512-hOLWVbm7uRza0BYXpIIW5pxfrKe0W+D5lrFiAEYR+pb6w3N2SwSMaJbXdUfSEv+dT4MfHBLtn5js0LAWaO6otw==", + "dev": true + }, + "node_modules/@types/d3-axis": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-axis/-/d3-axis-3.0.6.tgz", + "integrity": "sha512-pYeijfZuBd87T0hGn0FO1vQ/cgLk6E1ALJjfkC0oJ8cbwkZl3TpgS8bVBLZN+2jjGgg38epgxb2zmoGtSfvgMw==", + "dev": true, + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-brush": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-brush/-/d3-brush-3.0.6.tgz", + "integrity": "sha512-nH60IZNNxEcrh6L1ZSMNA28rj27ut/2ZmI3r96Zd+1jrZD++zD3LsMIjWlvg4AYrHn/Pqz4CF3veCxGjtbqt7A==", + "dev": true, + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-chord": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-chord/-/d3-chord-3.0.6.tgz", + "integrity": "sha512-LFYWWd8nwfwEmTZG9PfQxd17HbNPksHBiJHaKuY1XeqscXacsS2tyoo6OdRsjf+NQYeB6XrNL3a25E3gH69lcg==", + "dev": true + }, + "node_modules/@types/d3-color": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/@types/d3-color/-/d3-color-3.1.3.tgz", + "integrity": "sha512-iO90scth9WAbmgv7ogoq57O9YpKmFBbmoEoCHDB2xMBY0+/KVrqAaCDyCE16dUspeOvIxFFRI+0sEtqDqy2b4A==", + "dev": true + }, + "node_modules/@types/d3-contour": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-contour/-/d3-contour-3.0.6.tgz", + "integrity": "sha512-BjzLgXGnCWjUSYGfH1cpdo41/hgdWETu4YxpezoztawmqsvCeep+8QGfiY6YbDvfgHz/DkjeIkkZVJavB4a3rg==", + "dev": true, + "dependencies": { + "@types/d3-array": "*", + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-ZMaSKu4THYCU6sV64Lhg6qjf1orxBthaC161plr5KuPHo3CNm8DTHiLw/5Eq2b6TsNP0W0iJrUOFscY6Q450Hw==", + "dev": true + }, + "node_modules/@types/d3-dispatch": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dispatch/-/d3-dispatch-3.0.7.tgz", + "integrity": "sha512-5o9OIAdKkhN1QItV2oqaE5KMIiXAvDWBDPrD85e58Qlz1c1kI/J0NcqbEG88CoTwJrYe7ntUCVfeUl2UJKbWgA==", + "dev": true + }, + "node_modules/@types/d3-drag": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-drag/-/d3-drag-3.0.7.tgz", + "integrity": "sha512-HE3jVKlzU9AaMazNufooRJ5ZpWmLIoc90A37WU2JMmeq28w1FQqCZswHZ3xR+SuxYftzHq6WU6KJHvqxKzTxxQ==", + "dev": true, + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-dsv": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-dsv/-/d3-dsv-3.0.7.tgz", + "integrity": "sha512-n6QBF9/+XASqcKK6waudgL0pf/S5XHPPI8APyMLLUHd8NqouBGLsU8MgtO7NINGtPBtk9Kko/W4ea0oAspwh9g==", + "dev": true + }, + "node_modules/@types/d3-ease": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-ease/-/d3-ease-3.0.2.tgz", + "integrity": "sha512-NcV1JjO5oDzoK26oMzbILE6HW7uVXOHLQvHshBUW4UMdZGfiY6v5BeQwh9a9tCzv+CeefZQHJt5SRgK154RtiA==", + "dev": true + }, + "node_modules/@types/d3-fetch": { + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/@types/d3-fetch/-/d3-fetch-3.0.7.tgz", + "integrity": "sha512-fTAfNmxSb9SOWNB9IoG5c8Hg6R+AzUHDRlsXsDZsNp6sxAEOP0tkP3gKkNSO/qmHPoBFTxNrjDprVHDQDvo5aA==", + "dev": true, + "dependencies": { + "@types/d3-dsv": "*" + } + }, + "node_modules/@types/d3-force": { + "version": "3.0.10", + "resolved": "https://registry.npmjs.org/@types/d3-force/-/d3-force-3.0.10.tgz", + "integrity": "sha512-ZYeSaCF3p73RdOKcjj+swRlZfnYpK1EbaDiYICEEp5Q6sUiqFaFQ9qgoshp5CzIyyb/yD09kD9o2zEltCexlgw==", + "dev": true + }, + "node_modules/@types/d3-format": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-format/-/d3-format-3.0.4.tgz", + "integrity": "sha512-fALi2aI6shfg7vM5KiR1wNJnZ7r6UuggVqtDA+xiEdPZQwy/trcQaHnwShLuLdta2rTymCNpxYTiMZX/e09F4g==", + "dev": true + }, + "node_modules/@types/d3-geo": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-geo/-/d3-geo-3.1.0.tgz", + "integrity": "sha512-856sckF0oP/diXtS4jNsiQw/UuK5fQG8l/a9VVLeSouf1/PPbBE1i1W852zVwKwYCBkFJJB7nCFTbk6UMEXBOQ==", + "dev": true, + "dependencies": { + "@types/geojson": "*" + } + }, + "node_modules/@types/d3-hierarchy": { + "version": "3.1.7", + "resolved": "https://registry.npmjs.org/@types/d3-hierarchy/-/d3-hierarchy-3.1.7.tgz", + "integrity": "sha512-tJFtNoYBtRtkNysX1Xq4sxtjK8YgoWUNpIiUee0/jHGRwqvzYxkq0hGVbbOGSz+JgFxxRu4K8nb3YpG3CMARtg==", + "dev": true + }, + "node_modules/@types/d3-interpolate": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-interpolate/-/d3-interpolate-3.0.4.tgz", + "integrity": "sha512-mgLPETlrpVV1YRJIglr4Ez47g7Yxjl1lj7YKsiMCb27VJH9W8NVM6Bb9d8kkpG/uAQS5AmbA48q2IAolKKo1MA==", + "dev": true, + "dependencies": { + "@types/d3-color": "*" + } + }, + "node_modules/@types/d3-path": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/@types/d3-path/-/d3-path-3.1.1.tgz", + "integrity": "sha512-VMZBYyQvbGmWyWVea0EHs/BwLgxc+MKi1zLDCONksozI4YJMcTt8ZEuIR4Sb1MMTE8MMW49v0IwI5+b7RmfWlg==", + "dev": true + }, + "node_modules/@types/d3-polygon": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-polygon/-/d3-polygon-3.0.2.tgz", + "integrity": "sha512-ZuWOtMaHCkN9xoeEMr1ubW2nGWsp4nIql+OPQRstu4ypeZ+zk3YKqQT0CXVe/PYqrKpZAi+J9mTs05TKwjXSRA==", + "dev": true + }, + "node_modules/@types/d3-quadtree": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/@types/d3-quadtree/-/d3-quadtree-3.0.6.tgz", + "integrity": "sha512-oUzyO1/Zm6rsxKRHA1vH0NEDG58HrT5icx/azi9MF1TWdtttWl0UIUsjEQBBh+SIkrpd21ZjEv7ptxWys1ncsg==", + "dev": true + }, + "node_modules/@types/d3-random": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-random/-/d3-random-3.0.3.tgz", + "integrity": "sha512-Imagg1vJ3y76Y2ea0871wpabqp613+8/r0mCLEBfdtqC7xMSfj9idOnmBYyMoULfHePJyxMAw3nWhJxzc+LFwQ==", + "dev": true + }, + "node_modules/@types/d3-scale": { + "version": "4.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-scale/-/d3-scale-4.0.9.tgz", + "integrity": "sha512-dLmtwB8zkAeO/juAMfnV+sItKjlsw2lKdZVVy6LRr0cBmegxSABiLEpGVmSJJ8O08i4+sGR6qQtb6WtuwJdvVw==", + "dev": true, + "dependencies": { + "@types/d3-time": "*" + } + }, + "node_modules/@types/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/@types/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-iWMJgwkK7yTRmWqRB5plb1kadXyQ5Sj8V/zYlFGMUBbIPKQScw+Dku9cAAMgJG+z5GYDoMjWGLVOvjghDEFnKQ==", + "dev": true + }, + "node_modules/@types/d3-selection": { + "version": "3.0.11", + "resolved": "https://registry.npmjs.org/@types/d3-selection/-/d3-selection-3.0.11.tgz", + "integrity": "sha512-bhAXu23DJWsrI45xafYpkQ4NtcKMwWnAC/vKrd2l+nxMFuvOT3XMYTIj2opv8vq8AO5Yh7Qac/nSeP/3zjTK0w==", + "dev": true + }, + "node_modules/@types/d3-shape": { + "version": "3.1.8", + "resolved": "https://registry.npmjs.org/@types/d3-shape/-/d3-shape-3.1.8.tgz", + "integrity": "sha512-lae0iWfcDeR7qt7rA88BNiqdvPS5pFVPpo5OfjElwNaT2yyekbM0C9vK+yqBqEmHr6lDkRnYNoTBYlAgJa7a4w==", + "dev": true, + "dependencies": { + "@types/d3-path": "*" + } + }, + "node_modules/@types/d3-time": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/d3-time/-/d3-time-3.0.4.tgz", + "integrity": "sha512-yuzZug1nkAAaBlBBikKZTgzCeA+k1uy4ZFwWANOfKw5z5LRhV0gNA7gNkKm7HoK+HRN0wX3EkxGk0fpbWhmB7g==", + "dev": true + }, + "node_modules/@types/d3-time-format": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/@types/d3-time-format/-/d3-time-format-4.0.3.tgz", + "integrity": "sha512-5xg9rC+wWL8kdDj153qZcsJ0FWiFt0J5RB6LYUNZjwSnesfblqrI/bJ1wBdJ8OQfncgbJG5+2F+qfqnqyzYxyg==", + "dev": true + }, + "node_modules/@types/d3-timer": { + "version": "3.0.2", + "resolved": "https://registry.npmjs.org/@types/d3-timer/-/d3-timer-3.0.2.tgz", + "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==", + "dev": true + }, + "node_modules/@types/d3-transition": { + "version": "3.0.9", + "resolved": "https://registry.npmjs.org/@types/d3-transition/-/d3-transition-3.0.9.tgz", + "integrity": "sha512-uZS5shfxzO3rGlu0cC3bjmMFKsXv+SmZZcgp0KD22ts4uGXp5EVYGzu/0YdwZeKmddhcAccYtREJKkPfXkZuCg==", + "dev": true, + "dependencies": { + "@types/d3-selection": "*" + } + }, + "node_modules/@types/d3-zoom": { + "version": "3.0.8", + "resolved": "https://registry.npmjs.org/@types/d3-zoom/-/d3-zoom-3.0.8.tgz", + "integrity": "sha512-iqMC4/YlFCSlO8+2Ii1GGGliCAY4XdeG748w5vQUbevlbDu0zSjH/+jojorQVBK/se0j6DUFNPBGSqD3YWYnDw==", + "dev": true, + "dependencies": { + "@types/d3-interpolate": "*", + "@types/d3-selection": "*" + } + }, + "node_modules/@types/estree": { + "version": "1.0.8", + "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.8.tgz", + "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w==", + "dev": true + }, + "node_modules/@types/geojson": { + "version": "7946.0.16", + "resolved": "https://registry.npmjs.org/@types/geojson/-/geojson-7946.0.16.tgz", + "integrity": "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg==", + "dev": true + }, + "node_modules/@types/hast": { + "version": "3.0.4", + "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz", + "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==", + "dev": true, + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/linkify-it": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/@types/linkify-it/-/linkify-it-5.0.0.tgz", + "integrity": "sha512-sVDA58zAw4eWAffKOaQH5/5j3XeayukzDk+ewSsnv3p4yJEZHCCzMDiZM8e0OUrRvmpGZ85jf4yDHkHsgBNr9Q==", + "dev": true + }, + "node_modules/@types/markdown-it": { + "version": "14.1.2", + "resolved": "https://registry.npmjs.org/@types/markdown-it/-/markdown-it-14.1.2.tgz", + "integrity": "sha512-promo4eFwuiW+TfGxhi+0x3czqTYJkG8qB17ZUJiVF10Xm7NLVRSLUsfRTU/6h1e24VvRnXCx+hG7li58lkzog==", + "dev": true, + "dependencies": { + "@types/linkify-it": "^5", + "@types/mdurl": "^2" + } + }, + "node_modules/@types/mdast": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz", + "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==", + "dev": true, + "dependencies": { + "@types/unist": "*" + } + }, + "node_modules/@types/mdurl": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@types/mdurl/-/mdurl-2.0.0.tgz", + "integrity": "sha512-RGdgjQUZba5p6QEFAVx2OGb8rQDL/cPRG7GiedRzMcJ1tYnUANBncjbSB1NRGwbvjcPeikRABz2nshyPk1bhWg==", + "dev": true + }, + "node_modules/@types/trusted-types": { + "version": "2.0.7", + "resolved": "https://registry.npmjs.org/@types/trusted-types/-/trusted-types-2.0.7.tgz", + "integrity": "sha512-ScaPdn1dQczgbl0QFTeTOmVHFULt394XJgOQNoyVhZ6r2vLnMLJfBPd53SB52T/3G36VI1/g2MZaX0cwDuXsfw==", + "dev": true, + "optional": true + }, + "node_modules/@types/unist": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz", + "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==", + "dev": true + }, + "node_modules/@types/web-bluetooth": { + "version": "0.0.21", + "resolved": "https://registry.npmjs.org/@types/web-bluetooth/-/web-bluetooth-0.0.21.tgz", + "integrity": "sha512-oIQLCGWtcFZy2JW77j9k8nHzAOpqMHLQejDA48XXMWH6tjCQHz5RCFz1bzsmROyL6PUm+LLnUiI4BCn221inxA==", + "dev": true + }, + "node_modules/@ungap/structured-clone": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.0.tgz", + "integrity": "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g==", + "dev": true + }, + "node_modules/@upsetjs/venn.js": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/@upsetjs/venn.js/-/venn.js-2.0.0.tgz", + "integrity": "sha512-WbBhLrooyePuQ1VZxrJjtLvTc4NVfpOyKx0sKqioq9bX1C1m7Jgykkn8gLrtwumBioXIqam8DLxp88Adbue6Hw==", + "dev": true, + "optionalDependencies": { + "d3-selection": "^3.0.0", + "d3-transition": "^3.0.1" + } + }, + "node_modules/@vitejs/plugin-vue": { + "version": "5.2.4", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-vue/-/plugin-vue-5.2.4.tgz", + "integrity": "sha512-7Yx/SXSOcQq5HiiV3orevHUFn+pmMB4cgbEkDYgnkUWb0WfeQ/wa2yFv6D5ICiCQOVpjA7vYDXrC7AGO8yjDHA==", + "dev": true, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "peerDependencies": { + "vite": "^5.0.0 || ^6.0.0", + "vue": "^3.2.25" + } + }, + "node_modules/@vue/compiler-core": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/compiler-core/-/compiler-core-3.5.31.tgz", + "integrity": "sha512-k/ueL14aNIEy5Onf0OVzR8kiqF/WThgLdFhxwa4e/KF/0qe38IwIdofoSWBTvvxQOesaz6riAFAUaYjoF9fLLQ==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.29.2", + "@vue/shared": "3.5.31", + "entities": "^7.0.1", + "estree-walker": "^2.0.2", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-dom": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/compiler-dom/-/compiler-dom-3.5.31.tgz", + "integrity": "sha512-BMY/ozS/xxjYqRFL+tKdRpATJYDTTgWSo0+AJvJNg4ig+Hgb0dOsHPXvloHQ5hmlivUqw1Yt2pPIqp4e0v1GUw==", + "dev": true, + "dependencies": { + "@vue/compiler-core": "3.5.31", + "@vue/shared": "3.5.31" + } + }, + "node_modules/@vue/compiler-sfc": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/compiler-sfc/-/compiler-sfc-3.5.31.tgz", + "integrity": "sha512-M8wpPgR9UJ8MiRGjppvx9uWJfLV7A/T+/rL8s/y3QG3u0c2/YZgff3d6SuimKRIhcYnWg5fTfDMlz2E6seUW8Q==", + "dev": true, + "dependencies": { + "@babel/parser": "^7.29.2", + "@vue/compiler-core": "3.5.31", + "@vue/compiler-dom": "3.5.31", + "@vue/compiler-ssr": "3.5.31", + "@vue/shared": "3.5.31", + "estree-walker": "^2.0.2", + "magic-string": "^0.30.21", + "postcss": "^8.5.8", + "source-map-js": "^1.2.1" + } + }, + "node_modules/@vue/compiler-ssr": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/compiler-ssr/-/compiler-ssr-3.5.31.tgz", + "integrity": "sha512-h0xIMxrt/LHOvJKMri+vdYT92BrK3HFLtDqq9Pr/lVVfE4IyKZKvWf0vJFW10Yr6nX02OR4MkJwI0c1HDa1hog==", + "dev": true, + "dependencies": { + "@vue/compiler-dom": "3.5.31", + "@vue/shared": "3.5.31" + } + }, + "node_modules/@vue/devtools-api": { + "version": "7.7.9", + "resolved": "https://registry.npmjs.org/@vue/devtools-api/-/devtools-api-7.7.9.tgz", + "integrity": "sha512-kIE8wvwlcZ6TJTbNeU2HQNtaxLx3a84aotTITUuL/4bzfPxzajGBOoqjMhwZJ8L9qFYDU/lAYMEEm11dnZOD6g==", + "dev": true, + "dependencies": { + "@vue/devtools-kit": "^7.7.9" + } + }, + "node_modules/@vue/devtools-kit": { + "version": "7.7.9", + "resolved": "https://registry.npmjs.org/@vue/devtools-kit/-/devtools-kit-7.7.9.tgz", + "integrity": "sha512-PyQ6odHSgiDVd4hnTP+aDk2X4gl2HmLDfiyEnn3/oV+ckFDuswRs4IbBT7vacMuGdwY/XemxBoh302ctbsptuA==", + "dev": true, + "dependencies": { + "@vue/devtools-shared": "^7.7.9", + "birpc": "^2.3.0", + "hookable": "^5.5.3", + "mitt": "^3.0.1", + "perfect-debounce": "^1.0.0", + "speakingurl": "^14.0.1", + "superjson": "^2.2.2" + } + }, + "node_modules/@vue/devtools-shared": { + "version": "7.7.9", + "resolved": "https://registry.npmjs.org/@vue/devtools-shared/-/devtools-shared-7.7.9.tgz", + "integrity": "sha512-iWAb0v2WYf0QWmxCGy0seZNDPdO3Sp5+u78ORnyeonS6MT4PC7VPrryX2BpMJrwlDeaZ6BD4vP4XKjK0SZqaeA==", + "dev": true, + "dependencies": { + "rfdc": "^1.4.1" + } + }, + "node_modules/@vue/reactivity": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/reactivity/-/reactivity-3.5.31.tgz", + "integrity": "sha512-DtKXxk9E/KuVvt8VxWu+6Luc9I9ETNcqR1T1oW1gf02nXaZ1kuAx58oVu7uX9XxJR0iJCro6fqBLw9oSBELo5g==", + "dev": true, + "dependencies": { + "@vue/shared": "3.5.31" + } + }, + "node_modules/@vue/runtime-core": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/runtime-core/-/runtime-core-3.5.31.tgz", + "integrity": "sha512-AZPmIHXEAyhpkmN7aWlqjSfYynmkWlluDNPHMCZKFHH+lLtxP/30UJmoVhXmbDoP1Ng0jG0fyY2zCj1PnSSA6Q==", + "dev": true, + "dependencies": { + "@vue/reactivity": "3.5.31", + "@vue/shared": "3.5.31" + } + }, + "node_modules/@vue/runtime-dom": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/runtime-dom/-/runtime-dom-3.5.31.tgz", + "integrity": "sha512-xQJsNRmGPeDCJq/u813tyonNgWBFjzfVkBwDREdEWndBnGdHLHgkwNBQxLtg4zDrzKTEcnikUy1UUNecb3lJ6g==", + "dev": true, + "dependencies": { + "@vue/reactivity": "3.5.31", + "@vue/runtime-core": "3.5.31", + "@vue/shared": "3.5.31", + "csstype": "^3.2.3" + } + }, + "node_modules/@vue/server-renderer": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/server-renderer/-/server-renderer-3.5.31.tgz", + "integrity": "sha512-GJuwRvMcdZX/CriUnyIIOGkx3rMV3H6sOu0JhdKbduaeCji6zb60iOGMY7tFoN24NfsUYoFBhshZtGxGpxO4iA==", + "dev": true, + "dependencies": { + "@vue/compiler-ssr": "3.5.31", + "@vue/shared": "3.5.31" + }, + "peerDependencies": { + "vue": "3.5.31" + } + }, + "node_modules/@vue/shared": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/@vue/shared/-/shared-3.5.31.tgz", + "integrity": "sha512-nBxuiuS9Lj5bPkPbWogPUnjxxWpkRniX7e5UBQDWl6Fsf4roq9wwV+cR7ezQ4zXswNvPIlsdj1slcLB7XCsRAw==", + "dev": true + }, + "node_modules/@vueuse/core": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/core/-/core-12.8.2.tgz", + "integrity": "sha512-HbvCmZdzAu3VGi/pWYm5Ut+Kd9mn1ZHnn4L5G8kOQTPs/IwIAmJoBrmYk2ckLArgMXZj0AW3n5CAejLUO+PhdQ==", + "dev": true, + "dependencies": { + "@types/web-bluetooth": "^0.0.21", + "@vueuse/metadata": "12.8.2", + "@vueuse/shared": "12.8.2", + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/integrations": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/integrations/-/integrations-12.8.2.tgz", + "integrity": "sha512-fbGYivgK5uBTRt7p5F3zy6VrETlV9RtZjBqd1/HxGdjdckBgBM4ugP8LHpjolqTj14TXTxSK1ZfgPbHYyGuH7g==", + "dev": true, + "dependencies": { + "@vueuse/core": "12.8.2", + "@vueuse/shared": "12.8.2", + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + }, + "peerDependencies": { + "async-validator": "^4", + "axios": "^1", + "change-case": "^5", + "drauu": "^0.4", + "focus-trap": "^7", + "fuse.js": "^7", + "idb-keyval": "^6", + "jwt-decode": "^4", + "nprogress": "^0.2", + "qrcode": "^1.5", + "sortablejs": "^1", + "universal-cookie": "^7" + }, + "peerDependenciesMeta": { + "async-validator": { + "optional": true + }, + "axios": { + "optional": true + }, + "change-case": { + "optional": true + }, + "drauu": { + "optional": true + }, + "focus-trap": { + "optional": true + }, + "fuse.js": { + "optional": true + }, + "idb-keyval": { + "optional": true + }, + "jwt-decode": { + "optional": true + }, + "nprogress": { + "optional": true + }, + "qrcode": { + "optional": true + }, + "sortablejs": { + "optional": true + }, + "universal-cookie": { + "optional": true + } + } + }, + "node_modules/@vueuse/metadata": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/metadata/-/metadata-12.8.2.tgz", + "integrity": "sha512-rAyLGEuoBJ/Il5AmFHiziCPdQzRt88VxR+Y/A/QhJ1EWtWqPBBAxTAFaSkviwEuOEZNtW8pvkPgoCZQ+HxqW1A==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/@vueuse/shared": { + "version": "12.8.2", + "resolved": "https://registry.npmjs.org/@vueuse/shared/-/shared-12.8.2.tgz", + "integrity": "sha512-dznP38YzxZoNloI0qpEfpkms8knDtaoQ6Y/sfS0L7Yki4zh40LFHEhur0odJC6xTHG5dxWVPiUWBXn+wCG2s5w==", + "dev": true, + "dependencies": { + "vue": "^3.5.13" + }, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/acorn": { + "version": "8.16.0", + "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.16.0.tgz", + "integrity": "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw==", + "dev": true, + "bin": { + "acorn": "bin/acorn" + }, + "engines": { + "node": ">=0.4.0" + } + }, + "node_modules/algoliasearch": { + "version": "5.50.1", + "resolved": "https://registry.npmjs.org/algoliasearch/-/algoliasearch-5.50.1.tgz", + "integrity": "sha512-/bwdue1/8LWELn/DBalGRfuLsXBLXULJo/yOeavJtDu8rBwxIzC6/Rz9Jg19S21VkJvRuZO1k8CZXBMS73mYbA==", + "dev": true, + "dependencies": { + "@algolia/abtesting": "1.16.1", + "@algolia/client-abtesting": "5.50.1", + "@algolia/client-analytics": "5.50.1", + "@algolia/client-common": "5.50.1", + "@algolia/client-insights": "5.50.1", + "@algolia/client-personalization": "5.50.1", + "@algolia/client-query-suggestions": "5.50.1", + "@algolia/client-search": "5.50.1", + "@algolia/ingestion": "1.50.1", + "@algolia/monitoring": "1.50.1", + "@algolia/recommend": "5.50.1", + "@algolia/requester-browser-xhr": "5.50.1", + "@algolia/requester-fetch": "5.50.1", + "@algolia/requester-node-http": "5.50.1" + }, + "engines": { + "node": ">= 14.0.0" + } + }, + "node_modules/ansi-regex": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz", + "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/ansi-styles": { + "version": "4.3.0", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", + "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", + "dev": true, + "dependencies": { + "color-convert": "^2.0.1" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/birpc": { + "version": "2.9.0", + "resolved": "https://registry.npmjs.org/birpc/-/birpc-2.9.0.tgz", + "integrity": "sha512-KrayHS5pBi69Xi9JmvoqrIgYGDkD6mcSe/i6YKi3w5kekCLzrX4+nawcXqrj2tIp50Kw/mT/s3p+GVK0A0sKxw==", + "dev": true, + "funding": { + "url": "https://github.com/sponsors/antfu" + } + }, + "node_modules/ccount": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz", + "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/chalk": { + "version": "4.1.2", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", + "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", + "dev": true, + "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/chalk/node_modules/supports-color": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", + "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/character-entities-html4": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz", + "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/character-entities-legacy": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz", + "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/chevrotain": { + "version": "11.1.2", + "resolved": "https://registry.npmjs.org/chevrotain/-/chevrotain-11.1.2.tgz", + "integrity": "sha512-opLQzEVriiH1uUQ4Kctsd49bRoFDXGGSC4GUqj7pGyxM3RehRhvTlZJc1FL/Flew2p5uwxa1tUDWKzI4wNM8pg==", + "dev": true, + "dependencies": { + "@chevrotain/cst-dts-gen": "11.1.2", + "@chevrotain/gast": "11.1.2", + "@chevrotain/regexp-to-ast": "11.1.2", + "@chevrotain/types": "11.1.2", + "@chevrotain/utils": "11.1.2", + "lodash-es": "4.17.23" + } + }, + "node_modules/chevrotain-allstar": { + "version": "0.3.1", + "resolved": "https://registry.npmjs.org/chevrotain-allstar/-/chevrotain-allstar-0.3.1.tgz", + "integrity": "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw==", + "dev": true, + "dependencies": { + "lodash-es": "^4.17.21" + }, + "peerDependencies": { + "chevrotain": "^11.0.0" + } + }, + "node_modules/chevrotain/node_modules/lodash-es": { + "version": "4.17.23", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.17.23.tgz", + "integrity": "sha512-kVI48u3PZr38HdYz98UmfPnXl2DXrpdctLrFLCd3kOx1xUkOmpFPx7gCWWM5MPkL/fD8zb+Ph0QzjGFs4+hHWg==", + "dev": true + }, + "node_modules/cliui": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", + "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==", + "dev": true, + "dependencies": { + "string-width": "^4.2.0", + "strip-ansi": "^6.0.1", + "wrap-ansi": "^7.0.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/color-convert": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", + "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", + "dev": true, + "dependencies": { + "color-name": "~1.1.4" + }, + "engines": { + "node": ">=7.0.0" + } + }, + "node_modules/color-name": { + "version": "1.1.4", + "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", + "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", + "dev": true + }, + "node_modules/comma-separated-tokens": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz", + "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/commander": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-7.2.0.tgz", + "integrity": "sha512-QrWXB+ZQSVPmIWIhtEO9H+gwHaMGYiF5ChvoJ+K9ZGHG/sVsa6yiesAD1GC/x46sET00Xlwo1u49RVVVzvcSkw==", + "dev": true, + "engines": { + "node": ">= 10" + } + }, + "node_modules/concurrently": { + "version": "9.2.1", + "resolved": "https://registry.npmjs.org/concurrently/-/concurrently-9.2.1.tgz", + "integrity": "sha512-fsfrO0MxV64Znoy8/l1vVIjjHa29SZyyqPgQBwhiDcaW8wJc2W3XWVOGx4M3oJBnv/zdUZIIp1gDeS98GzP8Ng==", + "dev": true, + "dependencies": { + "chalk": "4.1.2", + "rxjs": "7.8.2", + "shell-quote": "1.8.3", + "supports-color": "8.1.1", + "tree-kill": "1.2.2", + "yargs": "17.7.2" + }, + "bin": { + "conc": "dist/bin/concurrently.js", + "concurrently": "dist/bin/concurrently.js" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/open-cli-tools/concurrently?sponsor=1" + } + }, + "node_modules/confbox": { + "version": "0.1.8", + "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz", + "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==", + "dev": true + }, + "node_modules/copy-anything": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/copy-anything/-/copy-anything-4.0.5.tgz", + "integrity": "sha512-7Vv6asjS4gMOuILabD3l739tsaxFQmC+a7pLZm02zyvs8p977bL3zEgq3yDk5rn9B0PbYgIv++jmHcuUab4RhA==", + "dev": true, + "dependencies": { + "is-what": "^5.2.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/cose-base": { + "version": "1.0.3", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-1.0.3.tgz", + "integrity": "sha512-s9whTXInMSgAp/NVXVNuVxVKzGH2qck3aQlVHxDCdAEPgtMKwc4Wq6/QKhgdEdgbLSi9rBTAcPoRa6JpiG4ksg==", + "dev": true, + "dependencies": { + "layout-base": "^1.0.0" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "dev": true + }, + "node_modules/cytoscape": { + "version": "3.33.1", + "resolved": "https://registry.npmjs.org/cytoscape/-/cytoscape-3.33.1.tgz", + "integrity": "sha512-iJc4TwyANnOGR1OmWhsS9ayRS3s+XQ185FmuHObThD+5AeJCakAAbWv8KimMTt08xCCLNgneQwFp+JRJOr9qGQ==", + "dev": true, + "engines": { + "node": ">=0.10" + } + }, + "node_modules/cytoscape-cose-bilkent": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/cytoscape-cose-bilkent/-/cytoscape-cose-bilkent-4.1.0.tgz", + "integrity": "sha512-wgQlVIUJF13Quxiv5e1gstZ08rnZj2XaLHGoFMYXz7SkNfCDOOteKBE6SYRfA9WxxI/iBc3ajfDoc6hb/MRAHQ==", + "dev": true, + "dependencies": { + "cose-base": "^1.0.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cytoscape-fcose/-/cytoscape-fcose-2.2.0.tgz", + "integrity": "sha512-ki1/VuRIHFCzxWNrsshHYPs6L7TvLu3DL+TyIGEsRcvVERmxokbf5Gdk7mFxZnTdiGtnA4cfSmjZJMviqSuZrQ==", + "dev": true, + "dependencies": { + "cose-base": "^2.2.0" + }, + "peerDependencies": { + "cytoscape": "^3.2.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/cose-base": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/cose-base/-/cose-base-2.2.0.tgz", + "integrity": "sha512-AzlgcsCbUMymkADOJtQm3wO9S3ltPfYOFD5033keQn9NJzIbtnZj+UdBJe7DYml/8TdbtHJW3j58SOnKhWY/5g==", + "dev": true, + "dependencies": { + "layout-base": "^2.0.0" + } + }, + "node_modules/cytoscape-fcose/node_modules/layout-base": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-2.0.1.tgz", + "integrity": "sha512-dp3s92+uNI1hWIpPGH3jK2kxE2lMjdXdr+DH8ynZHpd6PUlH6x6cbuXnoMmiNumznqaNO31xu9e79F0uuZ0JFg==", + "dev": true + }, + "node_modules/d3": { + "version": "7.9.0", + "resolved": "https://registry.npmjs.org/d3/-/d3-7.9.0.tgz", + "integrity": "sha512-e1U46jVP+w7Iut8Jt8ri1YsPOvFpg46k+K8TpCb0P+zjCkjkPnV7WzfDJzMHy1LnA+wj5pLT1wjO901gLXeEhA==", + "dev": true, + "dependencies": { + "d3-array": "3", + "d3-axis": "3", + "d3-brush": "3", + "d3-chord": "3", + "d3-color": "3", + "d3-contour": "4", + "d3-delaunay": "6", + "d3-dispatch": "3", + "d3-drag": "3", + "d3-dsv": "3", + "d3-ease": "3", + "d3-fetch": "3", + "d3-force": "3", + "d3-format": "3", + "d3-geo": "3", + "d3-hierarchy": "3", + "d3-interpolate": "3", + "d3-path": "3", + "d3-polygon": "3", + "d3-quadtree": "3", + "d3-random": "3", + "d3-scale": "4", + "d3-scale-chromatic": "3", + "d3-selection": "3", + "d3-shape": "3", + "d3-time": "3", + "d3-time-format": "4", + "d3-timer": "3", + "d3-transition": "3", + "d3-zoom": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-array": { + "version": "3.2.4", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-3.2.4.tgz", + "integrity": "sha512-tdQAmyA18i4J7wprpYq8ClcxZy3SC31QMeByyCFyRt7BVHdREQZ5lpzoe5mFEYZUWe+oq8HBvk9JjpibyEV4Jg==", + "dev": true, + "dependencies": { + "internmap": "1 - 2" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-axis": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-axis/-/d3-axis-3.0.0.tgz", + "integrity": "sha512-IH5tgjV4jE/GhHkRV0HiVYPDtvfjHQlQfJHs0usq7M30XcSBvOotpmH1IgkcXsO/5gEQZD43B//fc7SRT5S+xw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-brush": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-brush/-/d3-brush-3.0.0.tgz", + "integrity": "sha512-ALnjWlVYkXsVIGlOsuWH1+3udkYFI48Ljihfnh8FZPF2QS9o+PzGLBslO0PjzVoHLZ2KCVgAM8NVkXPJB2aNnQ==", + "dev": true, + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "3", + "d3-transition": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-chord": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-chord/-/d3-chord-3.0.1.tgz", + "integrity": "sha512-VE5S6TNa+j8msksl7HwjxMHDM2yNK3XCkusIlpX5kwauBfXuyLAtNg9jCp/iHH61tgI4sb6R/EIMWCqEIdjT/g==", + "dev": true, + "dependencies": { + "d3-path": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-color": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-color/-/d3-color-3.1.0.tgz", + "integrity": "sha512-zg/chbXyeBtMQ1LbD/WSoW2DpC3I0mpmPdW+ynRTj/x2DAWYrIY7qeZIHidozwV24m4iavr15lNwIwLxRmOxhA==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-contour": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-contour/-/d3-contour-4.0.2.tgz", + "integrity": "sha512-4EzFTRIikzs47RGmdxbeUvLWtGedDUNkTcmzoeyg4sP/dvCexO47AaQL7VKy/gul85TOxw+IBgA8US2xwbToNA==", + "dev": true, + "dependencies": { + "d3-array": "^3.2.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-delaunay": { + "version": "6.0.4", + "resolved": "https://registry.npmjs.org/d3-delaunay/-/d3-delaunay-6.0.4.tgz", + "integrity": "sha512-mdjtIZ1XLAM8bm/hx3WwjfHt6Sggek7qH043O8KEjDXN40xi3vx/6pYSVTwLjEgiXQTbvaouWKynLBiUZ6SK6A==", + "dev": true, + "dependencies": { + "delaunator": "5" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dispatch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dispatch/-/d3-dispatch-3.0.1.tgz", + "integrity": "sha512-rzUyPU/S7rwUflMyLc1ETDeBj0NRuHKKAcvukozwhshr6g6c5d8zh4c2gQjY2bZ0dXeGLWc1PF174P2tVvKhfg==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-drag": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-drag/-/d3-drag-3.0.0.tgz", + "integrity": "sha512-pWbUJLdETVA8lQNJecMxoXfH6x+mO2UQo8rSmZ+QqxcbyA3hfeprFgIT//HW2nlHChWeIIMwS2Fq+gEARkhTkg==", + "dev": true, + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-selection": "3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-dsv": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-dsv/-/d3-dsv-3.0.1.tgz", + "integrity": "sha512-UG6OvdI5afDIFP9w4G0mNq50dSOsXHJaRE8arAS5o9ApWnIElp8GZw1Dun8vP8OyHOZ/QJUKUJwxiiCCnUwm+Q==", + "dev": true, + "dependencies": { + "commander": "7", + "iconv-lite": "0.6", + "rw": "1" + }, + "bin": { + "csv2json": "bin/dsv2json.js", + "csv2tsv": "bin/dsv2dsv.js", + "dsv2dsv": "bin/dsv2dsv.js", + "dsv2json": "bin/dsv2json.js", + "json2csv": "bin/json2dsv.js", + "json2dsv": "bin/json2dsv.js", + "json2tsv": "bin/json2dsv.js", + "tsv2csv": "bin/dsv2dsv.js", + "tsv2json": "bin/dsv2json.js" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-ease": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-ease/-/d3-ease-3.0.1.tgz", + "integrity": "sha512-wR/XK3D3XcLIZwpbvQwQ5fK+8Ykds1ip7A2Txe0yxncXSdq1L9skcG7blcedkOX+ZcgxGAmLX1FrRGbADwzi0w==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-fetch": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-fetch/-/d3-fetch-3.0.1.tgz", + "integrity": "sha512-kpkQIM20n3oLVBKGg6oHrUchHM3xODkTzjMoj7aWQFq5QEM+R6E4WkzT5+tojDY7yjez8KgCBRoj4aEr99Fdqw==", + "dev": true, + "dependencies": { + "d3-dsv": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-force": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-force/-/d3-force-3.0.0.tgz", + "integrity": "sha512-zxV/SsA+U4yte8051P4ECydjD/S+qeYtnaIyAs9tgHCqfguma/aAQDjo85A9Z6EKhBirHRJHXIgJUlffT4wdLg==", + "dev": true, + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-quadtree": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-format": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-format/-/d3-format-3.1.2.tgz", + "integrity": "sha512-AJDdYOdnyRDV5b6ArilzCPPwc1ejkHcoyFarqlPqT7zRYjhavcT3uSrqcMvsgh2CgoPbK3RCwyHaVyxYcP2Arg==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-geo": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/d3-geo/-/d3-geo-3.1.1.tgz", + "integrity": "sha512-637ln3gXKXOwhalDzinUgY83KzNWZRKbYubaG+fGVuc/dxO64RRljtCTnf5ecMyE1RIdtqpkVcq0IbtU2S8j2Q==", + "dev": true, + "dependencies": { + "d3-array": "2.5.0 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-hierarchy": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/d3-hierarchy/-/d3-hierarchy-3.1.2.tgz", + "integrity": "sha512-FX/9frcub54beBdugHjDCdikxThEqjnR93Qt7PvQTOHxyiNCAlvMrHhclk3cD5VeAaq9fxmfRp+CnWw9rEMBuA==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-interpolate": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-interpolate/-/d3-interpolate-3.0.1.tgz", + "integrity": "sha512-3bYs1rOD33uo8aqJfKP3JWPAibgw8Zm2+L9vBKEHJ2Rg+viTR7o5Mmv5mZcieN+FRYaAOWX5SJATX6k1PWz72g==", + "dev": true, + "dependencies": { + "d3-color": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-path": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-3.1.0.tgz", + "integrity": "sha512-p3KP5HCf/bvjBSSKuXid6Zqijx7wIfNW+J/maPs+iwR35at5JCbLUT0LzF1cnjbCHWhqzQTIN2Jpe8pRebIEFQ==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-polygon": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-polygon/-/d3-polygon-3.0.1.tgz", + "integrity": "sha512-3vbA7vXYwfe1SYhED++fPUQlWSYTTGmFmQiany/gdbiWgU/iEyQzyymwL9SkJjFFuCS4902BSzewVGsHHmHtXg==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-quadtree": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-quadtree/-/d3-quadtree-3.0.1.tgz", + "integrity": "sha512-04xDrxQTDTCFwP5H6hRhsRcb9xxv2RzkcsygFzmkSIOJy3PeRJP7sNk3VRIbKXcog561P9oU0/rVH6vDROAgUw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-random": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-random/-/d3-random-3.0.1.tgz", + "integrity": "sha512-FXMe9GfxTxqd5D6jFsQ+DJ8BJS4E/fT5mqqdjovykEB2oFbTMDVdg1MGFxfQW+FBOGoB++k8swBrgwSHT1cUXQ==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-sankey": { + "version": "0.12.3", + "resolved": "https://registry.npmjs.org/d3-sankey/-/d3-sankey-0.12.3.tgz", + "integrity": "sha512-nQhsBRmM19Ax5xEIPLMY9ZmJ/cDvd1BG3UVvt5h3WRxKg5zGRbvnteTyWAbzeSvlh3tW7ZEmq4VwR5mB3tutmQ==", + "dev": true, + "dependencies": { + "d3-array": "1 - 2", + "d3-shape": "^1.2.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-array": { + "version": "2.12.1", + "resolved": "https://registry.npmjs.org/d3-array/-/d3-array-2.12.1.tgz", + "integrity": "sha512-B0ErZK/66mHtEsR1TkPEEkwdy+WDesimkM5gpZr5Dsg54BiTA5RXtYW5qTLIAcekaS9xfZrzBLF/OAkB3Qn1YQ==", + "dev": true, + "dependencies": { + "internmap": "^1.0.0" + } + }, + "node_modules/d3-sankey/node_modules/d3-path": { + "version": "1.0.9", + "resolved": "https://registry.npmjs.org/d3-path/-/d3-path-1.0.9.tgz", + "integrity": "sha512-VLaYcn81dtHVTjEHd8B+pbe9yHWpXKZUC87PzoFmsFrJqgFwDe/qxfp5MlfsfM1V5E/iVt0MmEbWQ7FVIXh/bg==", + "dev": true + }, + "node_modules/d3-sankey/node_modules/d3-shape": { + "version": "1.3.7", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-1.3.7.tgz", + "integrity": "sha512-EUkvKjqPFUAZyOlhY5gzCxCeI0Aep04LwIRpsZ/mLFelJiUfnK56jo5JMDSE7yyP2kLSb6LtF+S5chMk7uqPqw==", + "dev": true, + "dependencies": { + "d3-path": "1" + } + }, + "node_modules/d3-sankey/node_modules/internmap": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-1.0.1.tgz", + "integrity": "sha512-lDB5YccMydFBtasVtxnZ3MRBHuaoE8GKsppq+EchKL2U4nK/DmEpPHNH8MZe5HkMtpSiTSOZwfN0tzYjO/lJEw==", + "dev": true + }, + "node_modules/d3-scale": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/d3-scale/-/d3-scale-4.0.2.tgz", + "integrity": "sha512-GZW464g1SH7ag3Y7hXjf8RoUuAFIqklOAq3MRl4OaWabTFJY9PN/E1YklhXLh+OQ3fM9yS2nOkCoS+WLZ6kvxQ==", + "dev": true, + "dependencies": { + "d3-array": "2.10.0 - 3", + "d3-format": "1 - 3", + "d3-interpolate": "1.2.0 - 3", + "d3-time": "2.1.1 - 3", + "d3-time-format": "2 - 4" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-scale-chromatic": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-scale-chromatic/-/d3-scale-chromatic-3.1.0.tgz", + "integrity": "sha512-A3s5PWiZ9YCXFye1o246KoscMWqf8BsD9eRiJ3He7C9OBaxKhAd5TFCdEx/7VbKtxxTsu//1mMJFrEt572cEyQ==", + "dev": true, + "dependencies": { + "d3-color": "1 - 3", + "d3-interpolate": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-selection": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-selection/-/d3-selection-3.0.0.tgz", + "integrity": "sha512-fmTRWbNMmsmWq6xJV8D19U/gw/bwrHfNXxrIN+HfZgnzqTHp9jOmKMhsTUjXOJnZOdZY9Q28y4yebKzqDKlxlQ==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-shape": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/d3-shape/-/d3-shape-3.2.0.tgz", + "integrity": "sha512-SaLBuwGm3MOViRq2ABk3eLoxwZELpH6zhl3FbAoJ7Vm1gofKx6El1Ib5z23NUEhF9AsGl7y+dzLe5Cw2AArGTA==", + "dev": true, + "dependencies": { + "d3-path": "^3.1.0" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/d3-time/-/d3-time-3.1.0.tgz", + "integrity": "sha512-VqKjzBLejbSMT4IgbmVgDjpkYrNWUYJnbCGo874u7MMKIWsILRX+OpX/gTk8MqjpT1A/c6HY2dCA77ZN0lkQ2Q==", + "dev": true, + "dependencies": { + "d3-array": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-time-format": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/d3-time-format/-/d3-time-format-4.1.0.tgz", + "integrity": "sha512-dJxPBlzC7NugB2PDLwo9Q8JiTR3M3e4/XANkreKSUxF8vvXKqm1Yfq4Q5dl8budlunRVlUUaDUgFt7eA8D6NLg==", + "dev": true, + "dependencies": { + "d3-time": "1 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-timer": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-timer/-/d3-timer-3.0.1.tgz", + "integrity": "sha512-ndfJ/JxxMd3nw31uyKoY2naivF+r29V+Lc0svZxe1JvvIRmi8hUsrMvdOwgS1o6uBHmiz91geQ0ylPP0aj1VUA==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/d3-transition": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/d3-transition/-/d3-transition-3.0.1.tgz", + "integrity": "sha512-ApKvfjsSR6tg06xrL434C0WydLr7JewBB3V+/39RMHsaXTOG0zmt/OAXeng5M5LBm0ojmxJrpomQVZ1aPvBL4w==", + "dev": true, + "dependencies": { + "d3-color": "1 - 3", + "d3-dispatch": "1 - 3", + "d3-ease": "1 - 3", + "d3-interpolate": "1 - 3", + "d3-timer": "1 - 3" + }, + "engines": { + "node": ">=12" + }, + "peerDependencies": { + "d3-selection": "2 - 3" + } + }, + "node_modules/d3-zoom": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/d3-zoom/-/d3-zoom-3.0.0.tgz", + "integrity": "sha512-b8AmV3kfQaqWAuacbPuNbL6vahnOJflOhexLzMMNLga62+/nh0JzvJ0aO/5a5MVgUFGS7Hu1P9P03o3fJkDCyw==", + "dev": true, + "dependencies": { + "d3-dispatch": "1 - 3", + "d3-drag": "2 - 3", + "d3-interpolate": "1 - 3", + "d3-selection": "2 - 3", + "d3-transition": "2 - 3" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/dagre-d3-es": { + "version": "7.0.14", + "resolved": "https://registry.npmjs.org/dagre-d3-es/-/dagre-d3-es-7.0.14.tgz", + "integrity": "sha512-P4rFMVq9ESWqmOgK+dlXvOtLwYg0i7u0HBGJER0LZDJT2VHIPAMZ/riPxqJceWMStH5+E61QxFra9kIS3AqdMg==", + "dev": true, + "dependencies": { + "d3": "^7.9.0", + "lodash-es": "^4.17.21" + } + }, + "node_modules/dayjs": { + "version": "1.11.20", + "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.20.tgz", + "integrity": "sha512-YbwwqR/uYpeoP4pu043q+LTDLFBLApUP6VxRihdfNTqu4ubqMlGDLd6ErXhEgsyvY0K6nCs7nggYumAN+9uEuQ==", + "dev": true + }, + "node_modules/delaunator": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/delaunator/-/delaunator-5.1.0.tgz", + "integrity": "sha512-AGrQ4QSgssa1NGmWmLPqN5NY2KajF5MqxetNEO+o0n3ZwZZeTmt7bBnvzHWrmkZFxGgr4HdyFgelzgi06otLuQ==", + "dev": true, + "dependencies": { + "robust-predicates": "^3.0.2" + } + }, + "node_modules/dequal": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz", + "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/devlop": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz", + "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==", + "dev": true, + "dependencies": { + "dequal": "^2.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/dompurify": { + "version": "3.3.3", + "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.3.3.tgz", + "integrity": "sha512-Oj6pzI2+RqBfFG+qOaOLbFXLQ90ARpcGG6UePL82bJLtdsa6CYJD7nmiU8MW9nQNOtCHV3lZ/Bzq1X0QYbBZCA==", + "dev": true, + "optionalDependencies": { + "@types/trusted-types": "^2.0.7" + } + }, + "node_modules/emoji-regex": { + "version": "8.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz", + "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==", + "dev": true + }, + "node_modules/emoji-regex-xs": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/emoji-regex-xs/-/emoji-regex-xs-1.0.0.tgz", + "integrity": "sha512-LRlerrMYoIDrT6jgpeZ2YYl/L8EulRTt5hQcYjy5AInh7HWXKimpqx68aknBFpGL2+/IcogTcaydJEgaTmOpDg==", + "dev": true + }, + "node_modules/entities": { + "version": "7.0.1", + "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz", + "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==", + "dev": true, + "engines": { + "node": ">=0.12" + }, + "funding": { + "url": "https://github.com/fb55/entities?sponsor=1" + } + }, + "node_modules/esbuild": { + "version": "0.21.5", + "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.21.5.tgz", + "integrity": "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw==", + "dev": true, + "hasInstallScript": true, + "bin": { + "esbuild": "bin/esbuild" + }, + "engines": { + "node": ">=12" + }, + "optionalDependencies": { + "@esbuild/aix-ppc64": "0.21.5", + "@esbuild/android-arm": "0.21.5", + "@esbuild/android-arm64": "0.21.5", + "@esbuild/android-x64": "0.21.5", + "@esbuild/darwin-arm64": "0.21.5", + "@esbuild/darwin-x64": "0.21.5", + "@esbuild/freebsd-arm64": "0.21.5", + "@esbuild/freebsd-x64": "0.21.5", + "@esbuild/linux-arm": "0.21.5", + "@esbuild/linux-arm64": "0.21.5", + "@esbuild/linux-ia32": "0.21.5", + "@esbuild/linux-loong64": "0.21.5", + "@esbuild/linux-mips64el": "0.21.5", + "@esbuild/linux-ppc64": "0.21.5", + "@esbuild/linux-riscv64": "0.21.5", + "@esbuild/linux-s390x": "0.21.5", + "@esbuild/linux-x64": "0.21.5", + "@esbuild/netbsd-x64": "0.21.5", + "@esbuild/openbsd-x64": "0.21.5", + "@esbuild/sunos-x64": "0.21.5", + "@esbuild/win32-arm64": "0.21.5", + "@esbuild/win32-ia32": "0.21.5", + "@esbuild/win32-x64": "0.21.5" + } + }, + "node_modules/escalade": { + "version": "3.2.0", + "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz", + "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==", + "dev": true, + "engines": { + "node": ">=6" + } + }, + "node_modules/estree-walker": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-2.0.2.tgz", + "integrity": "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w==", + "dev": true + }, + "node_modules/focus-trap": { + "version": "7.8.0", + "resolved": "https://registry.npmjs.org/focus-trap/-/focus-trap-7.8.0.tgz", + "integrity": "sha512-/yNdlIkpWbM0ptxno3ONTuf+2g318kh2ez3KSeZN5dZ8YC6AAmgeWz+GasYYiBJPFaYcSAPeu4GfhUaChzIJXA==", + "dev": true, + "dependencies": { + "tabbable": "^6.4.0" + } + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/get-caller-file": { + "version": "2.0.5", + "resolved": "https://registry.npmjs.org/get-caller-file/-/get-caller-file-2.0.5.tgz", + "integrity": "sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==", + "dev": true, + "engines": { + "node": "6.* || 8.* || >= 10.*" + } + }, + "node_modules/hachure-fill": { + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/hachure-fill/-/hachure-fill-0.5.2.tgz", + "integrity": "sha512-3GKBOn+m2LX9iq+JC1064cSFprJY4jL1jCXTcpnfER5HYE2l/4EfWSGzkPa/ZDBmYI0ZOEj5VHV/eKnPGkHuOg==", + "dev": true + }, + "node_modules/has-flag": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", + "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/hast-util-to-html": { + "version": "9.0.5", + "resolved": "https://registry.npmjs.org/hast-util-to-html/-/hast-util-to-html-9.0.5.tgz", + "integrity": "sha512-OguPdidb+fbHQSU4Q4ZiLKnzWo8Wwsf5bZfbvu7//a9oTYoqD/fWpe96NuHkoS9h0ccGOTe0C4NGXdtS0iObOw==", + "dev": true, + "dependencies": { + "@types/hast": "^3.0.0", + "@types/unist": "^3.0.0", + "ccount": "^2.0.0", + "comma-separated-tokens": "^2.0.0", + "hast-util-whitespace": "^3.0.0", + "html-void-elements": "^3.0.0", + "mdast-util-to-hast": "^13.0.0", + "property-information": "^7.0.0", + "space-separated-tokens": "^2.0.0", + "stringify-entities": "^4.0.0", + "zwitch": "^2.0.4" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hast-util-whitespace": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz", + "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==", + "dev": true, + "dependencies": { + "@types/hast": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/hookable": { + "version": "5.5.3", + "resolved": "https://registry.npmjs.org/hookable/-/hookable-5.5.3.tgz", + "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==", + "dev": true + }, + "node_modules/html-void-elements": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/html-void-elements/-/html-void-elements-3.0.0.tgz", + "integrity": "sha512-bEqo66MRXsUGxWHV5IP0PUiAWwoEjba4VCzg0LjFJBpchPaTfyfCKTG6bc5F8ucKec3q5y6qOdGyYTSBEvhCrg==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/iconv-lite": { + "version": "0.6.3", + "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz", + "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==", + "dev": true, + "dependencies": { + "safer-buffer": ">= 2.1.2 < 3.0.0" + }, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/internmap": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz", + "integrity": "sha512-5Hh7Y1wQbvY5ooGgPbDaL5iYLAPzMTUrjMulskHLH6wnv/A+1q5rgEaiuqEjB+oxGXIVZs1FF+R/KPN3ZSQYYg==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/is-fullwidth-code-point": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz", + "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==", + "dev": true, + "engines": { + "node": ">=8" + } + }, + "node_modules/is-what": { + "version": "5.5.0", + "resolved": "https://registry.npmjs.org/is-what/-/is-what-5.5.0.tgz", + "integrity": "sha512-oG7cgbmg5kLYae2N5IVd3jm2s+vldjxJzK1pcu9LfpGuQ93MQSzo0okvRna+7y5ifrD+20FE8FvjusyGaz14fw==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/mesqueeb" + } + }, + "node_modules/katex": { + "version": "0.16.44", + "resolved": "https://registry.npmjs.org/katex/-/katex-0.16.44.tgz", + "integrity": "sha512-EkxoDTk8ufHqHlf9QxGwcxeLkWRR3iOuYfRpfORgYfqc8s13bgb+YtRY59NK5ZpRaCwq1kqA6a5lpX8C/eLphQ==", + "dev": true, + "funding": [ + "https://opencollective.com/katex", + "https://github.com/sponsors/katex" + ], + "dependencies": { + "commander": "^8.3.0" + }, + "bin": { + "katex": "cli.js" + } + }, + "node_modules/katex/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "dev": true, + "engines": { + "node": ">= 12" + } + }, + "node_modules/khroma": { + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/khroma/-/khroma-2.1.0.tgz", + "integrity": "sha512-Ls993zuzfayK269Svk9hzpeGUKob/sIgZzyHYdjQoAdQetRKpOLj+k/QQQ/6Qi0Yz65mlROrfd+Ev+1+7dz9Kw==", + "dev": true + }, + "node_modules/langium": { + "version": "4.2.1", + "resolved": "https://registry.npmjs.org/langium/-/langium-4.2.1.tgz", + "integrity": "sha512-zu9QWmjpzJcomzdJQAHgDVhLGq5bLosVak1KVa40NzQHXfqr4eAHupvnPOVXEoLkg6Ocefvf/93d//SB7du4YQ==", + "dev": true, + "dependencies": { + "chevrotain": "~11.1.1", + "chevrotain-allstar": "~0.3.1", + "vscode-languageserver": "~9.0.1", + "vscode-languageserver-textdocument": "~1.0.11", + "vscode-uri": "~3.1.0" + }, + "engines": { + "node": ">=20.10.0", + "npm": ">=10.2.3" + } + }, + "node_modules/layout-base": { + "version": "1.0.2", + "resolved": "https://registry.npmjs.org/layout-base/-/layout-base-1.0.2.tgz", + "integrity": "sha512-8h2oVEZNktL4BH2JCOI90iD1yXwL6iNW7KcCKT2QZgQJR2vbqDsldCTPRU9NifTCqHZci57XvQQ15YTu+sTYPg==", + "dev": true + }, + "node_modules/lodash-es": { + "version": "4.18.1", + "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz", + "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==", + "dev": true + }, + "node_modules/magic-string": { + "version": "0.30.21", + "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.21.tgz", + "integrity": "sha512-vd2F4YUyEXKGcLHoq+TEyCjxueSeHnFxyyjNp80yg0XV4vUhnDer/lvvlqM/arB5bXQN5K2/3oinyCRyx8T2CQ==", + "dev": true, + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.5" + } + }, + "node_modules/mark.js": { + "version": "8.11.1", + "resolved": "https://registry.npmjs.org/mark.js/-/mark.js-8.11.1.tgz", + "integrity": "sha512-1I+1qpDt4idfgLQG+BNWmrqku+7/2bi5nLf4YwF8y8zXvmfiTBY3PV3ZibfrjBueCByROpuBjLLFCajqkgYoLQ==", + "dev": true + }, + "node_modules/marked": { + "version": "16.4.2", + "resolved": "https://registry.npmjs.org/marked/-/marked-16.4.2.tgz", + "integrity": "sha512-TI3V8YYWvkVf3KJe1dRkpnjs68JUPyEa5vjKrp1XEEJUAOaQc+Qj+L1qWbPd0SJuAdQkFU0h73sXXqwDYxsiDA==", + "dev": true, + "bin": { + "marked": "bin/marked.js" + }, + "engines": { + "node": ">= 20" + } + }, + "node_modules/mdast-util-to-hast": { + "version": "13.2.1", + "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz", + "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==", + "dev": true, + "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/mermaid": { + "version": "11.14.0", + "resolved": "https://registry.npmjs.org/mermaid/-/mermaid-11.14.0.tgz", + "integrity": "sha512-GSGloRsBs+JINmmhl0JDwjpuezCsHB4WGI4NASHxL3fHo3o/BRXTxhDLKnln8/Q0lRFRyDdEjmk1/d5Sn1Xz8g==", + "dev": true, + "dependencies": { + "@braintree/sanitize-url": "^7.1.1", + "@iconify/utils": "^3.0.2", + "@mermaid-js/parser": "^1.1.0", + "@types/d3": "^7.4.3", + "@upsetjs/venn.js": "^2.0.0", + "cytoscape": "^3.33.1", + "cytoscape-cose-bilkent": "^4.1.0", + "cytoscape-fcose": "^2.2.0", + "d3": "^7.9.0", + "d3-sankey": "^0.12.3", + "dagre-d3-es": "7.0.14", + "dayjs": "^1.11.19", + "dompurify": "^3.3.1", + "katex": "^0.16.25", + "khroma": "^2.1.0", + "lodash-es": "^4.17.23", + "marked": "^16.3.0", + "roughjs": "^4.6.6", + "stylis": "^4.3.6", + "ts-dedent": "^2.2.0", + "uuid": "^11.1.0" + } + }, + "node_modules/micromark-util-character": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz", + "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "dependencies": { + "micromark-util-symbol": "^2.0.0", + "micromark-util-types": "^2.0.0" + } + }, + "node_modules/micromark-util-encode": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz", + "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ] + }, + "node_modules/micromark-util-sanitize-uri": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz", + "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ], + "dependencies": { + "micromark-util-character": "^2.0.0", + "micromark-util-encode": "^2.0.0", + "micromark-util-symbol": "^2.0.0" + } + }, + "node_modules/micromark-util-symbol": { + "version": "2.0.1", + "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz", + "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ] + }, + "node_modules/micromark-util-types": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz", + "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==", + "dev": true, + "funding": [ + { + "type": "GitHub Sponsors", + "url": "https://github.com/sponsors/unifiedjs" + }, + { + "type": "OpenCollective", + "url": "https://opencollective.com/unified" + } + ] + }, + "node_modules/minisearch": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/minisearch/-/minisearch-7.2.0.tgz", + "integrity": "sha512-dqT2XBYUOZOiC5t2HRnwADjhNS2cecp9u+TJRiJ1Qp/f5qjkeT5APcGPjHw+bz89Ms8Jp+cG4AlE+QZ/QnDglg==", + "dev": true + }, + "node_modules/mitt": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/mitt/-/mitt-3.0.1.tgz", + "integrity": "sha512-vKivATfr97l2/QBCYAkXYDbrIWPM2IIKEl7YPhjCvKlG3kE2gm+uBo6nEXK3M5/Ffh/FLpKExzOQ3JJoJGFKBw==", + "dev": true + }, + "node_modules/mlly": { + "version": "1.8.2", + "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.2.tgz", + "integrity": "sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==", + "dev": true, + "dependencies": { + "acorn": "^8.16.0", + "pathe": "^2.0.3", + "pkg-types": "^1.3.1", + "ufo": "^1.6.3" + } + }, + "node_modules/nanoid": { + "version": "3.3.11", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.11.tgz", + "integrity": "sha512-N8SpfPUnUp1bK+PMYW8qSWdl9U+wwNWI4QKxOYDy9JAro3WMX7p2OeVRF9v+347pnakNevPmiHhNmZ2HbFA76w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/non-layered-tidy-tree-layout": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/non-layered-tidy-tree-layout/-/non-layered-tidy-tree-layout-2.0.2.tgz", + "integrity": "sha512-gkXMxRzUH+PB0ax9dUN0yYF0S25BqeAYqhgMaLUFmpXLEk7Fcu8f4emJuOAY0V8kjDICxROIKsTAKsV/v355xw==", + "dev": true, + "optional": true + }, + "node_modules/oniguruma-to-es": { + "version": "3.1.1", + "resolved": "https://registry.npmjs.org/oniguruma-to-es/-/oniguruma-to-es-3.1.1.tgz", + "integrity": "sha512-bUH8SDvPkH3ho3dvwJwfonjlQ4R80vjyvrU8YpxuROddv55vAEJrTuCuCVUhhsHbtlD9tGGbaNApGQckXhS8iQ==", + "dev": true, + "dependencies": { + "emoji-regex-xs": "^1.0.0", + "regex": "^6.0.1", + "regex-recursion": "^6.0.2" + } + }, + "node_modules/package-manager-detector": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/package-manager-detector/-/package-manager-detector-1.6.0.tgz", + "integrity": "sha512-61A5ThoTiDG/C8s8UMZwSorAGwMJ0ERVGj2OjoW5pAalsNOg15+iQiPzrLJ4jhZ1HJzmC2PIHT2oEiH3R5fzNA==", + "dev": true + }, + "node_modules/path-data-parser": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/path-data-parser/-/path-data-parser-0.1.0.tgz", + "integrity": "sha512-NOnmBpt5Y2RWbuv0LMzsayp3lVylAHLPUTut412ZA3l+C4uw4ZVkQbjShYCQ8TCpUMdPapr4YjUqLYD6v68j+w==", + "dev": true + }, + "node_modules/pathe": { + "version": "2.0.3", + "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz", + "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==", + "dev": true + }, + "node_modules/perfect-debounce": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz", + "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==", + "dev": true + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "dev": true + }, + "node_modules/pkg-types": { + "version": "1.3.1", + "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz", + "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==", + "dev": true, + "dependencies": { + "confbox": "^0.1.8", + "mlly": "^1.7.4", + "pathe": "^2.0.1" + } + }, + "node_modules/points-on-curve": { + "version": "0.2.0", + "resolved": "https://registry.npmjs.org/points-on-curve/-/points-on-curve-0.2.0.tgz", + "integrity": "sha512-0mYKnYYe9ZcqMCWhUjItv/oHjvgEsfKvnUTg8sAtnHr3GVy7rGkXCb6d5cSyqrWqL4k81b9CPg3urd+T7aop3A==", + "dev": true + }, + "node_modules/points-on-path": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/points-on-path/-/points-on-path-0.2.1.tgz", + "integrity": "sha512-25ClnWWuw7JbWZcgqY/gJ4FQWadKxGWk+3kR/7kD0tCaDtPPMj7oHu2ToLaVhfpnHrZzYby2w6tUA0eOIuUg8g==", + "dev": true, + "dependencies": { + "path-data-parser": "0.1.0", + "points-on-curve": "0.2.0" + } + }, + "node_modules/postcss": { + "version": "8.5.8", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.8.tgz", + "integrity": "sha512-OW/rX8O/jXnm82Ey1k44pObPtdblfiuWnrd8X7GJ7emImCOstunGbXUpp7HdBrFQX6rJzn3sPT397Wp5aCwCHg==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "dependencies": { + "nanoid": "^3.3.11", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/preact": { + "version": "10.29.0", + "resolved": "https://registry.npmjs.org/preact/-/preact-10.29.0.tgz", + "integrity": "sha512-wSAGyk2bYR1c7t3SZ3jHcM6xy0lcBcDel6lODcs9ME6Th++Dx2KU+6D3HD8wMMKGA8Wpw7OMd3/4RGzYRpzwRg==", + "dev": true, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/preact" + } + }, + "node_modules/property-information": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.1.0.tgz", + "integrity": "sha512-TwEZ+X+yCJmYfL7TPUOcvBZ4QfoT5YenQiJuX//0th53DE6w0xxLEtfK3iyryQFddXuvkIk51EEgrJQ0WJkOmQ==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/regex/-/regex-6.1.0.tgz", + "integrity": "sha512-6VwtthbV4o/7+OaAF9I5L5V3llLEsoPyq9P1JVXkedTP33c7MfCG0/5NOPcSJn0TzXcG9YUrR0gQSWioew3LDg==", + "dev": true, + "dependencies": { + "regex-utilities": "^2.3.0" + } + }, + "node_modules/regex-recursion": { + "version": "6.0.2", + "resolved": "https://registry.npmjs.org/regex-recursion/-/regex-recursion-6.0.2.tgz", + "integrity": "sha512-0YCaSCq2VRIebiaUviZNs0cBz1kg5kVS2UKUfNIx8YVs1cN3AV7NTctO5FOKBA+UT2BPJIWZauYHPqJODG50cg==", + "dev": true, + "dependencies": { + "regex-utilities": "^2.3.0" + } + }, + "node_modules/regex-utilities": { + "version": "2.3.0", + "resolved": "https://registry.npmjs.org/regex-utilities/-/regex-utilities-2.3.0.tgz", + "integrity": "sha512-8VhliFJAWRaUiVvREIiW2NXXTmHs4vMNnSzuJVhscgmGav3g9VDxLrQndI3dZZVVdp0ZO/5v0xmX516/7M9cng==", + "dev": true + }, + "node_modules/require-directory": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/require-directory/-/require-directory-2.1.1.tgz", + "integrity": "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", + "dev": true + }, + "node_modules/robust-predicates": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/robust-predicates/-/robust-predicates-3.0.3.tgz", + "integrity": "sha512-NS3levdsRIUOmiJ8FZWCP7LG3QpJyrs/TE0Zpf1yvZu8cAJJ6QMW92H1c7kWpdIHo8RvmLxN/o2JXTKHp74lUA==", + "dev": true + }, + "node_modules/rollup": { + "version": "4.60.1", + "resolved": "https://registry.npmjs.org/rollup/-/rollup-4.60.1.tgz", + "integrity": "sha512-VmtB2rFU/GroZ4oL8+ZqXgSA38O6GR8KSIvWmEFv63pQ0G6KaBH9s07PO8XTXP4vI+3UJUEypOfjkGfmSBBR0w==", + "dev": true, + "dependencies": { + "@types/estree": "1.0.8" + }, + "bin": { + "rollup": "dist/bin/rollup" + }, + "engines": { + "node": ">=18.0.0", + "npm": ">=8.0.0" + }, + "optionalDependencies": { + "@rollup/rollup-android-arm-eabi": "4.60.1", + "@rollup/rollup-android-arm64": "4.60.1", + "@rollup/rollup-darwin-arm64": "4.60.1", + "@rollup/rollup-darwin-x64": "4.60.1", + "@rollup/rollup-freebsd-arm64": "4.60.1", + "@rollup/rollup-freebsd-x64": "4.60.1", + "@rollup/rollup-linux-arm-gnueabihf": "4.60.1", + "@rollup/rollup-linux-arm-musleabihf": "4.60.1", + "@rollup/rollup-linux-arm64-gnu": "4.60.1", + "@rollup/rollup-linux-arm64-musl": "4.60.1", + "@rollup/rollup-linux-loong64-gnu": "4.60.1", + "@rollup/rollup-linux-loong64-musl": "4.60.1", + "@rollup/rollup-linux-ppc64-gnu": "4.60.1", + "@rollup/rollup-linux-ppc64-musl": "4.60.1", + "@rollup/rollup-linux-riscv64-gnu": "4.60.1", + "@rollup/rollup-linux-riscv64-musl": "4.60.1", + "@rollup/rollup-linux-s390x-gnu": "4.60.1", + "@rollup/rollup-linux-x64-gnu": "4.60.1", + "@rollup/rollup-linux-x64-musl": "4.60.1", + "@rollup/rollup-openbsd-x64": "4.60.1", + "@rollup/rollup-openharmony-arm64": "4.60.1", + "@rollup/rollup-win32-arm64-msvc": "4.60.1", + "@rollup/rollup-win32-ia32-msvc": "4.60.1", + "@rollup/rollup-win32-x64-gnu": "4.60.1", + "@rollup/rollup-win32-x64-msvc": "4.60.1", + "fsevents": "~2.3.2" + } + }, + "node_modules/roughjs": { + "version": "4.6.6", + "resolved": "https://registry.npmjs.org/roughjs/-/roughjs-4.6.6.tgz", + "integrity": "sha512-ZUz/69+SYpFN/g/lUlo2FXcIjRkSu3nDarreVdGGndHEBJ6cXPdKguS8JGxwj5HA5xIbVKSmLgr5b3AWxtRfvQ==", + "dev": true, + "dependencies": { + "hachure-fill": "^0.5.2", + "path-data-parser": "^0.1.0", + "points-on-curve": "^0.2.0", + "points-on-path": "^0.2.1" + } + }, + "node_modules/rw": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/rw/-/rw-1.3.3.tgz", + "integrity": "sha512-PdhdWy89SiZogBLaw42zdeqtRJ//zFd2PgQavcICDUgJT5oW10QCRKbJ6bg4r0/UY2M6BWd5tkxuGFRvCkgfHQ==", + "dev": true + }, + "node_modules/rxjs": { + "version": "7.8.2", + "resolved": "https://registry.npmjs.org/rxjs/-/rxjs-7.8.2.tgz", + "integrity": "sha512-dhKf903U/PQZY6boNNtAGdWbG85WAbjT/1xYoZIC7FAY0yWapOBQVsVrDl58W86//e1VpMNBtRV4MaXfdMySFA==", + "dev": true, + "dependencies": { + "tslib": "^2.1.0" + } + }, + "node_modules/safer-buffer": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz", + "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==", + "dev": true + }, + "node_modules/search-insights": { + "version": "2.17.3", + "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.17.3.tgz", + "integrity": "sha512-RQPdCYTa8A68uM2jwxoY842xDhvx3E5LFL1LxvxCNMev4o5mLuokczhzjAgGwUZBAmOKZknArSxLKmXtIi2AxQ==", + "dev": true, + "peer": true + }, + "node_modules/shell-quote": { + "version": "1.8.3", + "resolved": "https://registry.npmjs.org/shell-quote/-/shell-quote-1.8.3.tgz", + "integrity": "sha512-ObmnIF4hXNg1BqhnHmgbDETF8dLPCggZWBjkQfhZpbszZnYur5DUljTcCHii5LC3J5E0yeO/1LIMyH+UvHQgyw==", + "dev": true, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/shiki": { + "version": "2.5.0", + "resolved": "https://registry.npmjs.org/shiki/-/shiki-2.5.0.tgz", + "integrity": "sha512-mI//trrsaiCIPsja5CNfsyNOqgAZUb6VpJA+340toL42UpzQlXpwRV9nch69X6gaUxrr9kaOOa6e3y3uAkGFxQ==", + "dev": true, + "dependencies": { + "@shikijs/core": "2.5.0", + "@shikijs/engine-javascript": "2.5.0", + "@shikijs/engine-oniguruma": "2.5.0", + "@shikijs/langs": "2.5.0", + "@shikijs/themes": "2.5.0", + "@shikijs/types": "2.5.0", + "@shikijs/vscode-textmate": "^10.0.2", + "@types/hast": "^3.0.4" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/space-separated-tokens": { + "version": "2.0.2", + "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz", + "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/speakingurl": { + "version": "14.0.1", + "resolved": "https://registry.npmjs.org/speakingurl/-/speakingurl-14.0.1.tgz", + "integrity": "sha512-1POYv7uv2gXoyGFpBCmpDVSNV74IfsWlDW216UPjbWufNf+bSU6GdbDsxdcxtfwb4xlI3yxzOTKClUosxARYrQ==", + "dev": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/string-width": { + "version": "4.2.3", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz", + "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==", + "dev": true, + "dependencies": { + "emoji-regex": "^8.0.0", + "is-fullwidth-code-point": "^3.0.0", + "strip-ansi": "^6.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/stringify-entities": { + "version": "4.0.4", + "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz", + "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==", + "dev": true, + "dependencies": { + "character-entities-html4": "^2.0.0", + "character-entities-legacy": "^3.0.0" + }, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/strip-ansi": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz", + "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==", + "dev": true, + "dependencies": { + "ansi-regex": "^5.0.1" + }, + "engines": { + "node": ">=8" + } + }, + "node_modules/stylis": { + "version": "4.3.6", + "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.3.6.tgz", + "integrity": "sha512-yQ3rwFWRfwNUY7H5vpU0wfdkNSnvnJinhF9830Swlaxl03zsOjCfmX0ugac+3LtK0lYSgwL/KXc8oYL3mG4YFQ==", + "dev": true + }, + "node_modules/superjson": { + "version": "2.2.6", + "resolved": "https://registry.npmjs.org/superjson/-/superjson-2.2.6.tgz", + "integrity": "sha512-H+ue8Zo4vJmV2nRjpx86P35lzwDT3nItnIsocgumgr0hHMQ+ZGq5vrERg9kJBo5AWGmxZDhzDo+WVIJqkB0cGA==", + "dev": true, + "dependencies": { + "copy-anything": "^4" + }, + "engines": { + "node": ">=16" + } + }, + "node_modules/supports-color": { + "version": "8.1.1", + "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz", + "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==", + "dev": true, + "dependencies": { + "has-flag": "^4.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/supports-color?sponsor=1" + } + }, + "node_modules/tabbable": { + "version": "6.4.0", + "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.4.0.tgz", + "integrity": "sha512-05PUHKSNE8ou2dwIxTngl4EzcnsCDZGJ/iCLtDflR/SHB/ny14rXc+qU5P4mG9JkusiV7EivzY9Mhm55AzAvCg==", + "dev": true + }, + "node_modules/tinyexec": { + "version": "1.0.4", + "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.0.4.tgz", + "integrity": "sha512-u9r3uZC0bdpGOXtlxUIdwf9pkmvhqJdrVCH9fapQtgy/OeTTMZ1nqH7agtvEfmGui6e1XxjcdrlxvxJvc3sMqw==", + "dev": true, + "engines": { + "node": ">=18" + } + }, + "node_modules/tree-kill": { + "version": "1.2.2", + "resolved": "https://registry.npmjs.org/tree-kill/-/tree-kill-1.2.2.tgz", + "integrity": "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A==", + "dev": true, + "bin": { + "tree-kill": "cli.js" + } + }, + "node_modules/trim-lines": { + "version": "3.0.1", + "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz", + "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + }, + "node_modules/ts-dedent": { + "version": "2.2.0", + "resolved": "https://registry.npmjs.org/ts-dedent/-/ts-dedent-2.2.0.tgz", + "integrity": "sha512-q5W7tVM71e2xjHZTlgfTDoPF/SmqKG5hddq9SzR49CH2hayqRKJtQ4mtRlSxKaJlR/+9rEM+mnBHf7I2/BQcpQ==", + "dev": true, + "engines": { + "node": ">=6.10" + } + }, + "node_modules/tslib": { + "version": "2.8.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz", + "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==", + "dev": true + }, + "node_modules/ufo": { + "version": "1.6.3", + "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.3.tgz", + "integrity": "sha512-yDJTmhydvl5lJzBmy/hyOAA0d+aqCBuwl818haVdYCRrWV84o7YyeVm4QlVHStqNrrJSTb6jKuFAVqAFsr+K3Q==", + "dev": true + }, + "node_modules/unist-util-is": { + "version": "6.0.1", + "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz", + "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-position": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz", + "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-stringify-position": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz", + "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/unist-util-visit": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz", + "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==", + "dev": true, + "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.2", + "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz", + "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-is": "^6.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/uuid": { + "version": "11.1.0", + "resolved": "https://registry.npmjs.org/uuid/-/uuid-11.1.0.tgz", + "integrity": "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A==", + "dev": true, + "funding": [ + "https://github.com/sponsors/broofa", + "https://github.com/sponsors/ctavan" + ], + "bin": { + "uuid": "dist/esm/bin/uuid" + } + }, + "node_modules/vfile": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz", + "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0", + "vfile-message": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vfile-message": { + "version": "4.0.3", + "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz", + "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==", + "dev": true, + "dependencies": { + "@types/unist": "^3.0.0", + "unist-util-stringify-position": "^4.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/unified" + } + }, + "node_modules/vite": { + "version": "5.4.21", + "resolved": "https://registry.npmjs.org/vite/-/vite-5.4.21.tgz", + "integrity": "sha512-o5a9xKjbtuhY6Bi5S3+HvbRERmouabWbyUcpXXUA1u+GNUKoROi9byOJ8M0nHbHYHkYICiMlqxkg1KkYmm25Sw==", + "dev": true, + "dependencies": { + "esbuild": "^0.21.3", + "postcss": "^8.4.43", + "rollup": "^4.20.0" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^18.0.0 || >=20.0.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^18.0.0 || >=20.0.0", + "less": "*", + "lightningcss": "^1.21.0", + "sass": "*", + "sass-embedded": "*", + "stylus": "*", + "sugarss": "*", + "terser": "^5.4.0" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "less": { + "optional": true + }, + "lightningcss": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + } + } + }, + "node_modules/vitepress": { + "version": "1.6.4", + "resolved": "https://registry.npmjs.org/vitepress/-/vitepress-1.6.4.tgz", + "integrity": "sha512-+2ym1/+0VVrbhNyRoFFesVvBvHAVMZMK0rw60E3X/5349M1GuVdKeazuksqopEdvkKwKGs21Q729jX81/bkBJg==", + "dev": true, + "dependencies": { + "@docsearch/css": "3.8.2", + "@docsearch/js": "3.8.2", + "@iconify-json/simple-icons": "^1.2.21", + "@shikijs/core": "^2.1.0", + "@shikijs/transformers": "^2.1.0", + "@shikijs/types": "^2.1.0", + "@types/markdown-it": "^14.1.2", + "@vitejs/plugin-vue": "^5.2.1", + "@vue/devtools-api": "^7.7.0", + "@vue/shared": "^3.5.13", + "@vueuse/core": "^12.4.0", + "@vueuse/integrations": "^12.4.0", + "focus-trap": "^7.6.4", + "mark.js": "8.11.1", + "minisearch": "^7.1.1", + "shiki": "^2.1.0", + "vite": "^5.4.14", + "vue": "^3.5.13" + }, + "bin": { + "vitepress": "bin/vitepress.js" + }, + "peerDependencies": { + "markdown-it-mathjax3": "^4", + "postcss": "^8" + }, + "peerDependenciesMeta": { + "markdown-it-mathjax3": { + "optional": true + }, + "postcss": { + "optional": true + } + } + }, + "node_modules/vitepress-plugin-mermaid": { + "version": "2.0.17", + "resolved": "https://registry.npmjs.org/vitepress-plugin-mermaid/-/vitepress-plugin-mermaid-2.0.17.tgz", + "integrity": "sha512-IUzYpwf61GC6k0XzfmAmNrLvMi9TRrVRMsUyCA8KNXhg/mQ1VqWnO0/tBVPiX5UoKF1mDUwqn5QV4qAJl6JnUg==", + "dev": true, + "optionalDependencies": { + "@mermaid-js/mermaid-mindmap": "^9.3.0" + }, + "peerDependencies": { + "mermaid": "10 || 11", + "vitepress": "^1.0.0 || ^1.0.0-alpha" + } + }, + "node_modules/vscode-jsonrpc": { + "version": "8.2.0", + "resolved": "https://registry.npmjs.org/vscode-jsonrpc/-/vscode-jsonrpc-8.2.0.tgz", + "integrity": "sha512-C+r0eKJUIfiDIfwJhria30+TYWPtuHJXHtI7J0YlOmKAo7ogxP20T0zxB7HZQIFhIyvoBPwWskjxrvAtfjyZfA==", + "dev": true, + "engines": { + "node": ">=14.0.0" + } + }, + "node_modules/vscode-languageserver": { + "version": "9.0.1", + "resolved": "https://registry.npmjs.org/vscode-languageserver/-/vscode-languageserver-9.0.1.tgz", + "integrity": "sha512-woByF3PDpkHFUreUa7Hos7+pUWdeWMXRd26+ZX2A8cFx6v/JPTtd4/uN0/jB6XQHYaOlHbio03NTHCqrgG5n7g==", + "dev": true, + "dependencies": { + "vscode-languageserver-protocol": "3.17.5" + }, + "bin": { + "installServerIntoExtension": "bin/installServerIntoExtension" + } + }, + "node_modules/vscode-languageserver-protocol": { + "version": "3.17.5", + "resolved": "https://registry.npmjs.org/vscode-languageserver-protocol/-/vscode-languageserver-protocol-3.17.5.tgz", + "integrity": "sha512-mb1bvRJN8SVznADSGWM9u/b07H7Ecg0I3OgXDuLdn307rl/J3A9YD6/eYOssqhecL27hK1IPZAsaqh00i/Jljg==", + "dev": true, + "dependencies": { + "vscode-jsonrpc": "8.2.0", + "vscode-languageserver-types": "3.17.5" + } + }, + "node_modules/vscode-languageserver-textdocument": { + "version": "1.0.12", + "resolved": "https://registry.npmjs.org/vscode-languageserver-textdocument/-/vscode-languageserver-textdocument-1.0.12.tgz", + "integrity": "sha512-cxWNPesCnQCcMPeenjKKsOCKQZ/L6Tv19DTRIGuLWe32lyzWhihGVJ/rcckZXJxfdKCFvRLS3fpBIsV/ZGX4zA==", + "dev": true + }, + "node_modules/vscode-languageserver-types": { + "version": "3.17.5", + "resolved": "https://registry.npmjs.org/vscode-languageserver-types/-/vscode-languageserver-types-3.17.5.tgz", + "integrity": "sha512-Ld1VelNuX9pdF39h2Hgaeb5hEZM2Z3jUrrMgWQAu82jMtZp7p3vJT3BzToKtZI7NgQssZje5o0zryOrhQvzQAg==", + "dev": true + }, + "node_modules/vscode-uri": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/vscode-uri/-/vscode-uri-3.1.0.tgz", + "integrity": "sha512-/BpdSx+yCQGnCvecbyXdxHDkuk55/G3xwnC0GqY4gmQ3j+A+g8kzzgB4Nk/SINjqn6+waqw3EgbVF2QKExkRxQ==", + "dev": true + }, + "node_modules/vue": { + "version": "3.5.31", + "resolved": "https://registry.npmjs.org/vue/-/vue-3.5.31.tgz", + "integrity": "sha512-iV/sU9SzOlmA/0tygSmjkEN6Jbs3nPoIPFhCMLD2STrjgOU8DX7ZtzMhg4ahVwf5Rp9KoFzcXeB1ZrVbLBp5/Q==", + "dev": true, + "dependencies": { + "@vue/compiler-dom": "3.5.31", + "@vue/compiler-sfc": "3.5.31", + "@vue/runtime-dom": "3.5.31", + "@vue/server-renderer": "3.5.31", + "@vue/shared": "3.5.31" + }, + "peerDependencies": { + "typescript": "*" + }, + "peerDependenciesMeta": { + "typescript": { + "optional": true + } + } + }, + "node_modules/wrap-ansi": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-7.0.0.tgz", + "integrity": "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^4.0.0", + "string-width": "^4.1.0", + "strip-ansi": "^6.0.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, + "node_modules/y18n": { + "version": "5.0.8", + "resolved": "https://registry.npmjs.org/y18n/-/y18n-5.0.8.tgz", + "integrity": "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==", + "dev": true, + "engines": { + "node": ">=10" + } + }, + "node_modules/yargs": { + "version": "17.7.2", + "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", + "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==", + "dev": true, + "dependencies": { + "cliui": "^8.0.1", + "escalade": "^3.1.1", + "get-caller-file": "^2.0.5", + "require-directory": "^2.1.1", + "string-width": "^4.2.3", + "y18n": "^5.0.5", + "yargs-parser": "^21.1.1" + }, + "engines": { + "node": ">=12" + } + }, + "node_modules/yargs-parser": { + "version": "21.1.1", + "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz", + "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==", + "dev": true, + "engines": { + "node": ">=12" + } + }, + "node_modules/zwitch": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz", + "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==", + "dev": true, + "funding": { + "type": "github", + "url": "https://github.com/sponsors/wooorm" + } + } + } +} diff --git a/package.json b/package.json new file mode 100644 index 0000000..5a5ef15 --- /dev/null +++ b/package.json @@ -0,0 +1,14 @@ +{ + "private": true, + "scripts": { + "mdsnippets": "mdsnippets", + "docs": "concurrently --group mdsnippets \"vitepress dev docs --port 5050 --open\"", + "docs-build": "concurrently --group mdsnippets \"vitepress build docs\"" + }, + "devDependencies": { + "concurrently": "^9.1.2", + "vitepress": "^1.6.3", + "vitepress-plugin-mermaid": "^2.0.17", + "mermaid": "^11.4.1" + } +} diff --git a/src/DocSamples/ArgumentFlagSamples.cs b/src/DocSamples/ArgumentFlagSamples.cs new file mode 100644 index 0000000..4095687 --- /dev/null +++ b/src/DocSamples/ArgumentFlagSamples.cs @@ -0,0 +1,25 @@ +using JasperFx.CommandLine; + +namespace DocSamples; + +#region sample_build_input +public class BuildInput +{ + [Description("The target configuration")] + public string Configuration { get; set; } = "Debug"; + + [Description("The output directory")] + public string OutputPath { get; set; } = "./bin"; + + [FlagAlias("verbose", 'v')] + [Description("Enable verbose output")] + public bool VerboseFlag { get; set; } + + [FlagAlias("force", 'f')] + [Description("Force a clean rebuild")] + public bool ForceFlag { get; set; } + + [Description("Maximum degree of parallelism")] + public int ParallelCount { get; set; } = 4; +} +#endregion diff --git a/src/DocSamples/BuiltInFramesSamples.cs b/src/DocSamples/BuiltInFramesSamples.cs new file mode 100644 index 0000000..aee6927 --- /dev/null +++ b/src/DocSamples/BuiltInFramesSamples.cs @@ -0,0 +1,142 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +public class BuiltInFramesSamples +{ + #region sample_comment_frame_usage + + public static void UsingCommentFrame() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Worker", typeof(IWorker)); + var method = type.MethodFor(nameof(IWorker.Execute)); + + // CommentFrame writes a C# comment line + method.Frames.Add(new CommentFrame("Begin processing")); + method.Frames.Code("Console.WriteLine(\"Working...\");"); + } + + public interface IWorker + { + void Execute(); + } + + #endregion + + #region sample_code_frame_usage + + public static void UsingCodeFrame() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Processor", typeof(IProcessor)); + var method = type.MethodFor(nameof(IProcessor.Process)); + + // CodeFrame uses a format string with variable placeholders + method.Frames.Code("Console.WriteLine({0});", Use.Type()); + } + + public interface IProcessor + { + void Process(string input); + } + + #endregion + + #region sample_return_frame_usage + + public static void UsingReturnFrame() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Checker", typeof(IChecker)); + var method = type.MethodFor(nameof(IChecker.IsValid)); + + method.Frames.Code("var result = {0} != null;", Use.Type()); + + // ReturnFrame generates "return ;" + method.Frames.Add(new ReturnFrame(typeof(bool))); + } + + public interface IChecker + { + bool IsValid(object input); + } + + #endregion + + #region sample_if_block_usage + + public static void UsingIfBlock() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Guard", typeof(IGuard)); + var method = type.MethodFor(nameof(IGuard.Check)); + + // IfBlock wraps inner frames in an if statement + var inner = new CodeFrame(false, "Console.WriteLine(\"Input is not null\");"); + method.Frames.Add(new IfBlock("input != null", inner)); + } + + public interface IGuard + { + void Check(object input); + } + + #endregion + + #region sample_constructor_frame_usage + + public static void UsingConstructorFrame() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("ServiceBuilder", typeof(IServiceBuilder)); + var method = type.MethodFor(nameof(IServiceBuilder.Build)); + + // ConstructorFrame generates "var widget = new Widget();" + var ctor = new ConstructorFrame(() => new Widget()); + method.Frames.Add(ctor); + } + + public interface IServiceBuilder + { + Widget Build(); + } + + public class Widget; + + #endregion + + #region sample_method_call_frame_usage + + public static void UsingMethodCallFrame() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Invoker", typeof(IInvoker)); + var method = type.MethodFor(nameof(IInvoker.Invoke)); + + // MethodCall generates a call to a static or instance method + var call = new MethodCall(typeof(Console), nameof(Console.WriteLine)); + method.Frames.Add(call); + } + + public interface IInvoker + { + void Invoke(string message); + } + + #endregion +} diff --git a/src/DocSamples/CliSetupSamples.cs b/src/DocSamples/CliSetupSamples.cs new file mode 100644 index 0000000..37494b7 --- /dev/null +++ b/src/DocSamples/CliSetupSamples.cs @@ -0,0 +1,37 @@ +using JasperFx; +using Microsoft.Extensions.Hosting; + +namespace DocSamples; + +public class CliSetupSamples +{ + public async Task setup_jasperfx_cli() + { + var args = Array.Empty(); + + #region sample_apply_jasperfx_extensions + await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); + #endregion + } + + public async Task run_jasperfx_commands() + { + var args = Array.Empty(); + + #region sample_run_jasperfx_commands + var builder = Host.CreateDefaultBuilder(); + + builder.ConfigureServices(services => + { + // Register your services here + }); + + await builder + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); + #endregion + } +} diff --git a/src/DocSamples/CodegenCliSamples.cs b/src/DocSamples/CodegenCliSamples.cs new file mode 100644 index 0000000..ecdb187 --- /dev/null +++ b/src/DocSamples/CodegenCliSamples.cs @@ -0,0 +1,64 @@ +using JasperFx; +using JasperFx.CodeGeneration; +using Microsoft.Extensions.Hosting; + +namespace DocSamples; + +public class CodegenCliSamples +{ + #region sample_type_load_mode_dynamic + + public static void ConfigureDynamicMode() + { + // Always generate types at runtime. Best for development. + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Dynamic + }; + } + + #endregion + + #region sample_type_load_mode_static + + public static void ConfigureStaticMode() + { + // Types must be pre-built in the application assembly. + // Throws if generated types are missing. + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Static + }; + } + + #endregion + + #region sample_type_load_mode_auto + + public static void ConfigureAutoMode() + { + // Try to load pre-built types first, fall back to runtime generation + var rules = new GenerationRules("MyApp.Generated") + { + TypeLoadMode = TypeLoadMode.Auto + }; + } + + #endregion + + #region sample_codegen_cli_setup + + public static async Task SetupWithCodegenCommand(string[] args) + { + return await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); + + // Run with: dotnet run -- codegen preview + // Run with: dotnet run -- codegen write + // Run with: dotnet run -- codegen delete + } + + #endregion +} diff --git a/src/DocSamples/CodegenOverviewSamples.cs b/src/DocSamples/CodegenOverviewSamples.cs new file mode 100644 index 0000000..1702173 --- /dev/null +++ b/src/DocSamples/CodegenOverviewSamples.cs @@ -0,0 +1,37 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +public class CodegenOverviewSamples +{ + #region sample_codegen_overview + + public static string GenerateGreeterCode() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Add a new type that implements IGreeter + var type = assembly.AddType("HelloGreeter", typeof(IGreeter)); + + // Get the method defined by the interface + var method = type.MethodFor("Greet"); + + // Add a frame that writes a line of code + method.Frames.Code("return \"Hello, \" + {0};", Use.Type()); + + // Generate the C# source code + var code = assembly.GenerateCode(); + + return code; + } + + public interface IGreeter + { + string Greet(string name); + } + + #endregion +} diff --git a/src/DocSamples/ConfigurationSamples.cs b/src/DocSamples/ConfigurationSamples.cs new file mode 100644 index 0000000..205b89d --- /dev/null +++ b/src/DocSamples/ConfigurationSamples.cs @@ -0,0 +1,43 @@ +using JasperFx; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Hosting; + +namespace DocSamples; + +public class ConfigurationSamples +{ + #region sample_critter_stack_defaults + public static IHostBuilder ConfigureWithDefaults() + { + return Host.CreateDefaultBuilder() + .ConfigureServices(services => + { + services.AddJasperFx(opts => + { + // Require a file to exist at application startup + opts.RequireFile("appsettings.json"); + + // Set the development environment name if non-standard + opts.DevelopmentEnvironmentName = "Local"; + }); + }); + } + #endregion + + #region sample_add_jasperfx_options + public static void ConfigureOptions(IServiceCollection services) + { + services.AddJasperFx(opts => + { + // Register an environment check inline + opts.RegisterEnvironmentCheck( + "Database connectivity", + async (sp, ct) => + { + // Verify your database is accessible + await Task.CompletedTask; + }); + }); + } + #endregion +} diff --git a/src/DocSamples/DescribeSamples.cs b/src/DocSamples/DescribeSamples.cs new file mode 100644 index 0000000..e73c414 --- /dev/null +++ b/src/DocSamples/DescribeSamples.cs @@ -0,0 +1,22 @@ +using JasperFx.CommandLine.Descriptions; +using Spectre.Console; + +namespace DocSamples; + +#region sample_custom_system_part +public class MessagingSystemPart : SystemPartBase +{ + public MessagingSystemPart() + : base("Messaging Subsystem", new Uri("system://messaging")) + { + } + + public override Task WriteToConsole() + { + AnsiConsole.MarkupLine("[bold]Transport:[/] RabbitMQ"); + AnsiConsole.MarkupLine("[bold]Queues:[/] 12 active"); + AnsiConsole.MarkupLine("[bold]Consumers:[/] 8 running"); + return Task.CompletedTask; + } +} +#endregion diff --git a/src/DocSamples/DocSamples.csproj b/src/DocSamples/DocSamples.csproj new file mode 100644 index 0000000..18ac9c4 --- /dev/null +++ b/src/DocSamples/DocSamples.csproj @@ -0,0 +1,23 @@ + + + + net10.0 + false + + + + + + + + all + runtime; build; native; contentfiles; analyzers; buildtransitive + + + + + + + + + diff --git a/src/DocSamples/EnvironmentCheckSamples.cs b/src/DocSamples/EnvironmentCheckSamples.cs new file mode 100644 index 0000000..2cf7103 --- /dev/null +++ b/src/DocSamples/EnvironmentCheckSamples.cs @@ -0,0 +1,53 @@ +using JasperFx.Environment; +using Microsoft.Extensions.DependencyInjection; + +namespace DocSamples; + +public class EnvironmentCheckSamples +{ + #region sample_register_environment_check + public static void RegisterChecks(IServiceCollection services) + { + // Async check with IServiceProvider access + services.CheckEnvironment( + "Database is reachable", + async (IServiceProvider sp, CancellationToken ct) => + { + // Throw an exception to indicate failure + await Task.CompletedTask; + }); + + // Synchronous check + services.CheckEnvironment( + "Configuration file exists", + (IServiceProvider sp) => + { + if (!File.Exists("appsettings.json")) + { + throw new FileNotFoundException("Missing configuration file"); + } + }); + } + #endregion + + #region sample_environment_check_with_service + public static void RegisterTypedCheck(IServiceCollection services) + { + services.CheckEnvironment( + "Required config keys present", + config => + { + if (config?.GetValue("ConnectionString") is null) + { + throw new Exception("ConnectionString is required"); + } + }); + } + #endregion +} + +// Placeholder for sample compilation +public interface IConfiguration +{ + T? GetValue(string key); +} diff --git a/src/DocSamples/ExtensionSamples.cs b/src/DocSamples/ExtensionSamples.cs new file mode 100644 index 0000000..9276c7f --- /dev/null +++ b/src/DocSamples/ExtensionSamples.cs @@ -0,0 +1,53 @@ +using JasperFx.Core; +using JasperFx.Core.Reflection; + +namespace DocSamples; + +public class ExtensionSamples +{ + #region sample_string_extensions + public void StringHelpers() + { + // Convert to camel case + var camel = "SomePropertyName".ToCamelCase(); + // => "somePropertyName" + + // Check if a string is empty or whitespace + var isEmpty = "".IsEmpty(); + var isNotEmpty = "hello".IsNotEmpty(); + + // Joining strings + var joined = new[] { "one", "two", "three" }.Join(", "); + } + #endregion + + #region sample_enumerable_extensions + public void EnumerableHelpers() + { + var items = new List { "a", "b", "c", "a" }; + + // AddRange that works on IList + items.Fill("d"); + + // Add only if not already present + items.Fill("a"); // no-op if already present + + // Each / EachAsync for side effects + items.Each(item => Console.WriteLine(item)); + } + #endregion + + #region sample_reflection_extensions + public void ReflectionHelpers() + { + // Check if a type implements an interface + var implements = typeof(List).CanBeCastTo>(); + + // Get a human-readable type name + var name = typeof(Dictionary).FullNameInCode(); + + // Close an open generic type + var closed = typeof(List<>).CloseAndBuildAs(typeof(string)); + } + #endregion +} diff --git a/src/DocSamples/FramesSamples.cs b/src/DocSamples/FramesSamples.cs new file mode 100644 index 0000000..ab399fa --- /dev/null +++ b/src/DocSamples/FramesSamples.cs @@ -0,0 +1,81 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +#region sample_custom_sync_frame + +public class LogMessageFrame : SyncFrame +{ + private readonly string _message; + private Variable? _logger; + + public LogMessageFrame(string message) + { + _message = message; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + writer.Write($"Console.WriteLine(\"{_message}\");"); + + // Always call through to the next frame in the chain + Next?.GenerateCode(method, writer); + } +} + +#endregion + +#region sample_custom_async_frame + +public class LoadEntityFrame : AsyncFrame +{ + private readonly Type _entityType; + private Variable? _id; + + public LoadEntityFrame(Type entityType) + { + _entityType = entityType; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + var entityVariable = Create(_entityType); + + writer.Write( + $"var {entityVariable.Usage} = await repository.LoadAsync<{_entityType.Name}>({_id?.Usage ?? "id"});"); + + Next?.GenerateCode(method, writer); + } +} + +#endregion + +#region sample_wrapping_frame + +public class StopwatchFrame : SyncFrame +{ + public StopwatchFrame() + { + // Mark this frame as wrapping inner frames + Wraps = true; + } + + public override void GenerateCode(GeneratedMethod method, ISourceWriter writer) + { + writer.Write("var stopwatch = System.Diagnostics.Stopwatch.StartNew();"); + writer.Write("BLOCK:try"); + + // Let the inner frames generate their code + Next?.GenerateCode(method, writer); + + writer.FinishBlock(); // end try + writer.Write("BLOCK:finally"); + writer.Write("stopwatch.Stop();"); + writer.Write("Console.WriteLine($\"Elapsed: {stopwatch.ElapsedMilliseconds}ms\");"); + writer.FinishBlock(); // end finally + } +} + +#endregion diff --git a/src/DocSamples/GeneratedTypesSamples.cs b/src/DocSamples/GeneratedTypesSamples.cs new file mode 100644 index 0000000..5f40119 --- /dev/null +++ b/src/DocSamples/GeneratedTypesSamples.cs @@ -0,0 +1,123 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +public class GeneratedTypesSamples +{ + #region sample_building_generated_type + + public static string BuildGeneratedType() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Create a type that inherits from a base class + var type = assembly.AddType("MyMessageHandler", typeof(MessageHandlerBase)); + + // The method defined on the base class is discovered automatically. + // Retrieve it by name. + var handleMethod = type.MethodFor("Handle"); + + // Add frames to define the method body + handleMethod.Frames.Code("Console.WriteLine(\"Handling message...\");"); + handleMethod.Frames.Code("return Task.CompletedTask;"); + + // Generate all source code for the assembly + var code = assembly.GenerateCode(); + + return code; + } + + public abstract class MessageHandlerBase + { + public abstract Task Handle(Message message); + } + + public class Message; + + #endregion + + #region sample_generated_type_with_interface + + public static string ImplementInterface() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + // Create a type that implements an interface + var type = assembly.AddType("WidgetValidator", typeof(IValidator)); + + var method = type.MethodFor(nameof(IValidator.Validate)); + method.Frames.Code("return {0} != null;", Use.Type()); + + return assembly.GenerateCode(); + } + + public interface IValidator + { + bool Validate(object input); + } + + #endregion + + #region sample_generated_type_injected_fields + + public static string TypeWithInjectedFields() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("NotificationSender", typeof(NotificationSenderBase)); + + // The InjectedField appears as a constructor argument and private field + var loggerField = new InjectedField(typeof(ILogger)); + type.AllInjectedFields.Add(loggerField); + + var method = type.MethodFor("Send"); + method.Frames.Code("Console.WriteLine(\"Sending notification\");"); + + return assembly.GenerateCode(); + } + + public abstract class NotificationSenderBase + { + public abstract void Send(string recipient, string body); + } + + public interface ILogger + { + void Log(string message); + } + + #endregion + + #region sample_generated_method_custom + + public static string AddCustomMethod() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("Calculator", typeof(object)); + + // Add a custom void method + var method = type.AddVoidMethod("PrintSum", + new Argument(typeof(int), "a"), + new Argument(typeof(int), "b")); + + method.Frames.Code("Console.WriteLine(a + b);"); + + // Add a method that returns a value + var multiply = type.AddMethodThatReturns("Multiply", + new Argument(typeof(int), "x"), + new Argument(typeof(int), "y")); + + multiply.Frames.Code("return x * y;"); + + return assembly.GenerateCode(); + } + + #endregion +} diff --git a/src/DocSamples/MethodCallSamples.cs b/src/DocSamples/MethodCallSamples.cs new file mode 100644 index 0000000..b00bf16 --- /dev/null +++ b/src/DocSamples/MethodCallSamples.cs @@ -0,0 +1,116 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +public class MethodCallSamples +{ + #region sample_method_call_basic + + public static void BasicMethodCall() + { + // Create a MethodCall by type and method name + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + + // The ReturnVariable is automatically created from the method's return type + Console.WriteLine(call.ReturnVariable!.VariableType); // typeof(OrderResult) + + // Arguments array matches the method's parameters + Console.WriteLine(call.Arguments.Length); // matches parameter count + } + + #endregion + + #region sample_method_call_async + + public static void AsyncMethodCall() + { + // Async methods are automatically detected + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrderAsync)); + + // The frame knows it is async + Console.WriteLine(call.IsAsync); // true + + // ReturnType unwraps Task to T + Console.WriteLine(call.ReturnVariable!.VariableType); // typeof(OrderResult) + } + + #endregion + + #region sample_method_call_return_action + + public static void ReturnActions() + { + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + + // Initialize: generates "var orderResult = ProcessOrder(...);" + call.ReturnAction = ReturnAction.Initialize; + + // Assign: generates "orderResult = ProcessOrder(...);" + call.ReturnAction = ReturnAction.Assign; + + // Return: generates "return ProcessOrder(...);" + call.ReturnAction = ReturnAction.Return; + } + + #endregion + + #region sample_method_call_disposal + + public static void disposal_mode_example() + { + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.CreateConnection)); + + // Wrap the return value in a using block + call.DisposalMode = DisposalMode.UsingBlock; + } + + #endregion + + #region sample_method_call_in_generated_type + + public static string UseMethodCallInGeneratedType() + { + var rules = new GenerationRules("MyApp.Generated"); + var assembly = new GeneratedAssembly(rules); + + var type = assembly.AddType("OrderHandler", typeof(IOrderHandler)); + var method = type.MethodFor(nameof(IOrderHandler.Handle)); + + // Add a MethodCall frame + var call = new MethodCall(typeof(OrderProcessor), nameof(OrderProcessor.ProcessOrder)); + method.Frames.Add(call); + + return assembly.GenerateCode(); + } + + #endregion + + public interface IOrderHandler + { + OrderResult Handle(Order order); + } + + public class Order; + + public class OrderResult; + + public class OrderProcessor + { + public static OrderResult ProcessOrder(Order order) + { + return new OrderResult(); + } + + public static Task ProcessOrderAsync(Order order) + { + return Task.FromResult(new OrderResult()); + } + + public static IDisposable CreateConnection() + { + throw new NotImplementedException(); + } + } +} diff --git a/src/DocSamples/QuickStartSamples.cs b/src/DocSamples/QuickStartSamples.cs new file mode 100644 index 0000000..45664a9 --- /dev/null +++ b/src/DocSamples/QuickStartSamples.cs @@ -0,0 +1,19 @@ +using JasperFx; +using Microsoft.Extensions.Hosting; + +namespace DocSamples; + +public class QuickStartSamples +{ + public async Task quickstart_minimal() + { + var args = Array.Empty(); + + #region sample_quickstart_minimal + await Host + .CreateDefaultBuilder() + .ApplyJasperFxExtensions() + .RunJasperFxCommands(args); + #endregion + } +} diff --git a/src/DocSamples/VariablesSamples.cs b/src/DocSamples/VariablesSamples.cs new file mode 100644 index 0000000..e45bbb9 --- /dev/null +++ b/src/DocSamples/VariablesSamples.cs @@ -0,0 +1,61 @@ +using JasperFx.CodeGeneration; +using JasperFx.CodeGeneration.Frames; +using JasperFx.CodeGeneration.Model; + +namespace DocSamples; + +public class VariablesSamples +{ + #region sample_variable_creation + + public static void CreateVariables() + { + // Create a variable with an auto-generated name based on the type + var widget = new Variable(typeof(Widget), "widget"); + + // The Usage property is the C# identifier used in generated code + Console.WriteLine(widget.Usage); // "widget" + + // DefaultArgName generates a camelCase name from the type + var defaultName = Variable.DefaultArgName(typeof(Widget)); + Console.WriteLine(defaultName); // "widget" + + // Variable tied to a creating Frame + var frame = new MethodCall(typeof(WidgetFactory), nameof(WidgetFactory.Build)); + var returnVar = frame.ReturnVariable; + Console.WriteLine(returnVar!.Creator == frame); // true + } + + #endregion + + #region sample_variable_default_arg_names + + public static void DefaultArgNameExamples() + { + // Simple types use lowercase type name + Console.WriteLine(Variable.DefaultArgName(typeof(Widget))); // "widget" + + // Arrays get "Array" suffix + Console.WriteLine(Variable.DefaultArgName(typeof(int[]))); // "intArray" + + // Generic types include inner type + Console.WriteLine(Variable.DefaultArgName(typeof(List))); // "listOfString" + + // Reserved C# keywords get an @ prefix + Console.WriteLine(Variable.DefaultArgName(typeof(Event))); // "@event" + } + + #endregion + + public class Widget; + + public class Event; + + public class WidgetFactory + { + public static Widget Build() + { + return new Widget(); + } + } +} diff --git a/src/DocSamples/WritingCommandSamples.cs b/src/DocSamples/WritingCommandSamples.cs new file mode 100644 index 0000000..a3d5c61 --- /dev/null +++ b/src/DocSamples/WritingCommandSamples.cs @@ -0,0 +1,36 @@ +using JasperFx.CommandLine; + +namespace DocSamples; + +#region sample_greeting_input +public class GreetingInput +{ + [Description("The name to greet")] + public string Name { get; set; } = "World"; +} +#endregion + +#region sample_greeting_command +[Description("Say hello to someone")] +public class GreetingCommand : JasperFxCommand +{ + public override bool Execute(GreetingInput input) + { + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +#endregion + +#region sample_async_greeting_command +[Description("Say hello to someone asynchronously")] +public class AsyncGreetingCommand : JasperFxAsyncCommand +{ + public override async Task Execute(GreetingInput input) + { + await Task.Delay(100); + Console.WriteLine($"Hello, {input.Name}!"); + return true; + } +} +#endregion