Please address the comments from this code review:
## Overall Comments
- In Navbars.razor.cs sample code, initialize `_dropdownItems` using `new List<SelectedItem>()` (or `new()`) instead of the invalid `[]` literal.
- You renamed the site CSS selector from `.navbar` to `.navbar-header`; make sure the Navbar component’s markup and classes align with this change so your styles still apply.
- The media‐query blocks in Navbar.razor.scss are almost identical—consider using a mixin or loop to DRY up the repetitive code.

## Individual Comments

### Comment 1
<location> `src/BootstrapBlazor/Components/Navbar/NavbarGroup.razor.cs:31` </location>
<code_context>
+    [Parameter]
+    public string? Height { get; set; }
+
+    private string? ClassString => CssBuilder.Default("navbar-nav")
+        .AddClass("navbar-nav-scroll", IsScrolling)
+        .AddClassFromAttributes(AdditionalAttributes)
</code_context>

<issue_to_address>
Consider refactoring the repeated CSS builder logic into a shared base class or helper to centralize and simplify navbar component styling.

Consider extracting the duplicated CSS‐builder logic into a shared base class or helper. This both DRYs up your Navbar* components and avoids pulling in the same `AdditionalAttributes` twice (which can collide). For example:

1) Shared abstract base:

```csharp
// NavbarBase.cs
public abstract class NavbarBase : ComponentBase
{
    [Parameter] public bool    IsScrolling          { get; set; }
    [Parameter] public string? Height               { get; set; } = "200px";
    [Parameter(CaptureUnmatchedValues = true)]
    public IDictionary<string, object>? AdditionalAttributes { get; set; }

    protected string BuildNavClass(string defaultClass) => CssBuilder
        .Default(defaultClass)
        .AddClass("navbar-nav-scroll", IsScrolling)
        .AddClassFromAttributes(AdditionalAttributes)
        .Build();

    protected string BuildNavStyle() => CssBuilder
        .Default()
        .AddStyle("--bs-scroll-height", Height, IsScrolling)
        .AddStyleFromAttributes(AdditionalAttributes)
        .Build();
}
```

```csharp
// NavbarGroup.razor.cs
public partial class NavbarGroup : NavbarBase
{
    private string? ClassString => BuildNavClass("navbar-nav");
    private string? StyleString => BuildNavStyle();

    // … other parameters / logic …
}
```

2) Or as extension methods:

```csharp
public static class NavbarCssExtensions
{
    public static CssBuilder AddNavbarAttributes(this CssBuilder builder, bool scrolling, IDictionary<string, object>? attrs) =>
        builder.AddClass("navbar-nav-scroll", scrolling)
               .AddClassFromAttributes(attrs);

    public static CssBuilder AddNavbarAttributes(this CssBuilder builder, string? height, bool scrolling, IDictionary<string, object>? attrs) =>
        builder.AddStyle("--bs-scroll-height", height, scrolling)
               .AddStyleFromAttributes(attrs);
}
```

```csharp
// usage in NavbarGroup.razor.cs
private string? ClassString =>
    CssBuilder.Default("navbar-nav")
              .AddNavbarAttributes(IsScrolling, AdditionalAttributes)
              .Build();

private string? StyleString =>
    CssBuilder.Default()
              .AddNavbarAttributes(Height, IsScrolling, AdditionalAttributes)
              .Build();
```

Either approach removes the nearly‐identical pattern from every navbar subcomponent and centralizes the `class`/`style` merging logic.
</issue_to_address>

### Comment 2
<location> `src/BootstrapBlazor/Components/Navbar/NavbarItem.razor.cs:19` </location>
<code_context>
+    [Parameter]
+    public RenderFragment? ChildContent { get; set; }
+
+    private string? ClassString => CssBuilder.Default("navbar-item")
+        .AddClassFromAttributes(AdditionalAttributes)
+        .Build();
</code_context>

<issue_to_address>
Consider refactoring shared logic into a base class so each navigation child only overrides its default CSS class.

Consider extracting the common bits into a small base class so each nav-child only needs to override its default css class. For example:

```csharp
// NavItemBase.cs
public abstract class NavItemBase : ComponentBase
{
    [Parameter] public RenderFragment? ChildContent { get; set; }
    [Parameter(CaptureUnmatchedValues = true)]
    public IReadOnlyDictionary<string, object>? AdditionalAttributes { get; set; }

    protected abstract string DefaultCss { get; }
    protected string ClassString => CssBuilder
        .Default(DefaultCss)
        .AddClassFromAttributes(AdditionalAttributes)
        .Build();
}
```

Then your NavbarItem becomes trivial:

```csharp
// NavbarItem.razor.cs
public partial class NavbarItem : NavItemBase
{
    protected override string DefaultCss => "navbar-item";
}
```

If you have other siblings (e.g. `NavLink`, `NavDropdown`), they all just override `DefaultCss` and inherit the same `ChildContent` + `ClassString` logic.
</issue_to_address>