func ParseGlob(pattern string) (err error) {
	tLocker.Lock()
	defer func() {
		tLocker.Unlock()
		if err != nil {
			return
		}
		parseFuncsLocker.Lock()
		defer parseFuncsLocker.Unlock()
		parseFuncs[pattern] = func(nt *template.Template) {
			if _, err := nt.ParseGlob(pattern); err != nil {
				erpc.Errorf("ParseGlob: pattern: %s, error: %s", pattern, err.Error())
			}
		}
	}()
	_, err = t.ParseGlob(pattern)
	return err
}
ParseGlob creates a new Template and parses the template definitions from the
files identified by the pattern, which must match at least one file. The
returned template will have the (base) name and (parsed) contents of the
first file matched by the pattern. ParseGlob is equivalent to calling
ParseFiles with the list of files matched by the pattern.

When parsing multiple files with the same name in different directories,
the last one mentioned will be the one that results.

The pattern syntax is:

pattern:
{ term }
term:
'*'         matches any sequence of non-Separator characters
'?'         matches any single non-Separator character
'[' [ '^' ] { character-range } ']'
character class (must be non-empty)
c           matches character c (c != '*', '?', '\\', '[')
'\\' c      matches character c

character-range:
c           matches character c (c != '\\', '-', ']')
'\\' c      matches character c
lo '-' hi   matches character c for lo <= c <= hi

Match requires pattern to match all of name, not just a substring.
The only possible returned error is ErrBadPattern, when pattern
is malformed.

On Windows, escaping is disabled. Instead, '\\' is treated as
path separator.
package html
import (
	"sync"
	"text/template"
	"time"
	"github.com/henrylee2cn/erpc/v6"
	"github.com/henrylee2cn/erpc/v6/utils"
	micro "github.com/xiaoenai/tp-micro/v6"
)
type CtxMeta interface {
	SetMeta(key, value string)
}
var (
	t                = template.New("")
	tLocker          sync.RWMutex
	parseFuncs       = make(map[string]func(*template.Template), 128)
	parseFuncsLocker sync.RWMutex
)
func Delims(left, right string) {
	tLocker.Lock()
	defer tLocker.Unlock()
	t.Delims(left, right)
}
func Funcs(funcMap template.FuncMap) {
	tLocker.Lock()
	defer tLocker.Unlock()
	t.Funcs(funcMap)
}
func Option(opt ...string) {
	tLocker.Lock()
	defer tLocker.Unlock()
	t.Option(opt...)
}
func Parse(name, text string) error {
	tLocker.Lock()
	defer tLocker.Unlock()
	_, err := t.New(name).Parse(text)
	return err
}
func ParseFiles(filenames ...string) (err error) {
	tLocker.Lock()
	defer func() {
		tLocker.Unlock()
		if err != nil {
			return
		}
		parseFuncsLocker.Lock()
		defer parseFuncsLocker.Unlock()
		for _, f := range filenames {
			parseFuncs[f] = func(nt *template.Template) {
				if _, err := nt.ParseFiles(f); err != nil {
					erpc.Errorf("ParseFiles: filename: %s, error: %s", f, err.Error())
				}
			}
		}
	}()
	_, err = t.ParseFiles(filenames...)
	return err
}