golang with script

func NewLuaStateWithLib(opts ...lua.Options) *lua.LState {
	L := lua.NewState(opts...)
	InstallAll(L)
	return L
}

func InstallAll(L *lua.LState) {
	L.SetGlobal("http", luar.New(L, &Http{}))
	L.SetGlobal("regexp", luar.New(L, &Regexp{}))
	L.SetGlobal("ioutil", luar.New(L, &IoUtil{}))
	L.SetGlobal("exec", luar.New(L, &Exec{}))
	L.SetGlobal("time", luar.New(L, &Time{}))
	L.SetGlobal("resty", luar.New(L, &Resty{}))
	L.SetGlobal("colly", luar.New(L, &Colly{}))

	// more... pls refer to: github.com/vadv/gopher-lua-libs
}

// Http ----------------------------------------------------------------------------------------------------------------
type Http struct{}

func (h Http) DefaultClient() *http.Client { return http.DefaultClient }

// Regex ---------------------------------------------------------------------------------------------------------------
type Regexp struct{}

func (r Regexp) Compile(a string) (*regexp.Regexp, error)     { return regexp.Compile(a) }
func (r Regexp) Match(a string, b []byte) (bool, error)       { return regexp.Match(a, b) }
func (r Regexp) MatchString(a string, b string) (bool, error) { return regexp.MatchString(a, b) }

// IoUtils -------------------------------------------------------------------------------------------------------------
type IoUtil struct{}

func (i IoUtil) ReadAll(a io.Reader) ([]byte, error)               { return ioutil.ReadAll(a) }
func (i IoUtil) ReadFile(filename string) ([]byte, error)          { return os.ReadFile(filename) }
func (i IoUtil) WriteFile(a string, b []byte, c fs.FileMode) error { return os.WriteFile(a, b, c) }
func (i IoUtil) ReadDir(dirname string) ([]fs.FileInfo, error)     { return ioutil.ReadDir(dirname) }

type Url struct{}

func (u Url) Parse(a string) (*url.URL, error) { return url.Parse(a) }

// Cmd -----------------------------------------------------------------------------------------------------------------
type Exec struct{}

func (c Exec) Cmd(a ...string) *exec.Cmd { return exec.Command(a[0], a[1:]...) }
func (c Exec) Run(a ...string) ([]byte, []byte, error) {
	out, err := bytes.NewBuffer(nil), bytes.NewBuffer(nil)
	cmd := exec.Command(a[0], a[1:]...)
	cmd.Stdout, cmd.Stderr = out, err
	err1 := cmd.Run()
	return out.Bytes(), err.Bytes(), err1
}

type Time struct{}

func (t Time) Parse(a, b string) (time.Time, error) { return time.Parse(a, b) }
func (t Time) Now() time.Time                       { return time.Now() }

// Colly ---------------------------------------------------------------------------------------------------------------
type Colly struct{}

func (c Colly) New() *colly.Collector { return colly.NewCollector() }

// Resty ---------------------------------------------------------------------------------------------------------------
type Resty struct{}

func (c Resty) New() *resty.Client { r := resty.New(); return r }
func (c Resty) NewRequestWithResult(a M) *resty.Request {
	r := resty.New().NewRequest().SetResult(&a)
	return r
}

func InstallAllExampleModule(d starlark.StringDict) {
	for _, v := range exampleModules {
		d[v.Name] = v
	}
}

var exampleModules = []*starlarkstruct.Module{
	GreetModule,
	{
		Name: "modules",
		Members: starlark.StringDict{
			"all": ToValue(func() (ret []string) {
				for _, v := range starlark.Universe {
					if m, ok := v.(*starlarkstruct.Module); ok {
						ret = append(ret, m.Name)
					}
				}
				return
			}),
			"inspect": ToValue(func(a string) (ret []string) {
				if v, ok := starlark.Universe[a]; ok {
					if m, ok := v.(*starlarkstruct.Module); ok {
						for x, y := range m.Members {
							ret = append(ret, fmt.Sprintf("%s: [%s, %s]", x, y.Type(), y.String()))
						}
					}
				}
				return
			}),
		},
	},
	{
		Name: "http",
		Members: starlark.StringDict{
			"get":           ToValue(http.Get),
			"pos":           ToValue(http.Post),
			"defaultClient": ToValue(http.DefaultClient),
		},
	},
	{
		Name: "ioutil",
		Members: starlark.StringDict{
			"read_all":   ToValue(ioutil.ReadAll),
			"read_file":  ToValue(os.ReadFile),
			"write_file": ToValue(os.WriteFile),
			"read_dir":   ToValue(os.ReadDir),
		},
	},
	{
		Name: "strings",
		Members: starlark.StringDict{
			"contains": ToValue(strings.Contains),
			"split":    ToValue(strings.Split),
		},
	},
	{
		Name: "url",
		Members: starlark.StringDict{
			"parse": ToValue(url.Parse),
		},
	},
	{
		Name: "resty",
		Members: starlark.StringDict{
			"new": ToValue(resty.New),
		},
	},
}

type KernelInterface interface {
	Init() error
	Eval(outerr OutErr, code string) (val []interface{}, err error)
	Name() string
}