tdewolff/minify

You can run the Minify CLI using a Docker container:

docker run -it tdewolff/minify --help

Minify can be used as middleware in a Go web server. Use m.MiddlewareWithError(handler) to wrap an existing http.Handler. This will automatically minify responses.

Important: When using MiddlewareWithError, you must close the response writer (which is returned as an io.Closer) to ensure errors are captured and the response is properly finalized.

// Standard Middleware usage
fs := http.FileServer(http.Dir("www/"))
http.Handle("/", m.MiddlewareWithError(fs))

// Handling errors in custom handlers with Middleware
m.Middleware(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Header().Set("Content-Type", "text/html")
    _, _ = w.Write([]byte(input))

    // You must cast the writer to io.Closer and close it
    if err = w.(io.Closer).Close(); err != nil {
        panic(err)
    }
})).ServeHTTP(rec, req)

You can minify resources on-the-fly by wrapping an http.Handler with m.Middleware(handler).

• The middleware wraps the response writer and removes the Content-Length header.
• The minifier is selected based on the Content-Type header or, if empty, the file extension in the request URI.
• Performance Tip: Since this is on-the-fly processing, you should cache the results to avoid repeated minification overhead.

fs := http.FileServer(http.Dir("www/"))
http.Handle("/", m.Middleware(fs))

Use minify.New() to retrieve a *minify.M struct. This struct holds a mapping of mediatypes to their respective minification functions. You must register minifiers (e.g., CSS, HTML, JS) using AddFunc, AddFuncRegexp, Add, or AddRegexp before they can be used.

Note: Input streams are buffered for performance, but output streams are not. It is recommended to preallocate an output buffer equal to the input size or use bufio to wrap the output writer.

```go
m := minify.New()
m.AddFunc("text/css", css.Minify)
m.AddFunc("text/html", html.Minify)
```埋

Minify is available for several other environments:

• JavaScript (Node.js 20.19+): npm i @tdewolff/minify
• Python: pip install tdewolff-minify
• Windows (via Scoop): scoop install main/minify
• .NET: Install-Package NMinify or dotnet add package NMinify

The Python bindings provide three primary functions: minify.config() to set minifier options, minify.string() to minify a string in memory, and minify.file() to minify a file on disk. All functions require a mediatype as the first argument.

import minify

# Configure minifier options
minify.config({
    'css-precision': 0,
    'html-keep-comments': False,
    'js-version': 0,
})

# Minify a string
s = minify.string('text/html', '<span style="color:#ff0000;" class="text">Some  text</span>')
print(s)

# Minify a file (creates output_file from input_file)
minify.file('text/html', 'example.html', 'example.min.html')

To use Minify in your Go project, ensure you have Git and Go (1.18 or higher) installed. Initialize your module and fetch the package using the following commands:

mkdir Project
cd Project
go mod init
go get -u github.com/tdewolff/minify/v2

To clean up your go.mod and go.sum files, you can optionally run go mod tidy.

To use the various minifiers (HTML, CSS, JS, etc.), you must import the core package along with the specific minifier implementations:

import (
	"github.com/tdewolff/minify/v2"
	"github.com/tdewolff/minify/v2/css"
	"github.com/tdewolff/minify/v2/html"
	"github.com/tdewolff/minify/v2/js"
	"github.com/tdewolff/minify/v2/json"
	"github.com/tdewolff/minify/v2/svg"
	"github.com/tdewolff/minify/v2/xml"
)

To use the JavaScript bindings for the Go minifiers, install the @tdewolff/minify package. This package requires Node.js 20.19+.

npm install @tdewolff/minify