HandlerFunc builds and returns a http.Handler from the chain of middlewares, with `h http.Handler` as the final handler.

ServeHTTP is the single method of the http.Handler interface that makes Mux interoperable with the standard library. It uses a sync.Pool to get and re

Use appends one or more middlewares onto the Router stack.

NewRouter returns a new Mux object that implements the Router interface.

Route mounts a sub-Router along a `pattern` string.

Add will append a URL parameter to the end of the route param

URLParam returns the url parameter from a http.Request object.

NewRouteContext returns a new routing Context object.

handle registers a http.Handler in the routing tree for a particular http method and routing pattern.

run invokes mw with the request constructed by buildReq and returns the client IP captured inside the handler (or "" if none was set).

NotFound defines a handler to respond whenever a route could not be found.

URLParam returns the corresponding URL parameter value from the request routing context.

ClientIPFromXFF stores the client IP read from the X-Forwarded-For header, walking the chain right-to-left and skipping any IP that falls within one o

Mount attaches another http.Handler along ./pattern/*

GetClientIP returns the client IP as a string, as set by one of the ClientIPFrom* middlewares. Returns "" if no valid IP was set. Convenient for loggi

With adds inline middlewares for an endpoint handler.

ClientIPFromHeader stores the client IP from a single-IP header set by your reverse proxy. Read it with [GetClientIP]. Only safe with headers your pr

Group adds a new inline-Router along the current routing path, with a fresh middleware stack for the inline-Router.

Match searches the routing tree for a handler that matches the method/path - similar to routing a http request, but without executing the handler ther

Handle and HandleFunc adds routes for `pattern` that matches all HTTP methods.

ThrottleBacklog is a middleware that limits number of currently processed requests at a time and provides a backlog for holding a finite number of pen

Walk walks any router tree that implements Routes interface.

colorWrite

Chain returns a Middlewares type from a slice of middleware handlers.

NotFoundHandler returns the default Mux 404 responder whenever a route cannot be found.

RouteContext returns chi's routing Context object from a http.Request Context.

Status returns the HTTP status of the request, or 0 if one has not yet been sent.

ThrottleWithOpts is a middleware that limits number of currently processed requests using passed ThrottleOpts.

walkXFF walks the entries of the merged X-Forwarded-For chain RIGHT-TO-LEFT, invoking visit on each trimmed non-empty entry. visit returns true to sto

BytesWritten returns the total number of bytes sent to the client.

ClientIPFromXFFTrustedProxies stores the client IP read from X-Forwarded-For, given the exact number of trusted reverse proxies between this server an

GetClientIPAddr returns the client IP as a [netip.Addr], as set by one of the ClientIPFrom* middlewares. The returned Addr is the zero value if not se

MethodNotAllowed defines a handler to respond whenever a method is not allowed.

NewCompressor creates a new Compressor that will handle encoding responses. The level should be one of the ones defined in the flate package. The typ

RoutePattern builds the routing pattern string for the particular request, at the particular point during routing. This means, the value will change t

Routes returns the routing tree in an easily traversable structure.

chain builds a http.Handler composed of an inline middleware stack and endpoint handler in the order they are passed.

parseHeaderAddr parses s and normalizes for storage: v4-mapped IPv6 (::ffff:a.b.c.d) folds to plain v4, IPv6 zone is stripped. Both defend the trust-p

patNextSegment returns the next segment details from a pattern: node type, param key, regexp string, param tail byte, param starting index, param endi

Bind on UserPayload will run after the unmarshalling is complete, its a good time to focus some post-processing after a decoding.

Find searches the routing tree for the pattern that matches the method/path.

GetReqID returns a request ID from the given context if one is present. Returns the empty string if a request ID cannot be found.

Handler builds and returns a http.Handler from the chain of middlewares, with `h http.Handler` as the final handler.

Handler returns a new middleware that will compress the response based on the current Compressor.

Method adds the route `pattern` that matches `method` http method to execute the `handler` http.Handler.

Method and MethodFunc adds routes for `pattern` that matches the `method` HTTP method.

Mount attaches another http.Handler or chi Router as a subrouter along a routing path. It's very useful to split up a large API as many independent ro

NewMux returns a newly initialized Mux object that implements the Router interface.

NewWrapResponseWriter wraps an http.ResponseWriter, returning a proxy that allows you to hook into various parts of the response process.

RequestLogger returns a logger handler using a custom LogFormatter.

Route creates a new Mux and mounts it along the `pattern` as a subrouter. Effectively, this is a short-hand call to Mount. See _examples/.

SetEncoder can be used to set the implementation of a compression algorithm. The encoding should be a standardised identifier. See: https://developer

Use appends a middleware handler to the Mux middleware stack. The middleware stack for any Mux will execute before searching for a matching route to

With adds inline middlewares for an endpoint handler.

Check the content encoding against a list of acceptable values.