### Configure WebMarkupMin Services and Middleware

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-Latest

This snippet shows the setup of WebMarkupMin services and the HTTP request pipeline in Program.cs for ASP.NET Core 8+. Ensure UseWebMarkupMin is called before route registration.

```csharp
using WebMarkupMin.AspNetCoreLatest;
…

var builder = WebApplication.CreateBuilder(args);

#region Configure services

IServiceCollection services = builder.Services;

…
// Add WebMarkupMin services.
services.AddWebMarkupMin()
    .AddHtmlMinification()
    .AddXmlMinification()
    .AddHttpCompression()
    ;

// Add framework services.
services.AddControllersWithViews();
…

#endregion

#region Configure the HTTP request pipeline

var app = builder.Build();

…
app.UseWebMarkupMin();

app.MapControllerRoute(
…
);

#endregion

app.Run();

```

--------------------------------

### Configure WebMarkupMin Services in ASP.NET Core 1.X

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-1.X

In the ConfigureServices method of the Startup class, add WebMarkupMin services using extension methods like AddWebMarkupMin, AddHtmlMinification, AddXmlMinification, and AddHttpCompression. This setup is crucial for enabling minification and compression features.

```csharp
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

using WebMarkupMin.AspNetCore1;
…

namespace WebMarkupMin.Sample.AspNetCore1.Mvc1
{
    public class Startup
    {
        …
        // This method gets called by the runtime.
        // Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            …
            // Add WebMarkupMin services.
            services.AddWebMarkupMin()
                .AddHtmlMinification()
                .AddXmlMinification()
                .AddHttpCompression()
                ;

            // Add framework services.
            services.AddMvc();
            …
        }

        // This method gets called by the runtime.
        // Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env,
            ILoggerFactory loggerFactory)
        {
            …
            app.UseWebMarkupMin();

            app.UseMvc(routes =>
            {
                …
            });
        }
    }
}
```

--------------------------------

### Configure WebMarkupMin Services in ASP.NET Core

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-3.1+

Add WebMarkupMin services to the dependency injection container and configure options for minification and compression. This setup allows minification and compression even in development environments.

```csharp
using System.Collections.Generic;
using System.IO.Compression;

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

using WebMarkupMin.AspNet.Common.Compressors;
using WebMarkupMin.AspNet.Common.UrlMatchers;
using WebMarkupMin.AspNetCore3;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;

namespace WebMarkupMin.Sample.AspNetCore31.Mvc31
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddWebMarkupMin(options =>
            {
                options.AllowMinificationInDevelopmentEnvironment = true;
                options.AllowCompressionInDevelopmentEnvironment = true;
            })
                .AddHtmlMinification(options =>
                {
                    options.ExcludedPages = new List<IUrlMatcher>
                    {
                        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
                        new ExactUrlMatcher("/contact")
                    };

                    HtmlMinificationSettings settings = options.MinificationSettings;
                    settings.RemoveRedundantAttributes = true;
                    settings.RemoveHttpProtocolFromAttributes = true;
                    settings.RemoveHttpsProtocolFromAttributes = true;

                    options.CssMinifierFactory = new NUglifyCssMinifierFactory();
                    options.JsMinifierFactory = new NUglifyJsMinifierFactory();
                })
                .AddXhtmlMinification(options =>
                {
                    options.IncludedPages = new List<IUrlMatcher>
                    {
                        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
                        new ExactUrlMatcher("/contact")
                    };

                    XhtmlMinificationSettings settings = options.MinificationSettings;
                    settings.RemoveRedundantAttributes = true;
                    settings.RemoveHttpProtocolFromAttributes = true;
                    settings.RemoveHttpsProtocolFromAttributes = true;

                    options.CssMinifierFactory = new KristensenCssMinifierFactory();
                    options.JsMinifierFactory = new CrockfordJsMinifierFactory();
                })
                .AddXmlMinification(options =>
                {
                    XmlMinificationSettings settings = options.MinificationSettings;
                    settings.CollapseTagsWithoutContent = true;
                })
                .AddHttpCompression(options =>
                {
                    options.CompressorFactories = new List<ICompressorFactory>
                    {
                        new BuiltInBrotliCompressorFactory(new BuiltInBrotliCompressionSettings
                        {
                            Level = CompressionLevel.Fastest
                        }),
                        new DeflateCompressorFactory(new DeflateCompressionSettings
                        {
                            Level = CompressionLevel.Fastest
                        }),
                        new GZipCompressorFactory(new GZipCompressionSettings
                        {
                            Level = CompressionLevel.Fastest
                        })
                    };
                });
        }
    }
}
```

--------------------------------

### Configure Supported HTTP Methods

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Extensions

Change the default behavior to minify and compress only GET requests. Supports specifying multiple HTTP methods.

```csharp
….SupportedHttpMethods = new HashSet<string> { "GET", "POST" };
```

--------------------------------

### Advanced XML Minification with Settings and Logger

Source: https://github.com/taritsyn/webmarkupmin/wiki/XML-Minifier

Shows advanced XML minification using XmlMinifier with custom settings and a logger. This example demonstrates how to configure minification behavior and integrate logging for debugging or monitoring purposes.

```csharp
using System;
using System.Collections.Generic;
using System.Text;

using WebMarkupMin.Core;
using WebMarkupMin.Core.Loggers;

namespace WebMarkupMin.Sample.ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            const string xmlInput = @"<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>
<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">
    <url>
        <loc>https://webmarkupmin.bsite.net/</loc>
        <changefreq>hourly</changefreq>
        <priority>0.9</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/minifiers</loc>
        <changefreq>daily</changefreq>
        <priority>0.7</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/change-log</loc>
        <changefreq>daily</changefreq>
        <priority>0.8</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/contact</loc>
        <changefreq>weekly</changefreq>
        <priority>0.4</priority>
    </url>
</urlset>";

            var settings = new XmlMinificationSettings();
            var logger = new NullLogger();

            var xmlMinifier = new XmlMinifier(settings, logger);

            MarkupMinificationResult result = xmlMinifier.Minify(xmlInput,
                 fileContext: string.Empty,
                 encoding: Encoding.GetEncoding(0),
                 generateStatistics: false);
            if (result.Errors.Count == 0)
            {
                Console.WriteLine("Minified content:{0}{0}{1}",
                     Environment.NewLine, result.MinifiedContent);
            }
            else
            {
                IList<MinificationErrorInfo> errors = result.Errors;

                Console.WriteLine("Found {0:N0} error(s):", errors.Count);
                Console.WriteLine();

                foreach (var error in errors)
                {
                    Console.WriteLine("Line {0}, Column {1}: {2}",
                         error.LineNumber, error.ColumnNumber, error.Message);
                    Console.WriteLine();
                }
            }
        }
    }
}
```

--------------------------------

### Initialize HtmlMinifier with Settings

Source: https://github.com/taritsyn/webmarkupmin/wiki/HTML-Minifier

Shows how to create an instance of HtmlMinifier, passing HTML minification settings, CSS minifier, JS minifier, and a logger to the constructor.

```csharp
var settings = new HtmlMinificationSettings();
var cssMinifier = new CssMinifier();
var jsMinifier = new JavaScriptMinifier();
var logger = new WebMarkupMin.Core.Logger();

var minifier = new HtmlMinifier(settings, cssMinifier, jsMinifier, logger);
```

--------------------------------

### Apply Action Filters to Controller

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-MVC

In version 2.X, action filters can be applied to entire controllers. This example shows applying CompressContent, MinifyHtml, and MinifyXml filters to the HomeController.

```csharp
using System.Web.Mvc;

using WebMarkupMin.AspNet4.Mvc;

namespace WebMarkupMin.Sample.AspNet4.Mvc4.Controllers
{
    [CompressContent]
    [MinifyHtml]
    [MinifyXml]
    public class HomeController : Controller
    {
        // ...
    }
}
```

--------------------------------

### Configure WebMarkupMin Options

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-6

Demonstrates how to configure various WebMarkupMin options, including minification and compression settings, excluded/included pages, and custom minifier factories.

```csharp
options.AllowMinificationInDevelopmentEnvironment = true;
options.AllowCompressionInDevelopmentEnvironment = true;
})
.AddHtmlMinification(options =>
{
    options.ExcludedPages = new List<IUrlMatcher>
    {
        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
        new ExactUrlMatcher("/contact")
    };

    HtmlMinificationSettings settings = options.MinificationSettings;
    settings.RemoveRedundantAttributes = true;
    settings.RemoveHttpProtocolFromAttributes = true;
    settings.RemoveHttpsProtocolFromAttributes = true;

    options.CssMinifierFactory = new NUglifyCssMinifierFactory();
    options.JsMinifierFactory = new NUglifyJsMinifierFactory();
})
.AddXhtmlMinification(options =>
{
    options.IncludedPages = new List<IUrlMatcher>
    {
        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
        new ExactUrlMatcher("/contact")
    };

    XhtmlMinificationSettings settings = options.MinificationSettings;
    settings.RemoveRedundantAttributes = true;
    settings.RemoveHttpProtocolFromAttributes = true;
    settings.RemoveHttpsProtocolFromAttributes = true;

    options.CssMinifierFactory = new KristensenCssMinifierFactory();
    options.JsMinifierFactory = new CrockfordJsMinifierFactory();
})
.AddXmlMinification(options =>
{
    XmlMinificationSettings settings = options.MinificationSettings;
    settings.CollapseTagsWithoutContent = true;
})
.AddHttpCompression(options =>
{
    options.CompressorFactories = new List<ICompressorFactory>
    {
        new BuiltInBrotliCompressorFactory(new BuiltInBrotliCompressionSettings
        {
            Level = CompressionLevel.Fastest
        }),
        new DeflateCompressorFactory(new DeflateCompressionSettings
        {
            Level = CompressionLevel.Fastest
        }),
        new GZipCompressorFactory(new GZipCompressionSettings
        {
            Level = CompressionLevel.Fastest
        })
    };
})
```

--------------------------------

### Cache Compressed Content with OutputCache Directive

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Web-Forms

Use the `OutputCache` directive with a `CacheProfile` to cache the result of markup minification and HTTP compression. This example caches content for 5 minutes.

```aspx
<%@ Page Title="Change log" Language="C#" MasterPageFile="~/Site.Master" AutoEventWireup="true"
    CodeBehind="ChangeLog.aspx.cs" Inherits="WebMarkupMin.Sample.AspNet45.WebForms.ChangeLog" %>
<%@ OutputCache CacheProfile="CacheCompressedContent5Minutes" %>
…
```

--------------------------------

### Advanced WebMarkupMin Configuration Options

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-6

Demonstrates advanced configuration options for WebMarkupMin services, including custom compressors and URL matchers, within the `Program.cs` file.

```csharp
using System.IO.Compression;

using WebMarkupMin.AspNet.Common.Compressors;
using WebMarkupMin.AspNet.Common.UrlMatchers;
using WebMarkupMin.AspNetCore6;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;
…

#region Configure services

…
// Add WebMarkupMin services.
services.AddWebMarkupMin(options =>
{

```

--------------------------------

### Configure WebMarkupMin in ASP.NET Web Pages (_AppStart.cshtml)

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Extensions

This Razor code configures WebMarkupMin for ASP.NET Web Pages sites using the _AppStart.cshtml file. It includes necessary using statements and sets up minification and compression options similar to the MVC configuration.

```cshtml
…
@using System.Collections.Generic

@using WebMarkupMin.AspNet.Brotli
@using WebMarkupMin.AspNet.Common
@using WebMarkupMin.AspNet.Common.Compressors
@using WebMarkupMin.AspNet.Common.UrlMatchers
@using WebMarkupMin.AspNet4.Common
@using WebMarkupMin.Core
@using WebMarkupMin.MsAjax
@using WebMarkupMin.Yui

@{ 
    …
    WebMarkupMinConfiguration configuration =
        WebMarkupMinConfiguration.Instance;
    configuration.AllowMinificationInDebugMode = true;
    configuration.AllowCompressionInDebugMode = true;

    IHtmlMinificationManager htmlMinificationManager =
        HtmlMinificationManager.Current;
    htmlMinificationManager.ExcludedPages = new List<IUrlMatcher>
    {
        new ExactUrlMatcher("/Contact")
    };
    HtmlMinificationSettings htmlMinificationSettings =

```

--------------------------------

### Advanced WebMarkupMin Configuration Imports

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-Latest

This snippet includes necessary using directives for advanced configuration of WebMarkupMin services, including compressors and URL matchers.

```csharp
using System.IO.Compression;

using WebMarkupMin.AspNet.Common.Compressors;
using WebMarkupMin.AspNet.Common.UrlMatchers;
using WebMarkupMin.AspNetCoreLatest;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;
…
```

--------------------------------

### Register WebMarkupMinConfig in Global.asax

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Extensions

This C# code snippet shows how to call the WebMarkupMinConfig.Configure method within the Application_Start event in the Global.asax file for ASP.NET MVC applications. This ensures the configuration takes effect.

```csharp
using System.Web;
…
using System.Web.Routing;

using WebMarkupMin.AspNet4.Common;

namespace WebMarkupMin.Sample.AspNet4.Mvc4
{
    public class MvcApplication : HttpApplication
    {
        protected void Application_Start()
        {
            …
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            WebMarkupMinConfig.Configure(WebMarkupMinConfiguration.Instance);
            …
        }
    }
}
```

--------------------------------

### Configure WebMarkupMin Services in ASP.NET Core

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-1.X

This snippet shows how to add and configure WebMarkupMin services, including HTML, XHTML, XML minification, and HTTP compression. It's essential to call this before route registration methods.

```csharp
using System.Collections.Generic;
using System.IO.Compression;

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;

using WebMarkupMin.AspNet.Brotli;
using WebMarkupMin.AspNet.Common.Compressors;
using WebMarkupMin.AspNet.Common.UrlMatchers;
using WebMarkupMin.AspNetCore1;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;

namespace WebMarkupMin.Sample.AspNetCore1.Mvc1
{
    public class Startup
    {
        public void ConfigureServices(IServiceCollection services)
        {
            services.AddWebMarkupMin(options =>
            {
                options.AllowMinificationInDevelopmentEnvironment = true;
                options.AllowCompressionInDevelopmentEnvironment = true;
            })
                .AddHtmlMinification(options =>
                {
                    options.ExcludedPages = new List<IUrlMatcher>
                    {
                        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
                        new ExactUrlMatcher("/contact")
                    };

                    HtmlMinificationSettings settings = options.MinificationSettings;
                    settings.RemoveRedundantAttributes = true;
                    settings.RemoveHttpProtocolFromAttributes = true;
                    settings.RemoveHttpsProtocolFromAttributes = true;

                    options.CssMinifierFactory = new NUglifyCssMinifierFactory();
                    options.JsMinifierFactory = new NUglifyJsMinifierFactory();
                })
                .AddXhtmlMinification(options =>
                {
                    options.IncludedPages = new List<IUrlMatcher>
                    {
                        new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
                        new ExactUrlMatcher("/contact")
                    };

                    XhtmlMinificationSettings settings = options.MinificationSettings;
                    settings.RemoveRedundantAttributes = true;
                    settings.RemoveHttpProtocolFromAttributes = true;
                    settings.RemoveHttpsProtocolFromAttributes = true;

                    options.CssMinifierFactory = new KristensenCssMinifierFactory();
                    options.JsMinifierFactory = new CrockfordJsMinifierFactory();
                })
                .AddXmlMinification(options =>
                {
                    XmlMinificationSettings settings = options.MinificationSettings;
                    settings.CollapseTagsWithoutContent = true;
                })
                .AddHttpCompression(options =>
                {
                    options.CompressorFactories = new List<ICompressorFactory>
                    {
                        new BrotliCompressorFactory(new BrotliCompressionSettings
                        {
                            Level = 1
                        }),
                        new DeflateCompressorFactory(new DeflateCompressionSettings
                        {
                            Level = CompressionLevel.Fastest
                        }),
                        new GZipCompressorFactory(new GZipCompressionSettings
                        {
                            Level = CompressionLevel.Fastest
                        })
                    };
                });
        }
    }
}
```

--------------------------------

### Basic XML Minification with Statistics

Source: https://github.com/taritsyn/webmarkupmin/wiki/XML-Minifier

Demonstrates basic XML minification using XmlMinifier. It includes generating minification statistics to show the original and minified sizes and the percentage saved. This is useful for understanding the effectiveness of the minification.

```csharp
using System;
using System.Collections.Generic;

using WebMarkupMin.Core;

namespace WebMarkupMin.Sample.ConsoleApplication
{
    class Program
    {
        private static void Main(string[] args)
        {
            const string xmlInput = @"<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"yes\"?>
<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">
    <url>
        <loc>https://webmarkupmin.bsite.net/</loc>
        <changefreq>hourly</changefreq>
        <priority>0.9</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/minifiers</loc>
        <changefreq>daily</changefreq>
        <priority>0.7</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/change-log</loc>
        <changefreq>daily</changefreq>
        <priority>0.8</priority>
    </url>
    <url>
        <loc>https://webmarkupmin.bsite.net/contact</loc>
        <changefreq>weekly</changefreq>
        <priority>0.4</priority>
    </url>
</urlset>";

            var xmlMinifier = new XmlMinifier();

            MarkupMinificationResult result = xmlMinifier.Minify(xmlInput,
                generateStatistics: true);
            if (result.Errors.Count == 0)
            {
                MinificationStatistics statistics = result.Statistics;
                if (statistics != null)
                {
                    Console.WriteLine("Original size: {0:N0} Bytes",
                        statistics.OriginalSize);
                    Console.WriteLine("Minified size: {0:N0} Bytes",
                        statistics.MinifiedSize);
                    Console.WriteLine("Saved: {0:N2}%",
                        statistics.SavedInPercent);
                }
                Console.WriteLine("Minified content:{0}{0}{1}",
                    Environment.NewLine, result.MinifiedContent);
            }
            else
            {
                IList<MinificationErrorInfo> errors = result.Errors;

                Console.WriteLine("Found {0} error(s):", errors.Count);
                Console.WriteLine();

                foreach (var error in errors)
                {
                    Console.WriteLine("Line {0}, Column {1}: {2}",
                        error.LineNumber, error.ColumnNumber, error.Message);
                    Console.WriteLine();
                }
            }
        }
    }
}
```

--------------------------------

### Configure WebMarkupMin Services

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-Latest

Add WebMarkupMin services to the application's service container and configure various minification and compression options. This includes enabling minification and compression in development environments and specifying custom settings for HTML, XHTML, and XML.

```csharp
services.AddWebMarkupMin(options =>
{
    options.AllowMinificationInDevelopmentEnvironment = true;
    options.AllowCompressionInDevelopmentEnvironment = true;
})
    .AddHtmlMinification(options =>
    {
        options.ExcludedPages = new List<IUrlMatcher>
        {
            new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
            new ExactUrlMatcher("/contact")
        };

        HtmlMinificationSettings settings = options.MinificationSettings;
        settings.RemoveRedundantAttributes = true;
        settings.RemoveHttpProtocolFromAttributes = true;
        settings.RemoveHttpsProtocolFromAttributes = true;

        options.CssMinifierFactory = new NUglifyCssMinifierFactory();
        options.JsMinifierFactory = new NUglifyJsMinifierFactory();
    })
    .AddXhtmlMinification(options =>
    {
        options.IncludedPages = new List<IUrlMatcher>
        {
            new WildcardUrlMatcher("/minifiers/x*ml-minifier"),
            new ExactUrlMatcher("/contact")
        };

        XhtmlMinificationSettings settings = options.MinificationSettings;
        settings.RemoveRedundantAttributes = true;
        settings.RemoveHttpProtocolFromAttributes = true;
        settings.RemoveHttpsProtocolFromAttributes = true;

        options.CssMinifierFactory = new KristensenCssMinifierFactory();
        options.JsMinifierFactory = new CrockfordJsMinifierFactory();
    })
    .AddXmlMinification(options =>
    {
        XmlMinificationSettings settings = options.MinificationSettings;
        settings.CollapseTagsWithoutContent = true;
    })
    .AddHttpCompression(options =>
    {
        options.CompressorFactories = new List<ICompressorFactory>
        {
            new BuiltInBrotliCompressorFactory(new BuiltInBrotliCompressionSettings
            {
                Level = CompressionLevel.Fastest
            }),
            new DeflateCompressorFactory(new DeflateCompressionSettings
            {
                Level = CompressionLevel.Fastest
            }),
            new GZipCompressorFactory(new GZipCompressionSettings
            {
                Level = CompressionLevel.Fastest
            })
        };
    });
```

--------------------------------

### Add WebMarkupMin Services in Program.cs

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-6

Configure WebMarkupMin services in the `Program.cs` file for ASP.NET Core 6+. This includes adding HTML, XML, and HTTP compression functionalities.

```csharp
using WebMarkupMin.AspNetCore6;
…

var builder = WebApplication.CreateBuilder(args);

#region Configure services

IServiceCollection services = builder.Services;

…
// Add WebMarkupMin services.
services.AddWebMarkupMin()
    .AddHtmlMinification()
    .AddXmlMinification()
    .AddHttpCompression()
    ;

// Add framework services.
services.AddControllersWithViews();
…

#endregion

#region Configure the HTTP request pipeline

var app = builder.Build();

…
app.UseWebMarkupMin();

app.MapControllerRoute(
…
);

#endregion

app.Run();

```

--------------------------------

### Configure WebMarkupMin Services in ASP.NET Core

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-3.1+

Add WebMarkupMin services to the dependency injection container in the `ConfigureServices` method. This includes HTML, XML, and HTTP compression functionalities.

```csharp
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;

using WebMarkupMin.AspNetCore3;
…

namespace WebMarkupMin.Sample.AspNetCore31.Mvc31
{
    public class Startup
    {
        …
        // This method gets called by the runtime.
        // Use this method to add services to the container.
        public void ConfigureServices(IServiceCollection services)
        {
            …
            // Add WebMarkupMin services.
            services.AddWebMarkupMin()
                .AddHtmlMinification()
                .AddXmlMinification()
                .AddHttpCompression()
                ;

            // Add framework services.
            services.AddControllersWithViews();
            …
        }

        // This method gets called by the runtime.
        // Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            …
            app.UseWebMarkupMin();

            app.UseEndpoints(endpoints =>
            {
                …
            });
        }
    }
}
```

--------------------------------

### Configure WebMarkupMin Middleware in ASP.NET Core

Source: https://context7.com/taritsyn/webmarkupmin/llms.txt

Add WebMarkupMin services with configuration for HTML, XHTML, XML minification, and HTTP compression. Ensure to add the middleware before routing.

```csharp
using System.IO.Compression;
using WebMarkupMin.AspNet.Common.Compressors;
using WebMarkupMin.AspNet.Common.UrlMatchers;
using WebMarkupMin.AspNetCoreLatest;
using WebMarkupMin.Core;
using WebMarkupMin.NUglify;

var builder = WebApplication.CreateBuilder(args);
IServiceCollection services = builder.Services;

// Add WebMarkupMin services with configuration
services.AddWebMarkupMin(options =>
{
    options.AllowMinificationInDevelopmentEnvironment = true;
    options.AllowCompressionInDevelopmentEnvironment = true;
})
.AddHtmlMinification(options =>
{
    // Exclude specific pages from minification
    options.ExcludedPages = new List<IUrlMatcher>
    {
        new WildcardUrlMatcher("/api/*"),
        new ExactUrlMatcher("/admin/debug"),
        new RegexUrlMatcher(@"^/legacy/.*")
    };

    // Configure minification settings
    HtmlMinificationSettings settings = options.MinificationSettings;
    settings.RemoveRedundantAttributes = true;
    settings.RemoveHttpProtocolFromAttributes = true;
    settings.RemoveHttpsProtocolFromAttributes = true;
    settings.WhitespaceMinificationMode = WhitespaceMinificationMode.Medium;

    // Use NUglify for CSS and JS minification
    options.CssMinifierFactory = new NUglifyCssMinifierFactory();
    options.JsMinifierFactory = new NUglifyJsMinifierFactory();
})
.AddXhtmlMinification(options =>
{
    // Include only specific pages for XHTML minification
    options.IncludedPages = new List<IUrlMatcher>
    {
        new WildcardUrlMatcher("/xhtml/*"),
        new ExactUrlMatcher("/contact")
    };

    XhtmlMinificationSettings settings = options.MinificationSettings;
    settings.RemoveRedundantAttributes = true;
})
.AddXmlMinification(options =>
{
    XmlMinificationSettings settings = options.MinificationSettings;
    settings.CollapseTagsWithoutContent = true;
})
.AddHttpCompression(options =>
{
    // Configure compression algorithms (in priority order)
    options.CompressorFactories = new List<ICompressorFactory>
    {
        new BuiltInBrotliCompressorFactory(new BuiltInBrotliCompressionSettings
        {
            Level = CompressionLevel.Fastest
        }),
        new GZipCompressorFactory(new GZipCompressionSettings
        {
            Level = CompressionLevel.Fastest
        }),
        new DeflateCompressorFactory(new DeflateCompressionSettings
        {
            Level = CompressionLevel.Fastest
        })
    };
});

services.AddControllersWithViews();

var app = builder.Build();

// Add WebMarkupMin middleware (before routing)
app.UseWebMarkupMin();

app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

```

--------------------------------

### HTML Minifier Configuration Options

Source: https://github.com/taritsyn/webmarkupmin/wiki/HTML-Minifier

This section details the various configuration options available for the WebMarkupMin HTML minifier.

```APIDOC
## HTML Minifier Configuration Options

### Description
This section details the various configuration options available for the WebMarkupMin HTML minifier, allowing for fine-grained control over the minification process.

### AttributeQuotesMode

#### Description
Determines the style for attribute quotes. Can auto-detect, use optimal style based on attribute value, or enforce single or double quotes.

#### Values
- `Auto`: Auto-detect style for attribute quotes based on the source input.
- `Optimal`: Optimal style for attribute quotes based on the attribute value.
- `Single`: Single quotes.
- `Double`: Double quotes.

### AttributeQuotesRemovalMode

#### Description
Specifies the mode for removing HTML attribute quotes. Options include keeping quotes, or removing them according to HTML 4.X or HTML5 standards.

#### Values
- `KeepQuotes`: Keep quotes.
- `Html4`: Removes quotes in accordance with standard HTML 4.X.
- `Html5`: Removes quotes in accordance with standard HTML5.

### RemoveEmptyAttributes

#### Description
A flag to determine whether to remove attributes with empty values. Specific attributes like `class`, `id`, `name`, `style`, `title`, `lang`, event attributes, `form[action]`, and `input[value]` are considered valid even when empty.

#### Type
Boolean

#### Default Value
`true`

### RemoveRedundantAttributes

#### Description
A flag to determine whether to remove redundant attributes that are often implied by the HTML standard or browser defaults. Examples include `a[name]`, `button[type=submit]`, `input[type=text]`, etc.

#### Type
Boolean

#### Default Value
`false`

### RemoveJsTypeAttributes

#### Description
A flag for whether to remove `type="text/javascript"` attributes from `script` tags.

#### Type
Boolean

#### Default Value
`true`

### RemoveCssTypeAttributes

#### Description
A flag for whether to remove `type="text/css"` attributes from `style` and `link` tags.

#### Type
Boolean

#### Default Value
`true`

### PreservableAttributeList

#### Description
A comma-separated list of attribute expressions that should not be removed during minification. These expressions are similar to CSS attribute selectors.

#### Examples
- `"form[method=get i]"`
- `"input[type]"`
- `"[xmlns]"`

#### Attribute Expression Varieties
- `[attrName]`
- `tagName[attrName]`
- `[attrName=attrValue]`
- `tagName[attrName=attrValue]`
- `[attrName=attrValue i]`
- `tagName[attrName=attrValue i]`

#### Type
String

#### Default Value
Empty string

### RemoveHttpProtocolFromAttributes

#### Description
A flag for whether to remove the `http:` protocol portion from URI-based attributes. Tags with `rel="external"` are skipped.

#### Type
Boolean

#### Default Value
`false`

### RemoveHttpsProtocolFromAttributes

#### Description
A flag for whether to remove the `https:` protocol portion from URI-based attributes. Tags with `rel="external"` are skipped.

#### Type
Boolean

#### Default Value
`false`

### RemoveJsProtocolFromAttributes

#### Description
A flag for whether to remove the JavaScript protocol portion from URI-based attributes.

#### Type
Boolean

#### Default Value
`true`

```

--------------------------------

### Override Default Logger for WebMarkupMin

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-6

Demonstrates how to register a custom logger implementation to override the default logger used by WebMarkupMin.

```csharp
using WebMarkupMin.AspNetCore6;

using IWmmLogger = WebMarkupMin.Core.Loggers.ILogger;
using WmmAspNetCoreLogger = WebMarkupMin.AspNetCore6.AspNetCoreLogger;

// Override the default logger for WebMarkupMin.
services.AddSingleton<IWmmLogger, WmmAspNetCoreLogger>();

// Add WebMarkupMin services to the services container.
services.AddWebMarkupMin(…)
```

--------------------------------

### WebMarkupMinOptions Configuration

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-Extensions

Configuration of ASP.NET Core extensions are made through special classes like WebMarkupMinOptions. This class provides properties to control minification and compression behavior.

```APIDOC
## WebMarkupMin Options

`WebMarkupMinOptions` class provides properties to configure the behavior of WebMarkupMin in ASP.NET Core.

### Properties

- **AllowMinificationInDevelopmentEnvironment** (Boolean) - Optional - Flag for whether to allow markup minification if the current hosting environment name is `Development`.
- **AllowCompressionInDevelopmentEnvironment** (Boolean) - Optional - Flag for whether to allow HTTP compression of content if the current hosting environment name is `Development`.
- **DefaultEncoding** (Encoding) - Optional - Default encoding that will be used if the content encoding could not be determined for the current HTTP response.

### Default Values

- **AllowMinificationInDevelopmentEnvironment**: `false`
- **AllowCompressionInDevelopmentEnvironment**: `false`
- **DefaultEncoding**: `Encoding.Default`
```

--------------------------------

### Configure Kristensen CSS Minifier Settings

Source: https://github.com/taritsyn/webmarkupmin/wiki/Built-in-CSS-minifiers

Instantiate and configure KristensenCssMinificationSettings to control CSS minification behavior. Pass these settings to the KristensenCssMinifier constructor.

```csharp
var cssSettings = new KristensenCssMinificationSettings
{
    RemoveRedundantSelectors = true,
    RemoveUnitsFromZeroValues = true
})
var cssMinifier = new KristensenCssMinifier(cssSettings);
```

--------------------------------

### Register WebMarkupMin Middleware in ASP.NET Core 1.X

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Core-1.X

In the Configure method of the Startup class, register the WebMarkupMin middleware using the UseWebMarkupMin extension method to process the HTTP request pipeline.

```csharp
app.UseWebMarkupMin();
```

--------------------------------

### Basic HTML Minification in C#

Source: https://github.com/taritsyn/webmarkupmin/wiki/HTML-Minifier

Use this snippet for basic HTML minification. It shows how to instantiate HtmlMinifier, minify HTML content, and display minification statistics or errors.

```csharp
using System;
using System.Collections.Generic;

using WebMarkupMin.Core;

namespace WebMarkupMin.Sample.ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            const string htmlInput = @"<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>The test document</title>
        <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <meta name="viewport" content="width=device-width" />
        <link rel="stylesheet" type="text/css" href="/Content/Site.css" />
    </head>
    <body>
        <p>Lorem ipsum dolor sit amet...</p>

        <script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.9.1.min.js"></script>
        <script>
            (window.jquery) || document.write('<script src="/Scripts/jquery-1.9.1.min.js"><\/script>');
        </script>
    </body>
</html>";

            var htmlMinifier = new HtmlMinifier();

            MarkupMinificationResult result = htmlMinifier.Minify(htmlInput,
                generateStatistics: true);
            if (result.Errors.Count == 0)
            {
                MinificationStatistics statistics = result.Statistics;
                if (statistics != null)
                {
                    Console.WriteLine("Original size: {0:N0} Bytes",
                        statistics.OriginalSize);
                    Console.WriteLine("Minified size: {0:N0} Bytes",
                        statistics.MinifiedSize);
                    Console.WriteLine("Saved: {0:N2}%",
                        statistics.SavedInPercent);
                }
                Console.WriteLine("Minified content:{0}{0}{1}",
                    Environment.NewLine, result.MinifiedContent);
            }
            else
            {
                IList<MinificationErrorInfo> errors = result.Errors;

                Console.WriteLine("Found {0} error(s):", errors.Count);
                Console.WriteLine();

                foreach (var error in errors)
                {
                    Console.WriteLine("Line {0}, Column {1}: {2}",
                        error.LineNumber, error.ColumnNumber, error.Message);
                    Console.WriteLine();
                }
            }
        }
    }
}
```

--------------------------------

### Configure HTTP Compression Factories

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Extensions

Specifies the compressor factories to be used for HTTP compression, including Brotli, Deflate, and GZip.

```csharp
httpCompressionManager.CompressorFactories = new List<ICompressorFactory>
{
    new BrotliCompressorFactory(),
    new DeflateCompressorFactory(),
    new GZipCompressorFactory()
};
```

--------------------------------

### Register Global Action Filters

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-MVC

To apply action filters at the application level, edit the `App_Start/FilterConfig.cs` file and register filters like CompressContentAttribute, MinifyHtmlAttribute, and MinifyXmlAttribute in the GlobalFilterCollection.

```csharp
using System.Web.Mvc;

using WebMarkupMin.AspNet4.Mvc;

namespace WebMarkupMin.Sample.AspNet4.Mvc4
{
    public class FilterConfig
    {
        public static void RegisterGlobalFilters(GlobalFilterCollection filters)
        {
            filters.Add(new CompressContentAttribute());
            filters.Add(new MinifyHtmlAttribute());
            filters.Add(new MinifyXmlAttribute());
        }
    }
}
```

--------------------------------

### Configure and Use Kristensen CSS Minifier

Source: https://context7.com/taritsyn/webmarkupmin/llms.txt

Configure CSS minification settings and use the KristensenCssMinifier directly or with the HtmlMinifier. Ensure correct settings for properties like RemoveUnitsFromZeroValues.

```csharp
using WebMarkupMin.Core;

// Configure CSS minification settings
var cssSettings = new KristensenCssMinificationSettings
{
    RemoveRedundantSelectors = true,   // a#btn -> #btn
    RemoveTrailingSemicolons = true,   // { color: red; } -> { color: red }
    RemoveUnitsFromZeroValues = false  // 0px -> 0 (disable if using calc/clamp)
};

var cssMinifier = new KristensenCssMinifier(cssSettings);

// Use with HTML minifier
var htmlSettings = new HtmlMinificationSettings
{
    MinifyEmbeddedCssCode = true,
    MinifyInlineCssCode = true
};

var htmlMinifier = new HtmlMinifier(htmlSettings, cssMinifier, jsMinifier: null, logger: null);

// CSS minifier can also be used directly
string cssCode = @"
    body {
        margin: 0px;
        padding: 0px;
    }
    a#resetButton {
        color: red;
    }
";
CodeMinificationResult cssResult = cssMinifier.Minify(cssCode, isInlineCode: false);
Console.WriteLine(cssResult.MinifiedContent);
// Output: body{margin:0;padding:0}#resetButton{color:red}
```

--------------------------------

### Configure XML Minification Settings

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Extensions

Enables collapsing tags that do not contain content during XML minification.

```csharp
xmlMinificationSettings.CollapseTagsWithoutContent = true;
```

--------------------------------

### Advanced HTML Minification with Custom Settings in C#

Source: https://github.com/taritsyn/webmarkupmin/wiki/HTML-Minifier

This snippet demonstrates advanced HTML minification using custom settings, including CSS and JavaScript minifiers, and a logger. It's useful when you need fine-grained control over the minification process.

```csharp
using System;
using System.Collections.Generic;
using System.Text;

using WebMarkupMin.Core;
using WebMarkupMin.Core.Loggers;

namespace WebMarkupMin.Sample.ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            const string htmlInput = @"<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>The test document</title>
        <link href="favicon.ico" rel="shortcut icon" type="image/x-icon" />
        <meta name="viewport" content="width=device-width" />
        <link rel="stylesheet" type="text/css" href="/Content/Site.css" />
    </head>
    <body>
        <p>Lorem ipsum dolor sit amet...</p>

        <script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-1.9.1.min.js"></script>
        <script>
            (window.jquery) || document.write('<script src="/Scripts/jquery-1.9.1.min.js"><\/script>');
        </script>
    </body>
</html>";

            var settings = new HtmlMinificationSettings();
            var cssMinifier = new KristensenCssMinifier();
            var jsMinifier = new CrockfordJsMinifier();
            var logger = new NullLogger();

            var htmlMinifier = new HtmlMinifier(settings, cssMinifier,
                jsMinifier, logger);

            MarkupMinificationResult result = htmlMinifier.Minify(htmlInput,
                fileContext: string.Empty,
                encoding: Encoding.GetEncoding(0),

```

--------------------------------

### Register HTTP Modules in Web.config (IIS Classic Mode)

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-HTTP-modules

Register the HTML, XHTML, XML minification, and HTTP compression modules within the `<system.web><httpModules>` section for IIS Classic mode.

```xml
<?xml version="1.0"?>
<configuration>
    …
    <system.web>
        <httpModules>
            <add name="HtmlMinificationModule"
                type="WebMarkupMin.AspNet4.HttpModules.HtmlMinificationModule, WebMarkupMin.AspNet4.HttpModules" />
            <add name="XhtmlMinificationModule"
                type="WebMarkupMin.AspNet4.HttpModules.XhtmlMinificationModule, WebMarkupMin.AspNet4.HttpModules" />
            <add name="XmlMinificationModule"
                type="WebMarkupMin.AspNet4.HttpModules.XmlMinificationModule, WebMarkupMin.AspNet4.HttpModules" />
            <add name="HttpCompressionModule"
                type="WebMarkupMin.AspNet4.HttpModules.HttpCompressionModule, WebMarkupMin.AspNet4.HttpModules" />
        </httpModules>
        …
    </system.web>
    …
</configuration>
```

--------------------------------

### HttpCompressionManager and HttpCompressionOptions Properties

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Extensions

Configuration properties for HTTP compression management.

```APIDOC
## HttpCompressionManager and HttpCompressionOptions

### Description
These classes manage HTTP compression settings and options for text content. They determine which compression algorithms to use, which HTTP status codes and methods are supported, and how to filter content for compression.

### Properties

#### CompressorFactories
- **Data type**: `IList<ICompressorFactory>`
- **Default value**: Instance of `GZipCompressorFactory`, Instance of `DeflateCompressorFactory`
- **Description**: List of HTTP compressor factories. The order determines the priority of compression algorithms. Custom compressors can be added by implementing `ICompressor` and `ICompressorFactory` interfaces and adding the factory to the top of this list.

#### SupportedHttpStatusCodes
- **Data type**: `ISet<int>`
- **Default value**: `200`
- **Description**: List of HTTP status codes for which compression is supported.

#### SupportedHttpMethods
- **Data type**: `ISet<string>`
- **Default value**: `GET`
- **Description**: List of HTTP methods for which compression is supported.

#### SupportedMediaTypePredicate
- **Data type**: `Func<string, bool>`
- **Default value**: `null`
- **Description**: A delegate that determines if a media-type is supported for compression. If `null`, the `MediaTypeHelpers.IsTextBasedMediaType` method is used.

#### IncludedPages
- **Data type**: `IList<IUrlMatcher>`
- **Default value**: Empty list
- **Description**: List of URL matchers used to include pages for compression processing.

#### ExcludedPages
- **Data type**: `IList<IUrlMatcher>`
- **Default value**: Empty list
- **Description**: List of URL matchers used to exclude pages from compression processing.

### Usage Notes
- The `HttpCompressionManager` decides between GZip and Deflate based on the `Accept-Encoding` HTTP header. If both are supported, the algorithm higher in the `CompressorFactories` list takes precedence.
- Support for other compression algorithms (e.g., Brotli) can be added by creating custom `ICompressor` and `ICompressorFactory` implementations.
```

--------------------------------

### Configure and Use Crockford JavaScript Minifier

Source: https://context7.com/taritsyn/webmarkupmin/llms.txt

Instantiate the CrockfordJsMinifier and use it directly or integrate it with the HtmlMinifier. Configure HTML minification settings to enable embedded and inline JavaScript minification.

```csharp
using WebMarkupMin.Core;

var jsMinifier = new CrockfordJsMinifier();

// Use with HTML minifier
var htmlSettings = new HtmlMinificationSettings
{
    MinifyEmbeddedJsCode = true,
    MinifyInlineJsCode = true,
    MinifyEmbeddedJsonData = true  // Minifies JSON in script[type="application/json"]
};

var htmlMinifier = new HtmlMinifier(htmlSettings, cssMinifier: null, jsMinifier, logger: null);

// JS minifier can also be used directly
string jsCode = @"
    function greet(name) {
        // This is a comment
        var message = 'Hello, ' + name + '!';
        console.log(message);
        return message;
    }
";
CodeMinificationResult jsResult = jsMinifier.Minify(jsCode, isInlineCode: false);
Console.WriteLine(jsResult.MinifiedContent);
```

--------------------------------

### Configure XHTML Minifier Factories

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-4.X-Extensions

Sets the factories for CSS and JavaScript minification specifically for XHTML.

```csharp
xhtmlMinificationManager.CssMinifierFactory =
    new YuiCssMinifierFactory();
xhtmlMinificationManager.JsMinifierFactory =
    new YuiJsMinifierFactory();
```

--------------------------------

### Configuring HTML Minification Settings in C#

Source: https://context7.com/taritsyn/webmarkupmin/llms.txt

Illustrates how to configure HTML minification behavior using HtmlMinificationSettings. This includes options for whitespace handling, comment removal, tag and attribute optimization, and embedded code minification.

```csharp
using WebMarkupMin.Core;

var settings = new HtmlMinificationSettings
{
    // Whitespace handling: None, Safe, Medium (default), or Aggressive
    WhitespaceMinificationMode = WhitespaceMinificationMode.Medium,
    PreserveNewLines = false,

    // Comment removal
    RemoveHtmlComments = true,
    RemoveHtmlCommentsFromScriptsAndStyles = true,

    // DOCTYPE optimization
    UseShortDoctype = true,  // Converts to <!DOCTYPE html>
    CustomShortDoctype = "", // Or specify custom: "<!doctype html>"

    // Character encoding
    UseMetaCharsetTag = true, // Converts <meta http-equiv="content-type"...> to <meta charset="...">

    // Tag optimization
    RemoveOptionalEndTags = true,  // Removes </li>, </p>, </td>, etc.
    RemoveTagsWithoutContent = false,
    EmptyTagRenderMode = HtmlEmptyTagRenderMode.NoSlash, // <br> vs <br/> vs <br />
    PreserveCase = false, // Set true for Angular 2 templates

    // Attribute optimization
    CollapseBooleanAttributes = true,  // checked="checked" -> checked
    AttributeQuotesRemovalMode = HtmlAttributeQuotesRemovalMode.Html5,
    RemoveEmptyAttributes = true,
    RemoveRedundantAttributes = false,
    RemoveJsTypeAttributes = true,  // Removes type="text/javascript"
    RemoveCssTypeAttributes = true, // Removes type="text/css"

    // Protocol removal
    RemoveHttpProtocolFromAttributes = true,
    RemoveHttpsProtocolFromAttributes = true,
    RemoveJsProtocolFromAttributes = true,

    // Embedded code minification
    MinifyEmbeddedCssCode = true,
    MinifyInlineCssCode = true,
    MinifyEmbeddedJsCode = true,
    MinifyInlineJsCode = true,
    MinifyEmbeddedJsonData = true,

    // Framework-specific optimizations
    MinifyKnockoutBindingExpressions = false,
    MinifyAngularBindingExpressions = false,
    ProcessableScriptTypeList = "text/html, text/ng-template"
};

var htmlMinifier = new HtmlMinifier(settings);
```

--------------------------------

### WebMarkupMin Common Configuration Properties

Source: https://github.com/taritsyn/webmarkupmin/wiki/ASP.NET-Extensions

Details the common configuration properties available in WebMarkupMinConfigurationBase, which is inherited by both ASP.NET 4.X and ASP.NET Core 1.X configuration classes.

```APIDOC
## WebMarkupMin Common Configuration

### Description
Configuration properties common to WebMarkupMin extensions for ASP.NET 4.X and ASP.NET Core 1.X, inherited from `WebMarkupMinConfigurationBase`.

### Properties

#### DisableMinification (Boolean)
- **Default value**: `false`
- **Description**: Flag for whether to disable markup minification.

#### DisableCompression (Boolean)
- **Default value**: `false`
- **Description**: Flag for whether to disable HTTP compression of content.

#### MaxResponseSize (Int32)
- **Default value**: `-1`
- **Description**: Maximum size of the response (in bytes), in excess of which disables the minification of markup. If this property is set equal to `-1`, then checking of the response size is not performed.

#### DisablePoweredByHttpHeaders (Boolean)
- **Default value**: `false`
- **Description**: Flag for whether to disable the `*-Minification-Powered-By` HTTP headers (e.g. `X-HTML-Minification-Powered-By: WebMarkupMin`).
```