func (n N) Evaluate(b []byte) []byte {
	if n.Start < 0 {
		n.Start = len(b) + 1 + n.Start
	}
	if n.End < 0 {
		n.End = len(b) + 1 + n.End
	}
	n.Start = clamp(n.Start, 0, len(b))
	n.End = clamp(n.End, 0, len(b))
	return ReplaceSlice(b, n.Start, n.End, n.Cmd.Evaluate(b[n.Start:n.End]))
}
Evaluate calculates slices the input with [start:end] and replaces that part
of the input with the application of Cmd to it.
package sregx
import (
	"bytes"
	"io"
	"regexp"
)
type Command interface {
	Evaluate(b []byte) []byte
}
type CommandPipeline []Command
func (cp CommandPipeline) Evaluate(b []byte) []byte {
	for _, c := range cp {
		b = c.Evaluate(b)
	}
	return b
}
type X struct {
	Patt *regexp.Regexp
	Cmd  Command
}
func (x X) Evaluate(b []byte) []byte {
	return x.Patt.ReplaceAllFunc(b, func(b []byte) []byte {
		return x.Cmd.Evaluate(b)
	})
}
type Y struct {
	Patt *regexp.Regexp
	Cmd  Command
}
func (y Y) Evaluate(b []byte) []byte {
	return ReplaceAllComplementFunc(y.Patt, b, func(b []byte) []byte {
		return y.Cmd.Evaluate(b)
	})
}
type G struct {
	Patt *regexp.Regexp
	Cmd  Command
}
func (g G) Evaluate(b []byte) []byte {
	if g.Patt.Match(b) {
		return g.Cmd.Evaluate(b)
	}
	return b
}
type V struct {
	Patt *regexp.Regexp
	Cmd  Command
}
func (v V) Evaluate(b []byte) []byte {
	if !v.Patt.Match(b) {
		return v.Cmd.Evaluate(b)
	}
	return b
}
type S struct {
	Patt    *regexp.Regexp
	Replace []byte
}
func (s S) Evaluate(b []byte) []byte {
	return s.Patt.ReplaceAll(b, s.Replace)
}
type P struct {
	W io.Writer
}
func (p P) Evaluate(b []byte) []byte {
	p.W.Write(b)
	return b
}
type D struct{}
func (d D) Evaluate(b []byte) []byte {
	return []byte{}
}
type C struct {
	Change []byte
}
func (c C) Evaluate(b []byte) []byte {
	return c.Change
}
type N struct {
	Start int
	End   int
	Cmd   Command
}