Add scripting (tengo) support for every incoming message (#731)

TengoModifyMessage allows you to specify the location of a tengo (https://github.com/d5/tengo/) script.
This script will receive every incoming message and can be used to modify the Username and the Text of that message.
The script will have the following global variables:
to modify: msgUsername and msgText
to read: msgChannel and msgAccount

The script is reloaded on every message, so you can modify the script on the fly.

Example script can be found in https://github.com/42wim/matterbridge/tree/master/gateway/bench.tengo
and https://github.com/42wim/matterbridge/tree/master/contrib/example.tengo

The example below will check if the text contains blah and if so, it'll replace the text and the username of that message.
text := import("text")
if text.re_match("blah",msgText) {
    msgText="replaced by this"
    msgUsername="fakeuser"
}

More information about tengo on: https://github.com/d5/tengo/blob/master/docs/tutorial.md and
https://github.com/d5/tengo/blob/master/docs/stdlib.md

12 files changed, 3718 insertions, 0 deletions

diff --git a/vendor/github.com/d5/tengo/stdlib/errors.go b/vendor/github.com/d5/tengo/stdlib/errors.go
new file mode 100644
index 00000000..a2942bb0
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/errors.go
@@ -0,0 +1,11 @@
+package stdlib
+
+import "github.com/d5/tengo/objects"
+
+func wrapError(err error) objects.Object {
+	if err == nil {
+		return objects.TrueValue
+	}
+
+	return &objects.Error{Value: &objects.String{Value: err.Error()}}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/func_typedefs.go b/vendor/github.com/d5/tengo/stdlib/func_typedefs.go
new file mode 100644
index 00000000..a85619fa
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/func_typedefs.go
@@ -0,0 +1,1057 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/d5/tengo/objects"
+)
+
+// FuncAR transform a function of 'func()' signature
+// into CallableFunc type.
+func FuncAR(fn func()) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		fn()
+
+		return objects.UndefinedValue, nil
+	}
+}
+
+// FuncARI transform a function of 'func() int' signature
+// into CallableFunc type.
+func FuncARI(fn func() int) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		return &objects.Int{Value: int64(fn())}, nil
+	}
+}
+
+// FuncARI64 transform a function of 'func() int64' signature
+// into CallableFunc type.
+func FuncARI64(fn func() int64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		return &objects.Int{Value: fn()}, nil
+	}
+}
+
+// FuncAI64RI64 transform a function of 'func(int64) int64' signature
+// into CallableFunc type.
+func FuncAI64RI64(fn func(int64) int64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.Int{Value: fn(i1)}, nil
+	}
+}
+
+// FuncAI64R transform a function of 'func(int64)' signature
+// into CallableFunc type.
+func FuncAI64R(fn func(int64)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		fn(i1)
+
+		return objects.UndefinedValue, nil
+	}
+}
+
+// FuncARB transform a function of 'func() bool' signature
+// into CallableFunc type.
+func FuncARB(fn func() bool) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		if fn() {
+			return objects.TrueValue, nil
+		}
+
+		return objects.FalseValue, nil
+	}
+}
+
+// FuncARE transform a function of 'func() error' signature
+// into CallableFunc type.
+func FuncARE(fn func() error) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		return wrapError(fn()), nil
+	}
+}
+
+// FuncARS transform a function of 'func() string' signature
+// into CallableFunc type.
+func FuncARS(fn func() string) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		return &objects.String{Value: fn()}, nil
+	}
+}
+
+// FuncARSE transform a function of 'func() (string, error)' signature
+// into CallableFunc type.
+func FuncARSE(fn func() (string, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		res, err := fn()
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		return &objects.String{Value: res}, nil
+	}
+}
+
+// FuncARYE transform a function of 'func() ([]byte, error)' signature
+// into CallableFunc type.
+func FuncARYE(fn func() ([]byte, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		res, err := fn()
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		return &objects.Bytes{Value: res}, nil
+	}
+}
+
+// FuncARF transform a function of 'func() float64' signature
+// into CallableFunc type.
+func FuncARF(fn func() float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		return &objects.Float{Value: fn()}, nil
+	}
+}
+
+// FuncARSs transform a function of 'func() []string' signature
+// into CallableFunc type.
+func FuncARSs(fn func() []string) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		arr := &objects.Array{}
+		for _, osArg := range fn() {
+			arr.Value = append(arr.Value, &objects.String{Value: osArg})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncARIsE transform a function of 'func() ([]int, error)' signature
+// into CallableFunc type.
+func FuncARIsE(fn func() ([]int, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 0 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		res, err := fn()
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		arr := &objects.Array{}
+		for _, v := range res {
+			arr.Value = append(arr.Value, &objects.Int{Value: int64(v)})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncAIRIs transform a function of 'func(int) []int' signature
+// into CallableFunc type.
+func FuncAIRIs(fn func(int) []int) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res := fn(i1)
+
+		arr := &objects.Array{}
+		for _, v := range res {
+			arr.Value = append(arr.Value, &objects.Int{Value: int64(v)})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncAFRF transform a function of 'func(float64) float64' signature
+// into CallableFunc type.
+func FuncAFRF(fn func(float64) float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.Float{Value: fn(f1)}, nil
+	}
+}
+
+// FuncAIR transform a function of 'func(int)' signature
+// into CallableFunc type.
+func FuncAIR(fn func(int)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		fn(i1)
+
+		return objects.UndefinedValue, nil
+	}
+}
+
+// FuncAIRF transform a function of 'func(int) float64' signature
+// into CallableFunc type.
+func FuncAIRF(fn func(int) float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.Float{Value: fn(i1)}, nil
+	}
+}
+
+// FuncAFRI transform a function of 'func(float64) int' signature
+// into CallableFunc type.
+func FuncAFRI(fn func(float64) int) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.Int{Value: int64(fn(f1))}, nil
+	}
+}
+
+// FuncAFFRF transform a function of 'func(float64, float64) float64' signature
+// into CallableFunc type.
+func FuncAFFRF(fn func(float64, float64) float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		f2, ok := objects.ToFloat64(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "float(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.Float{Value: fn(f1, f2)}, nil
+	}
+}
+
+// FuncAIFRF transform a function of 'func(int, float64) float64' signature
+// into CallableFunc type.
+func FuncAIFRF(fn func(int, float64) float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		f2, ok := objects.ToFloat64(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "float(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.Float{Value: fn(i1, f2)}, nil
+	}
+}
+
+// FuncAFIRF transform a function of 'func(float64, int) float64' signature
+// into CallableFunc type.
+func FuncAFIRF(fn func(float64, int) float64) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.Float{Value: fn(f1, i2)}, nil
+	}
+}
+
+// FuncAFIRB transform a function of 'func(float64, int) bool' signature
+// into CallableFunc type.
+func FuncAFIRB(fn func(float64, int) bool) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		if fn(f1, i2) {
+			return objects.TrueValue, nil
+		}
+
+		return objects.FalseValue, nil
+	}
+}
+
+// FuncAFRB transform a function of 'func(float64) bool' signature
+// into CallableFunc type.
+func FuncAFRB(fn func(float64) bool) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		f1, ok := objects.ToFloat64(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "float(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		if fn(f1) {
+			return objects.TrueValue, nil
+		}
+
+		return objects.FalseValue, nil
+	}
+}
+
+// FuncASRS transform a function of 'func(string) string' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRS(fn func(string) string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.String{Value: fn(s1)}, nil
+	}
+}
+
+// FuncASRSs transform a function of 'func(string) []string' signature into CallableFunc type.
+func FuncASRSs(fn func(string) []string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res := fn(s1)
+
+		arr := &objects.Array{}
+		for _, osArg := range res {
+			arr.Value = append(arr.Value, &objects.String{Value: osArg})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncASRSE transform a function of 'func(string) (string, error)' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRSE(fn func(string) (string, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res, err := fn(s1)
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		return &objects.String{Value: res}, nil
+	}
+}
+
+// FuncASRE transform a function of 'func(string) error' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASRE(fn func(string) error) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return wrapError(fn(s1)), nil
+	}
+}
+
+// FuncASSRE transform a function of 'func(string, string) error' signature into CallableFunc type.
+// User function will return 'true' if underlying native function returns nil.
+func FuncASSRE(fn func(string, string) error) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return wrapError(fn(s1, s2)), nil
+	}
+}
+
+// FuncASSRSs transform a function of 'func(string, string) []string' signature into CallableFunc type.
+func FuncASSRSs(fn func(string, string) []string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		arr := &objects.Array{}
+		for _, res := range fn(s1, s2) {
+			arr.Value = append(arr.Value, &objects.String{Value: res})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncASSIRSs transform a function of 'func(string, string, int) []string' signature into CallableFunc type.
+func FuncASSIRSs(fn func(string, string, int) []string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 3 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		i3, ok := objects.ToInt(args[2])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "third",
+				Expected: "int(compatible)",
+				Found:    args[2].TypeName(),
+			}
+		}
+
+		arr := &objects.Array{}
+		for _, res := range fn(s1, s2, i3) {
+			arr.Value = append(arr.Value, &objects.String{Value: res})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncASSRI transform a function of 'func(string, string) int' signature into CallableFunc type.
+func FuncASSRI(fn func(string, string) int) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.Int{Value: int64(fn(s1, s2))}, nil
+	}
+}
+
+// FuncASSRS transform a function of 'func(string, string) string' signature into CallableFunc type.
+func FuncASSRS(fn func(string, string) string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.String{Value: fn(s1, s2)}, nil
+	}
+}
+
+// FuncASSRB transform a function of 'func(string, string) bool' signature into CallableFunc type.
+func FuncASSRB(fn func(string, string) bool) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		if fn(s1, s2) {
+			return objects.TrueValue, nil
+		}
+
+		return objects.FalseValue, nil
+	}
+}
+
+// FuncASsSRS transform a function of 'func([]string, string) string' signature into CallableFunc type.
+func FuncASsSRS(fn func([]string, string) string) objects.CallableFunc {
+	return func(args ...objects.Object) (objects.Object, error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		var ss1 []string
+		switch arg0 := args[0].(type) {
+		case *objects.Array:
+			for idx, a := range arg0.Value {
+				as, ok := objects.ToString(a)
+				if !ok {
+					return nil, objects.ErrInvalidArgumentType{
+						Name:     fmt.Sprintf("first[%d]", idx),
+						Expected: "string(compatible)",
+						Found:    a.TypeName(),
+					}
+				}
+				ss1 = append(ss1, as)
+			}
+		case *objects.ImmutableArray:
+			for idx, a := range arg0.Value {
+				as, ok := objects.ToString(a)
+				if !ok {
+					return nil, objects.ErrInvalidArgumentType{
+						Name:     fmt.Sprintf("first[%d]", idx),
+						Expected: "string(compatible)",
+						Found:    a.TypeName(),
+					}
+				}
+				ss1 = append(ss1, as)
+			}
+		default:
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "array",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		s2, ok := objects.ToString(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "string(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.String{Value: fn(ss1, s2)}, nil
+	}
+}
+
+// FuncASI64RE transform a function of 'func(string, int64) error' signature
+// into CallableFunc type.
+func FuncASI64RE(fn func(string, int64) error) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt64(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return wrapError(fn(s1, i2)), nil
+	}
+}
+
+// FuncAIIRE transform a function of 'func(int, int) error' signature
+// into CallableFunc type.
+func FuncAIIRE(fn func(int, int) error) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return wrapError(fn(i1, i2)), nil
+	}
+}
+
+// FuncASIRS transform a function of 'func(string, int) string' signature
+// into CallableFunc type.
+func FuncASIRS(fn func(string, int) string) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 2 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		return &objects.String{Value: fn(s1, i2)}, nil
+	}
+}
+
+// FuncASIIRE transform a function of 'func(string, int, int) error' signature
+// into CallableFunc type.
+func FuncASIIRE(fn func(string, int, int) error) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 3 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		i2, ok := objects.ToInt(args[1])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "second",
+				Expected: "int(compatible)",
+				Found:    args[1].TypeName(),
+			}
+		}
+
+		i3, ok := objects.ToInt(args[2])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "third",
+				Expected: "int(compatible)",
+				Found:    args[2].TypeName(),
+			}
+		}
+
+		return wrapError(fn(s1, i2, i3)), nil
+	}
+}
+
+// FuncAYRIE transform a function of 'func([]byte) (int, error)' signature
+// into CallableFunc type.
+func FuncAYRIE(fn func([]byte) (int, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		y1, ok := objects.ToByteSlice(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "bytes(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res, err := fn(y1)
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		return &objects.Int{Value: int64(res)}, nil
+	}
+}
+
+// FuncASRIE transform a function of 'func(string) (int, error)' signature
+// into CallableFunc type.
+func FuncASRIE(fn func(string) (int, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		s1, ok := objects.ToString(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "string(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res, err := fn(s1)
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		return &objects.Int{Value: int64(res)}, nil
+	}
+}
+
+// FuncAIRSsE transform a function of 'func(int) ([]string, error)' signature
+// into CallableFunc type.
+func FuncAIRSsE(fn func(int) ([]string, error)) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		res, err := fn(i1)
+		if err != nil {
+			return wrapError(err), nil
+		}
+
+		arr := &objects.Array{}
+		for _, r := range res {
+			arr.Value = append(arr.Value, &objects.String{Value: r})
+		}
+
+		return arr, nil
+	}
+}
+
+// FuncAIRS transform a function of 'func(int) string' signature
+// into CallableFunc type.
+func FuncAIRS(fn func(int) string) objects.CallableFunc {
+	return func(args ...objects.Object) (ret objects.Object, err error) {
+		if len(args) != 1 {
+			return nil, objects.ErrWrongNumArguments
+		}
+
+		i1, ok := objects.ToInt(args[0])
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     "first",
+				Expected: "int(compatible)",
+				Found:    args[0].TypeName(),
+			}
+		}
+
+		return &objects.String{Value: fn(i1)}, nil
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/math.go b/vendor/github.com/d5/tengo/stdlib/math.go
new file mode 100644
index 00000000..08d82bdf
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/math.go
@@ -0,0 +1,74 @@
+package stdlib
+
+import (
+	"math"
+
+	"github.com/d5/tengo/objects"
+)
+
+var mathModule = map[string]objects.Object{
+	"e":         &objects.Float{Value: math.E},
+	"pi":        &objects.Float{Value: math.Pi},
+	"phi":       &objects.Float{Value: math.Phi},
+	"sqrt2":     &objects.Float{Value: math.Sqrt2},
+	"sqrtE":     &objects.Float{Value: math.SqrtE},
+	"sqrtPi":    &objects.Float{Value: math.SqrtPi},
+	"sqrtPhi":   &objects.Float{Value: math.SqrtPhi},
+	"ln2":       &objects.Float{Value: math.Ln2},
+	"log2E":     &objects.Float{Value: math.Log2E},
+	"ln10":      &objects.Float{Value: math.Ln10},
+	"log10E":    &objects.Float{Value: math.Log10E},
+	"abs":       &objects.UserFunction{Name: "abs", Value: FuncAFRF(math.Abs)},
+	"acos":      &objects.UserFunction{Name: "acos", Value: FuncAFRF(math.Acos)},
+	"acosh":     &objects.UserFunction{Name: "acosh", Value: FuncAFRF(math.Acosh)},
+	"asin":      &objects.UserFunction{Name: "asin", Value: FuncAFRF(math.Asin)},
+	"asinh":     &objects.UserFunction{Name: "asinh", Value: FuncAFRF(math.Asinh)},
+	"atan":      &objects.UserFunction{Name: "atan", Value: FuncAFRF(math.Atan)},
+	"atan2":     &objects.UserFunction{Name: "atan2", Value: FuncAFFRF(math.Atan2)},
+	"atanh":     &objects.UserFunction{Name: "atanh", Value: FuncAFRF(math.Atanh)},
+	"cbrt":      &objects.UserFunction{Name: "cbrt", Value: FuncAFRF(math.Cbrt)},
+	"ceil":      &objects.UserFunction{Name: "ceil", Value: FuncAFRF(math.Ceil)},
+	"copysign":  &objects.UserFunction{Name: "copysign", Value: FuncAFFRF(math.Copysign)},
+	"cos":       &objects.UserFunction{Name: "cos", Value: FuncAFRF(math.Cos)},
+	"cosh":      &objects.UserFunction{Name: "cosh", Value: FuncAFRF(math.Cosh)},
+	"dim":       &objects.UserFunction{Name: "dim", Value: FuncAFFRF(math.Dim)},
+	"erf":       &objects.UserFunction{Name: "erf", Value: FuncAFRF(math.Erf)},
+	"erfc":      &objects.UserFunction{Name: "erfc", Value: FuncAFRF(math.Erfc)},
+	"exp":       &objects.UserFunction{Name: "exp", Value: FuncAFRF(math.Exp)},
+	"exp2":      &objects.UserFunction{Name: "exp2", Value: FuncAFRF(math.Exp2)},
+	"expm1":     &objects.UserFunction{Name: "expm1", Value: FuncAFRF(math.Expm1)},
+	"floor":     &objects.UserFunction{Name: "floor", Value: FuncAFRF(math.Floor)},
+	"gamma":     &objects.UserFunction{Name: "gamma", Value: FuncAFRF(math.Gamma)},
+	"hypot":     &objects.UserFunction{Name: "hypot", Value: FuncAFFRF(math.Hypot)},
+	"ilogb":     &objects.UserFunction{Name: "ilogb", Value: FuncAFRI(math.Ilogb)},
+	"inf":       &objects.UserFunction{Name: "inf", Value: FuncAIRF(math.Inf)},
+	"is_inf":    &objects.UserFunction{Name: "is_inf", Value: FuncAFIRB(math.IsInf)},
+	"is_nan":    &objects.UserFunction{Name: "is_nan", Value: FuncAFRB(math.IsNaN)},
+	"j0":        &objects.UserFunction{Name: "j0", Value: FuncAFRF(math.J0)},
+	"j1":        &objects.UserFunction{Name: "j1", Value: FuncAFRF(math.J1)},
+	"jn":        &objects.UserFunction{Name: "jn", Value: FuncAIFRF(math.Jn)},
+	"ldexp":     &objects.UserFunction{Name: "ldexp", Value: FuncAFIRF(math.Ldexp)},
+	"log":       &objects.UserFunction{Name: "log", Value: FuncAFRF(math.Log)},
+	"log10":     &objects.UserFunction{Name: "log10", Value: FuncAFRF(math.Log10)},
+	"log1p":     &objects.UserFunction{Name: "log1p", Value: FuncAFRF(math.Log1p)},
+	"log2":      &objects.UserFunction{Name: "log2", Value: FuncAFRF(math.Log2)},
+	"logb":      &objects.UserFunction{Name: "logb", Value: FuncAFRF(math.Logb)},
+	"max":       &objects.UserFunction{Name: "max", Value: FuncAFFRF(math.Max)},
+	"min":       &objects.UserFunction{Name: "min", Value: FuncAFFRF(math.Min)},
+	"mod":       &objects.UserFunction{Name: "mod", Value: FuncAFFRF(math.Mod)},
+	"nan":       &objects.UserFunction{Name: "nan", Value: FuncARF(math.NaN)},
+	"nextafter": &objects.UserFunction{Name: "nextafter", Value: FuncAFFRF(math.Nextafter)},
+	"pow":       &objects.UserFunction{Name: "pow", Value: FuncAFFRF(math.Pow)},
+	"pow10":     &objects.UserFunction{Name: "pow10", Value: FuncAIRF(math.Pow10)},
+	"remainder": &objects.UserFunction{Name: "remainder", Value: FuncAFFRF(math.Remainder)},
+	"signbit":   &objects.UserFunction{Name: "signbit", Value: FuncAFRB(math.Signbit)},
+	"sin":       &objects.UserFunction{Name: "sin", Value: FuncAFRF(math.Sin)},
+	"sinh":      &objects.UserFunction{Name: "sinh", Value: FuncAFRF(math.Sinh)},
+	"sqrt":      &objects.UserFunction{Name: "sqrt", Value: FuncAFRF(math.Sqrt)},
+	"tan":       &objects.UserFunction{Name: "tan", Value: FuncAFRF(math.Tan)},
+	"tanh":      &objects.UserFunction{Name: "tanh", Value: FuncAFRF(math.Tanh)},
+	"trunc":     &objects.UserFunction{Name: "trunc", Value: FuncAFRF(math.Trunc)},
+	"y0":        &objects.UserFunction{Name: "y0", Value: FuncAFRF(math.Y0)},
+	"y1":        &objects.UserFunction{Name: "y1", Value: FuncAFRF(math.Y1)},
+	"yn":        &objects.UserFunction{Name: "yn", Value: FuncAIFRF(math.Yn)},
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os.go b/vendor/github.com/d5/tengo/stdlib/os.go
new file mode 100644
index 00000000..e68d5101
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os.go
@@ -0,0 +1,437 @@
+package stdlib
+
+import (
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+
+	"github.com/d5/tengo/objects"
+)
+
+var osModule = map[string]objects.Object{
+	"o_rdonly":            &objects.Int{Value: int64(os.O_RDONLY)},
+	"o_wronly":            &objects.Int{Value: int64(os.O_WRONLY)},
+	"o_rdwr":              &objects.Int{Value: int64(os.O_RDWR)},
+	"o_append":            &objects.Int{Value: int64(os.O_APPEND)},
+	"o_create":            &objects.Int{Value: int64(os.O_CREATE)},
+	"o_excl":              &objects.Int{Value: int64(os.O_EXCL)},
+	"o_sync":              &objects.Int{Value: int64(os.O_SYNC)},
+	"o_trunc":             &objects.Int{Value: int64(os.O_TRUNC)},
+	"mode_dir":            &objects.Int{Value: int64(os.ModeDir)},
+	"mode_append":         &objects.Int{Value: int64(os.ModeAppend)},
+	"mode_exclusive":      &objects.Int{Value: int64(os.ModeExclusive)},
+	"mode_temporary":      &objects.Int{Value: int64(os.ModeTemporary)},
+	"mode_symlink":        &objects.Int{Value: int64(os.ModeSymlink)},
+	"mode_device":         &objects.Int{Value: int64(os.ModeDevice)},
+	"mode_named_pipe":     &objects.Int{Value: int64(os.ModeNamedPipe)},
+	"mode_socket":         &objects.Int{Value: int64(os.ModeSocket)},
+	"mode_setuid":         &objects.Int{Value: int64(os.ModeSetuid)},
+	"mode_setgui":         &objects.Int{Value: int64(os.ModeSetgid)},
+	"mode_char_device":    &objects.Int{Value: int64(os.ModeCharDevice)},
+	"mode_sticky":         &objects.Int{Value: int64(os.ModeSticky)},
+	"mode_type":           &objects.Int{Value: int64(os.ModeType)},
+	"mode_perm":           &objects.Int{Value: int64(os.ModePerm)},
+	"path_separator":      &objects.Char{Value: os.PathSeparator},
+	"path_list_separator": &objects.Char{Value: os.PathListSeparator},
+	"dev_null":            &objects.String{Value: os.DevNull},
+	"seek_set":            &objects.Int{Value: int64(io.SeekStart)},
+	"seek_cur":            &objects.Int{Value: int64(io.SeekCurrent)},
+	"seek_end":            &objects.Int{Value: int64(io.SeekEnd)},
+	"args":                &objects.UserFunction{Value: osArgs},                                           // args() => array(string)
+	"chdir":               &objects.UserFunction{Name: "chdir", Value: FuncASRE(os.Chdir)},                // chdir(dir string) => error
+	"chmod":               osFuncASFmRE(os.Chmod),                                                         // chmod(name string, mode int) => error
+	"chown":               &objects.UserFunction{Name: "chown", Value: FuncASIIRE(os.Chown)},              // chown(name string, uid int, gid int) => error
+	"clearenv":            &objects.UserFunction{Name: "clearenv", Value: FuncAR(os.Clearenv)},            // clearenv()
+	"environ":             &objects.UserFunction{Name: "environ", Value: FuncARSs(os.Environ)},            // environ() => array(string)
+	"exit":                &objects.UserFunction{Name: "exit", Value: FuncAIR(os.Exit)},                   // exit(code int)
+	"expand_env":          &objects.UserFunction{Name: "expand_env", Value: FuncASRS(os.ExpandEnv)},       // expand_env(s string) => string
+	"getegid":             &objects.UserFunction{Name: "getegid", Value: FuncARI(os.Getegid)},             // getegid() => int
+	"getenv":              &objects.UserFunction{Name: "getenv", Value: FuncASRS(os.Getenv)},              // getenv(s string) => string
+	"geteuid":             &objects.UserFunction{Name: "geteuid", Value: FuncARI(os.Geteuid)},             // geteuid() => int
+	"getgid":              &objects.UserFunction{Name: "getgid", Value: FuncARI(os.Getgid)},               // getgid() => int
+	"getgroups":           &objects.UserFunction{Name: "getgroups", Value: FuncARIsE(os.Getgroups)},       // getgroups() => array(string)/error
+	"getpagesize":         &objects.UserFunction{Name: "getpagesize", Value: FuncARI(os.Getpagesize)},     // getpagesize() => int
+	"getpid":              &objects.UserFunction{Name: "getpid", Value: FuncARI(os.Getpid)},               // getpid() => int
+	"getppid":             &objects.UserFunction{Name: "getppid", Value: FuncARI(os.Getppid)},             // getppid() => int
+	"getuid":              &objects.UserFunction{Name: "getuid", Value: FuncARI(os.Getuid)},               // getuid() => int
+	"getwd":               &objects.UserFunction{Name: "getwd", Value: FuncARSE(os.Getwd)},                // getwd() => string/error
+	"hostname":            &objects.UserFunction{Name: "hostname", Value: FuncARSE(os.Hostname)},          // hostname() => string/error
+	"lchown":              &objects.UserFunction{Name: "lchown", Value: FuncASIIRE(os.Lchown)},            // lchown(name string, uid int, gid int) => error
+	"link":                &objects.UserFunction{Name: "link", Value: FuncASSRE(os.Link)},                 // link(oldname string, newname string) => error
+	"lookup_env":          &objects.UserFunction{Value: osLookupEnv},                                      // lookup_env(key string) => string/false
+	"mkdir":               osFuncASFmRE(os.Mkdir),                                                         // mkdir(name string, perm int) => error
+	"mkdir_all":           osFuncASFmRE(os.MkdirAll),                                                      // mkdir_all(name string, perm int) => error
+	"readlink":            &objects.UserFunction{Name: "readlink", Value: FuncASRSE(os.Readlink)},         // readlink(name string) => string/error
+	"remove":              &objects.UserFunction{Name: "remove", Value: FuncASRE(os.Remove)},              // remove(name string) => error
+	"remove_all":          &objects.UserFunction{Name: "remove_all", Value: FuncASRE(os.RemoveAll)},       // remove_all(name string) => error
+	"rename":              &objects.UserFunction{Name: "rename", Value: FuncASSRE(os.Rename)},             // rename(oldpath string, newpath string) => error
+	"setenv":              &objects.UserFunction{Name: "setenv", Value: FuncASSRE(os.Setenv)},             // setenv(key string, value string) => error
+	"symlink":             &objects.UserFunction{Name: "symlink", Value: FuncASSRE(os.Symlink)},           // symlink(oldname string newname string) => error
+	"temp_dir":            &objects.UserFunction{Name: "temp_dir", Value: FuncARS(os.TempDir)},            // temp_dir() => string
+	"truncate":            &objects.UserFunction{Name: "truncate", Value: FuncASI64RE(os.Truncate)},       // truncate(name string, size int) => error
+	"unsetenv":            &objects.UserFunction{Name: "unsetenv", Value: FuncASRE(os.Unsetenv)},          // unsetenv(key string) => error
+	"create":              &objects.UserFunction{Value: osCreate},                                         // create(name string) => imap(file)/error
+	"open":                &objects.UserFunction{Value: osOpen},                                           // open(name string) => imap(file)/error
+	"open_file":           &objects.UserFunction{Value: osOpenFile},                                       // open_file(name string, flag int, perm int) => imap(file)/error
+	"find_process":        &objects.UserFunction{Value: osFindProcess},                                    // find_process(pid int) => imap(process)/error
+	"start_process":       &objects.UserFunction{Value: osStartProcess},                                   // start_process(name string, argv array(string), dir string, env array(string)) => imap(process)/error
+	"exec_look_path":      &objects.UserFunction{Name: "exec_look_path", Value: FuncASRSE(exec.LookPath)}, // exec_look_path(file) => string/error
+	"exec":                &objects.UserFunction{Value: osExec},                                           // exec(name, args...) => command
+	"stat":                &objects.UserFunction{Value: osStat},                                           // stat(name) => imap(fileinfo)/error
+	"read_file":           &objects.UserFunction{Value: osReadFile},                                       // readfile(name) => array(byte)/error
+}
+
+func osReadFile(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	fname, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	bytes, err := ioutil.ReadFile(fname)
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return &objects.Bytes{Value: bytes}, nil
+}
+
+func osStat(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	fname, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	stat, err := os.Stat(fname)
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	fstat := &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			"name":  &objects.String{Value: stat.Name()},
+			"mtime": &objects.Time{Value: stat.ModTime()},
+			"size":  &objects.Int{Value: stat.Size()},
+			"mode":  &objects.Int{Value: int64(stat.Mode())},
+		},
+	}
+
+	if stat.IsDir() {
+		fstat.Value["directory"] = objects.TrueValue
+	} else {
+		fstat.Value["directory"] = objects.FalseValue
+	}
+
+	return fstat, nil
+}
+
+func osCreate(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	res, err := os.Create(s1)
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return makeOSFile(res), nil
+}
+
+func osOpen(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	res, err := os.Open(s1)
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return makeOSFile(res), nil
+}
+
+func osOpenFile(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 3 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+	}
+
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+	}
+
+	res, err := os.OpenFile(s1, i2, os.FileMode(i3))
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return makeOSFile(res), nil
+}
+
+func osArgs(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 0 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	arr := &objects.Array{}
+	for _, osArg := range os.Args {
+		arr.Value = append(arr.Value, &objects.String{Value: osArg})
+	}
+
+	return arr, nil
+}
+
+func osFuncASFmRE(fn func(string, os.FileMode) error) *objects.UserFunction {
+	return &objects.UserFunction{
+		Value: func(args ...objects.Object) (objects.Object, error) {
+			if len(args) != 2 {
+				return nil, objects.ErrWrongNumArguments
+			}
+
+			s1, ok := objects.ToString(args[0])
+			if !ok {
+				return nil, objects.ErrInvalidArgumentType{
+					Name:     "first",
+					Expected: "string(compatible)",
+					Found:    args[0].TypeName(),
+				}
+			}
+			i2, ok := objects.ToInt64(args[1])
+			if !ok {
+				return nil, objects.ErrInvalidArgumentType{
+					Name:     "second",
+					Expected: "int(compatible)",
+					Found:    args[1].TypeName(),
+				}
+			}
+
+			return wrapError(fn(s1, os.FileMode(i2))), nil
+		},
+	}
+}
+
+func osLookupEnv(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	res, ok := os.LookupEnv(s1)
+	if !ok {
+		return objects.FalseValue, nil
+	}
+
+	return &objects.String{Value: res}, nil
+}
+
+func osExec(args ...objects.Object) (objects.Object, error) {
+	if len(args) == 0 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	name, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	var execArgs []string
+	for idx, arg := range args[1:] {
+		execArg, ok := objects.ToString(arg)
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     fmt.Sprintf("args[%d]", idx),
+				Expected: "string(compatible)",
+				Found:    args[1+idx].TypeName(),
+			}
+		}
+
+		execArgs = append(execArgs, execArg)
+	}
+
+	return makeOSExecCommand(exec.Command(name, execArgs...)), nil
+}
+
+func osFindProcess(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 1 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	i1, ok := objects.ToInt(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	proc, err := os.FindProcess(i1)
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return makeOSProcess(proc), nil
+}
+
+func osStartProcess(args ...objects.Object) (objects.Object, error) {
+	if len(args) != 4 {
+		return nil, objects.ErrWrongNumArguments
+	}
+
+	name, ok := objects.ToString(args[0])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+	}
+
+	var argv []string
+	var err error
+	switch arg1 := args[1].(type) {
+	case *objects.Array:
+		argv, err = stringArray(arg1.Value, "second")
+		if err != nil {
+			return nil, err
+		}
+	case *objects.ImmutableArray:
+		argv, err = stringArray(arg1.Value, "second")
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "array",
+			Found:    arg1.TypeName(),
+		}
+	}
+
+	dir, ok := objects.ToString(args[2])
+	if !ok {
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "string(compatible)",
+			Found:    args[2].TypeName(),
+		}
+	}
+
+	var env []string
+	switch arg3 := args[3].(type) {
+	case *objects.Array:
+		env, err = stringArray(arg3.Value, "fourth")
+		if err != nil {
+			return nil, err
+		}
+	case *objects.ImmutableArray:
+		env, err = stringArray(arg3.Value, "fourth")
+		if err != nil {
+			return nil, err
+		}
+	default:
+		return nil, objects.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "array",
+			Found:    arg3.TypeName(),
+		}
+	}
+
+	proc, err := os.StartProcess(name, argv, &os.ProcAttr{
+		Dir: dir,
+		Env: env,
+	})
+	if err != nil {
+		return wrapError(err), nil
+	}
+
+	return makeOSProcess(proc), nil
+}
+
+func stringArray(arr []objects.Object, argName string) ([]string, error) {
+	var sarr []string
+	for idx, elem := range arr {
+		str, ok := elem.(*objects.String)
+		if !ok {
+			return nil, objects.ErrInvalidArgumentType{
+				Name:     fmt.Sprintf("%s[%d]", argName, idx),
+				Expected: "string",
+				Found:    elem.TypeName(),
+			}
+		}
+
+		sarr = append(sarr, str.Value)
+	}
+
+	return sarr, nil
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_exec.go b/vendor/github.com/d5/tengo/stdlib/os_exec.go
new file mode 100644
index 00000000..809c5810
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_exec.go
@@ -0,0 +1,109 @@
+package stdlib
+
+import (
+	"os/exec"
+
+	"github.com/d5/tengo/objects"
+)
+
+func makeOSExecCommand(cmd *exec.Cmd) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			// combined_output() => bytes/error
+			"combined_output": &objects.UserFunction{Name: "combined_output", Value: FuncARYE(cmd.CombinedOutput)}, //
+			// output() => bytes/error
+			"output": &objects.UserFunction{Name: "output", Value: FuncARYE(cmd.Output)}, //
+			// run() => error
+			"run": &objects.UserFunction{Name: "run", Value: FuncARE(cmd.Run)}, //
+			// start() => error
+			"start": &objects.UserFunction{Name: "start", Value: FuncARE(cmd.Start)}, //
+			// wait() => error
+			"wait": &objects.UserFunction{Name: "wait", Value: FuncARE(cmd.Wait)}, //
+			// set_path(path string)
+			"set_path": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+					}
+
+					cmd.Path = s1
+
+					return objects.UndefinedValue, nil
+				},
+			},
+			// set_dir(dir string)
+			"set_dir": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+					}
+
+					cmd.Dir = s1
+
+					return objects.UndefinedValue, nil
+				},
+			},
+			// set_env(env array(string))
+			"set_env": &objects.UserFunction{
+				Value: func(args ...objects.Object) (objects.Object, error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					var env []string
+					var err error
+					switch arg0 := args[0].(type) {
+					case *objects.Array:
+						env, err = stringArray(arg0.Value, "first")
+						if err != nil {
+							return nil, err
+						}
+					case *objects.ImmutableArray:
+						env, err = stringArray(arg0.Value, "first")
+						if err != nil {
+							return nil, err
+						}
+					default:
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "array",
+							Found:    arg0.TypeName(),
+						}
+					}
+
+					cmd.Env = env
+
+					return objects.UndefinedValue, nil
+				},
+			},
+			// process() => imap(process)
+			"process": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 0 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					return makeOSProcess(cmd.Process), nil
+				},
+			},
+		},
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_file.go b/vendor/github.com/d5/tengo/stdlib/os_file.go
new file mode 100644
index 00000000..4fc41dd8
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_file.go
@@ -0,0 +1,93 @@
+package stdlib
+
+import (
+	"os"
+
+	"github.com/d5/tengo/objects"
+)
+
+func makeOSFile(file *os.File) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			// chdir() => true/error
+			"chdir": &objects.UserFunction{Name: "chdir", Value: FuncARE(file.Chdir)}, //
+			// chown(uid int, gid int) => true/error
+			"chown": &objects.UserFunction{Name: "chown", Value: FuncAIIRE(file.Chown)}, //
+			// close() => error
+			"close": &objects.UserFunction{Name: "close", Value: FuncARE(file.Close)}, //
+			// name() => string
+			"name": &objects.UserFunction{Name: "name", Value: FuncARS(file.Name)}, //
+			// readdirnames(n int) => array(string)/error
+			"readdirnames": &objects.UserFunction{Name: "readdirnames", Value: FuncAIRSsE(file.Readdirnames)}, //
+			// sync() => error
+			"sync": &objects.UserFunction{Name: "sync", Value: FuncARE(file.Sync)}, //
+			// write(bytes) => int/error
+			"write": &objects.UserFunction{Name: "write", Value: FuncAYRIE(file.Write)}, //
+			// write(string) => int/error
+			"write_string": &objects.UserFunction{Name: "write_string", Value: FuncASRIE(file.WriteString)}, //
+			// read(bytes) => int/error
+			"read": &objects.UserFunction{Name: "read", Value: FuncAYRIE(file.Read)}, //
+			// chmod(mode int) => error
+			"chmod": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					i1, ok := objects.ToInt64(args[0])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "int(compatible)",
+							Found:    args[0].TypeName(),
+						}
+					}
+
+					return wrapError(file.Chmod(os.FileMode(i1))), nil
+				},
+			},
+			// seek(offset int, whence int) => int/error
+			"seek": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 2 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					i1, ok := objects.ToInt64(args[0])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "int(compatible)",
+							Found:    args[0].TypeName(),
+						}
+					}
+					i2, ok := objects.ToInt(args[1])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "second",
+							Expected: "int(compatible)",
+							Found:    args[1].TypeName(),
+						}
+					}
+
+					res, err := file.Seek(i1, i2)
+					if err != nil {
+						return wrapError(err), nil
+					}
+
+					return &objects.Int{Value: res}, nil
+				},
+			},
+			// stat() => imap(fileinfo)/error
+			"stat": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 0 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					return osStat(&objects.String{Value: file.Name()})
+				},
+			},
+		},
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/os_process.go b/vendor/github.com/d5/tengo/stdlib/os_process.go
new file mode 100644
index 00000000..0f4a9f77
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/os_process.go
@@ -0,0 +1,60 @@
+package stdlib
+
+import (
+	"os"
+	"syscall"
+
+	"github.com/d5/tengo/objects"
+)
+
+func makeOSProcessState(state *os.ProcessState) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			"exited":  &objects.UserFunction{Name: "exited", Value: FuncARB(state.Exited)},   //
+			"pid":     &objects.UserFunction{Name: "pid", Value: FuncARI(state.Pid)},         //
+			"string":  &objects.UserFunction{Name: "string", Value: FuncARS(state.String)},   //
+			"success": &objects.UserFunction{Name: "success", Value: FuncARB(state.Success)}, //
+		},
+	}
+}
+
+func makeOSProcess(proc *os.Process) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			"kill":    &objects.UserFunction{Name: "kill", Value: FuncARE(proc.Kill)},       //
+			"release": &objects.UserFunction{Name: "release", Value: FuncARE(proc.Release)}, //
+			"signal": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					i1, ok := objects.ToInt64(args[0])
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "int(compatible)",
+							Found:    args[0].TypeName(),
+						}
+					}
+
+					return wrapError(proc.Signal(syscall.Signal(i1))), nil
+				},
+			},
+			"wait": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 0 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					state, err := proc.Wait()
+					if err != nil {
+						return wrapError(err), nil
+					}
+
+					return makeOSProcessState(state), nil
+				},
+			},
+		},
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/rand.go b/vendor/github.com/d5/tengo/stdlib/rand.go
new file mode 100644
index 00000000..248d8e79
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/rand.go
@@ -0,0 +1,99 @@
+package stdlib
+
+import (
+	"math/rand"
+
+	"github.com/d5/tengo/objects"
+)
+
+var randModule = map[string]objects.Object{
+	"int":        &objects.UserFunction{Name: "int", Value: FuncARI64(rand.Int63)},
+	"float":      &objects.UserFunction{Name: "float", Value: FuncARF(rand.Float64)},
+	"intn":       &objects.UserFunction{Name: "intn", Value: FuncAI64RI64(rand.Int63n)},
+	"exp_float":  &objects.UserFunction{Name: "exp_float", Value: FuncARF(rand.ExpFloat64)},
+	"norm_float": &objects.UserFunction{Name: "norm_float", Value: FuncARF(rand.NormFloat64)},
+	"perm":       &objects.UserFunction{Name: "perm", Value: FuncAIRIs(rand.Perm)},
+	"seed":       &objects.UserFunction{Name: "seed", Value: FuncAI64R(rand.Seed)},
+	"read": &objects.UserFunction{
+		Value: func(args ...objects.Object) (ret objects.Object, err error) {
+			if len(args) != 1 {
+				return nil, objects.ErrWrongNumArguments
+			}
+
+			y1, ok := args[0].(*objects.Bytes)
+			if !ok {
+				return nil, objects.ErrInvalidArgumentType{
+					Name:     "first",
+					Expected: "bytes",
+					Found:    args[0].TypeName(),
+				}
+			}
+
+			res, err := rand.Read(y1.Value)
+			if err != nil {
+				ret = wrapError(err)
+				return
+			}
+
+			return &objects.Int{Value: int64(res)}, nil
+		},
+	},
+	"rand": &objects.UserFunction{
+		Value: func(args ...objects.Object) (ret objects.Object, err error) {
+			if len(args) != 1 {
+				return nil, objects.ErrWrongNumArguments
+			}
+
+			i1, ok := objects.ToInt64(args[0])
+			if !ok {
+				return nil, objects.ErrInvalidArgumentType{
+					Name:     "first",
+					Expected: "int(compatible)",
+					Found:    args[0].TypeName(),
+				}
+			}
+
+			src := rand.NewSource(i1)
+
+			return randRand(rand.New(src)), nil
+		},
+	},
+}
+
+func randRand(r *rand.Rand) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			"int":        &objects.UserFunction{Name: "int", Value: FuncARI64(r.Int63)},
+			"float":      &objects.UserFunction{Name: "float", Value: FuncARF(r.Float64)},
+			"intn":       &objects.UserFunction{Name: "intn", Value: FuncAI64RI64(r.Int63n)},
+			"exp_float":  &objects.UserFunction{Name: "exp_float", Value: FuncARF(r.ExpFloat64)},
+			"norm_float": &objects.UserFunction{Name: "norm_float", Value: FuncARF(r.NormFloat64)},
+			"perm":       &objects.UserFunction{Name: "perm", Value: FuncAIRIs(r.Perm)},
+			"seed":       &objects.UserFunction{Name: "seed", Value: FuncAI64R(r.Seed)},
+			"read": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						return nil, objects.ErrWrongNumArguments
+					}
+
+					y1, ok := args[0].(*objects.Bytes)
+					if !ok {
+						return nil, objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "bytes",
+							Found:    args[0].TypeName(),
+						}
+					}
+
+					res, err := r.Read(y1.Value)
+					if err != nil {
+						ret = wrapError(err)
+						return
+					}
+
+					return &objects.Int{Value: int64(res)}, nil
+				},
+			},
+		},
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/stdlib.go b/vendor/github.com/d5/tengo/stdlib/stdlib.go
new file mode 100644
index 00000000..d34fbc82
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/stdlib.go
@@ -0,0 +1,16 @@
+package stdlib
+
+import "github.com/d5/tengo/objects"
+
+// Modules contain the standard modules.
+var Modules = map[string]*objects.Object{
+	"math":  objectPtr(&objects.ImmutableMap{Value: mathModule}),
+	"os":    objectPtr(&objects.ImmutableMap{Value: osModule}),
+	"text":  objectPtr(&objects.ImmutableMap{Value: textModule}),
+	"times": objectPtr(&objects.ImmutableMap{Value: timesModule}),
+	"rand":  objectPtr(&objects.ImmutableMap{Value: randModule}),
+}
+
+func objectPtr(o objects.Object) *objects.Object {
+	return &o
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/text.go b/vendor/github.com/d5/tengo/stdlib/text.go
new file mode 100644
index 00000000..053bebf5
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/text.go
@@ -0,0 +1,585 @@
+package stdlib
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/d5/tengo/objects"
+)
+
+var textModule = map[string]objects.Object{
+	"re_match":       &objects.UserFunction{Value: textREMatch},                                             // re_match(pattern, text) => bool/error
+	"re_find":        &objects.UserFunction{Value: textREFind},                                              // re_find(pattern, text, count) => [[{text:,begin:,end:}]]/undefined
+	"re_replace":     &objects.UserFunction{Value: textREReplace},                                           // re_replace(pattern, text, repl) => string/error
+	"re_split":       &objects.UserFunction{Value: textRESplit},                                             // re_split(pattern, text, count) => [string]/error
+	"re_compile":     &objects.UserFunction{Value: textRECompile},                                           // re_compile(pattern) => Regexp/error
+	"compare":        &objects.UserFunction{Name: "compare", Value: FuncASSRI(strings.Compare)},             // compare(a, b) => int
+	"contains":       &objects.UserFunction{Name: "contains", Value: FuncASSRB(strings.Contains)},           // contains(s, substr) => bool
+	"contains_any":   &objects.UserFunction{Name: "contains_any", Value: FuncASSRB(strings.ContainsAny)},    // contains_any(s, chars) => bool
+	"count":          &objects.UserFunction{Name: "count", Value: FuncASSRI(strings.Count)},                 // count(s, substr) => int
+	"equal_fold":     &objects.UserFunction{Name: "equal_fold", Value: FuncASSRB(strings.EqualFold)},        // "equal_fold(s, t) => bool
+	"fields":         &objects.UserFunction{Name: "fields", Value: FuncASRSs(strings.Fields)},               // fields(s) => [string]
+	"has_prefix":     &objects.UserFunction{Name: "has_prefix", Value: FuncASSRB(strings.HasPrefix)},        // has_prefix(s, prefix) => bool
+	"has_suffix":     &objects.UserFunction{Name: "has_suffix", Value: FuncASSRB(strings.HasSuffix)},        // has_suffix(s, suffix) => bool
+	"index":          &objects.UserFunction{Name: "index", Value: FuncASSRI(strings.Index)},                 // index(s, substr) => int
+	"index_any":      &objects.UserFunction{Name: "index_any", Value: FuncASSRI(strings.IndexAny)},          // index_any(s, chars) => int
+	"join":           &objects.UserFunction{Name: "join", Value: FuncASsSRS(strings.Join)},                  // join(arr, sep) => string
+	"last_index":     &objects.UserFunction{Name: "last_index", Value: FuncASSRI(strings.LastIndex)},        // last_index(s, substr) => int
+	"last_index_any": &objects.UserFunction{Name: "last_index_any", Value: FuncASSRI(strings.LastIndexAny)}, // last_index_any(s, chars) => int
+	"repeat":         &objects.UserFunction{Name: "repeat", Value: FuncASIRS(strings.Repeat)},               // repeat(s, count) => string
+	"replace":        &objects.UserFunction{Value: textReplace},                                             // replace(s, old, new, n) => string
+	"split":          &objects.UserFunction{Name: "split", Value: FuncASSRSs(strings.Split)},                // split(s, sep) => [string]
+	"split_after":    &objects.UserFunction{Name: "split_after", Value: FuncASSRSs(strings.SplitAfter)},     // split_after(s, sep) => [string]
+	"split_after_n":  &objects.UserFunction{Name: "split_after_n", Value: FuncASSIRSs(strings.SplitAfterN)}, // split_after_n(s, sep, n) => [string]
+	"split_n":        &objects.UserFunction{Name: "split_n", Value: FuncASSIRSs(strings.SplitN)},            // split_n(s, sep, n) => [string]
+	"title":          &objects.UserFunction{Name: "title", Value: FuncASRS(strings.Title)},                  // title(s) => string
+	"to_lower":       &objects.UserFunction{Name: "to_lower", Value: FuncASRS(strings.ToLower)},             // to_lower(s) => string
+	"to_title":       &objects.UserFunction{Name: "to_title", Value: FuncASRS(strings.ToTitle)},             // to_title(s) => string
+	"to_upper":       &objects.UserFunction{Name: "to_upper", Value: FuncASRS(strings.ToUpper)},             // to_upper(s) => string
+	"trim_left":      &objects.UserFunction{Name: "trim_left", Value: FuncASSRS(strings.TrimLeft)},          // trim_left(s, cutset) => string
+	"trim_prefix":    &objects.UserFunction{Name: "trim_prefix", Value: FuncASSRS(strings.TrimPrefix)},      // trim_prefix(s, prefix) => string
+	"trim_right":     &objects.UserFunction{Name: "trim_right", Value: FuncASSRS(strings.TrimRight)},        // trim_right(s, cutset) => string
+	"trim_space":     &objects.UserFunction{Name: "trim_space", Value: FuncASRS(strings.TrimSpace)},         // trim_space(s) => string
+	"trim_suffix":    &objects.UserFunction{Name: "trim_suffix", Value: FuncASSRS(strings.TrimSuffix)},      // trim_suffix(s, suffix) => string
+	"atoi":           &objects.UserFunction{Name: "atoi", Value: FuncASRIE(strconv.Atoi)},                   // atoi(str) => int/error
+	"format_bool":    &objects.UserFunction{Value: textFormatBool},                                          // format_bool(b) => string
+	"format_float":   &objects.UserFunction{Value: textFormatFloat},                                         // format_float(f, fmt, prec, bits) => string
+	"format_int":     &objects.UserFunction{Value: textFormatInt},                                           // format_int(i, base) => string
+	"itoa":           &objects.UserFunction{Name: "itoa", Value: FuncAIRS(strconv.Itoa)},                    // itoa(i) => string
+	"parse_bool":     &objects.UserFunction{Value: textParseBool},                                           // parse_bool(str) => bool/error
+	"parse_float":    &objects.UserFunction{Value: textParseFloat},                                          // parse_float(str, bits) => float/error
+	"parse_int":      &objects.UserFunction{Value: textParseInt},                                            // parse_int(str, base, bits) => int/error
+	"quote":          &objects.UserFunction{Name: "quote", Value: FuncASRS(strconv.Quote)},                  // quote(str) => string
+	"unquote":        &objects.UserFunction{Name: "unquote", Value: FuncASRSE(strconv.Unquote)},             // unquote(str) => string/error
+}
+
+func textREMatch(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	matched, err := regexp.MatchString(s1, s2)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	if matched {
+		ret = objects.TrueValue
+	} else {
+		ret = objects.FalseValue
+	}
+
+	return
+}
+
+func textREFind(args ...objects.Object) (ret objects.Object, err error) {
+	numArgs := len(args)
+	if numArgs != 2 && numArgs != 3 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	re, err := regexp.Compile(s1)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	if numArgs < 3 {
+		m := re.FindStringSubmatchIndex(s2)
+		if m == nil {
+			ret = objects.UndefinedValue
+			return
+		}
+
+		arr := &objects.Array{}
+		for i := 0; i < len(m); i += 2 {
+			arr.Value = append(arr.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+				"text":  &objects.String{Value: s2[m[i]:m[i+1]]},
+				"begin": &objects.Int{Value: int64(m[i])},
+				"end":   &objects.Int{Value: int64(m[i+1])},
+			}})
+		}
+
+		ret = &objects.Array{Value: []objects.Object{arr}}
+
+		return
+	}
+
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+	m := re.FindAllStringSubmatchIndex(s2, i3)
+	if m == nil {
+		ret = objects.UndefinedValue
+		return
+	}
+
+	arr := &objects.Array{}
+	for _, m := range m {
+		subMatch := &objects.Array{}
+		for i := 0; i < len(m); i += 2 {
+			subMatch.Value = append(subMatch.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+				"text":  &objects.String{Value: s2[m[i]:m[i+1]]},
+				"begin": &objects.Int{Value: int64(m[i])},
+				"end":   &objects.Int{Value: int64(m[i+1])},
+			}})
+		}
+
+		arr.Value = append(arr.Value, subMatch)
+	}
+
+	ret = arr
+
+	return
+}
+
+func textREReplace(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 3 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	s3, ok := objects.ToString(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "string(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	re, err := regexp.Compile(s1)
+	if err != nil {
+		ret = wrapError(err)
+	} else {
+		ret = &objects.String{Value: re.ReplaceAllString(s2, s3)}
+	}
+
+	return
+}
+
+func textRESplit(args ...objects.Object) (ret objects.Object, err error) {
+	numArgs := len(args)
+	if numArgs != 2 && numArgs != 3 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	var i3 = -1
+	if numArgs > 2 {
+		i3, ok = objects.ToInt(args[2])
+		if !ok {
+			err = objects.ErrInvalidArgumentType{
+				Name:     "third",
+				Expected: "int(compatible)",
+				Found:    args[2].TypeName(),
+			}
+			return
+		}
+	}
+
+	re, err := regexp.Compile(s1)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	arr := &objects.Array{}
+	for _, s := range re.Split(s2, i3) {
+		arr.Value = append(arr.Value, &objects.String{Value: s})
+	}
+
+	ret = arr
+
+	return
+}
+
+func textRECompile(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	re, err := regexp.Compile(s1)
+	if err != nil {
+		ret = wrapError(err)
+	} else {
+		ret = makeTextRegexp(re)
+	}
+
+	return
+}
+
+func textReplace(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 4 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	s3, ok := objects.ToString(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "string(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	i4, ok := objects.ToInt(args[3])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: strings.Replace(s1, s2, s3, i4)}
+
+	return
+}
+
+func textFormatBool(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	b1, ok := args[0].(*objects.Bool)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "bool",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	if b1 == objects.TrueValue {
+		ret = &objects.String{Value: "true"}
+	} else {
+		ret = &objects.String{Value: "false"}
+	}
+
+	return
+}
+
+func textFormatFloat(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 4 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	f1, ok := args[0].(*objects.Float)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "float",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	i4, ok := objects.ToInt(args[3])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: strconv.FormatFloat(f1.Value, s2[0], i3, i4)}
+
+	return
+}
+
+func textFormatInt(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := args[0].(*objects.Int)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: strconv.FormatInt(i1.Value, i2)}
+
+	return
+}
+
+func textParseBool(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := args[0].(*objects.String)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	parsed, err := strconv.ParseBool(s1.Value)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	if parsed {
+		ret = objects.TrueValue
+	} else {
+		ret = objects.FalseValue
+	}
+
+	return
+}
+
+func textParseFloat(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := args[0].(*objects.String)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	parsed, err := strconv.ParseFloat(s1.Value, i2)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	ret = &objects.Float{Value: parsed}
+
+	return
+}
+
+func textParseInt(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 3 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := args[0].(*objects.String)
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	parsed, err := strconv.ParseInt(s1.Value, i2, i3)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	ret = &objects.Int{Value: parsed}
+
+	return
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/text_regexp.go b/vendor/github.com/d5/tengo/stdlib/text_regexp.go
new file mode 100644
index 00000000..3fb8b3b3
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/text_regexp.go
@@ -0,0 +1,195 @@
+package stdlib
+
+import (
+	"regexp"
+
+	"github.com/d5/tengo/objects"
+)
+
+func makeTextRegexp(re *regexp.Regexp) *objects.ImmutableMap {
+	return &objects.ImmutableMap{
+		Value: map[string]objects.Object{
+			// match(text) => bool
+			"match": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 1 {
+						err = objects.ErrWrongNumArguments
+						return
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+						return
+					}
+
+					if re.MatchString(s1) {
+						ret = objects.TrueValue
+					} else {
+						ret = objects.FalseValue
+					}
+
+					return
+				},
+			},
+
+			// find(text) 			=> array(array({text:,begin:,end:}))/undefined
+			// find(text, maxCount) => array(array({text:,begin:,end:}))/undefined
+			"find": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					numArgs := len(args)
+					if numArgs != 1 && numArgs != 2 {
+						err = objects.ErrWrongNumArguments
+						return
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+						return
+					}
+
+					if numArgs == 1 {
+						m := re.FindStringSubmatchIndex(s1)
+						if m == nil {
+							ret = objects.UndefinedValue
+							return
+						}
+
+						arr := &objects.Array{}
+						for i := 0; i < len(m); i += 2 {
+							arr.Value = append(arr.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+								"text":  &objects.String{Value: s1[m[i]:m[i+1]]},
+								"begin": &objects.Int{Value: int64(m[i])},
+								"end":   &objects.Int{Value: int64(m[i+1])},
+							}})
+						}
+
+						ret = &objects.Array{Value: []objects.Object{arr}}
+
+						return
+					}
+
+					i2, ok := objects.ToInt(args[1])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "second",
+							Expected: "int(compatible)",
+							Found:    args[1].TypeName(),
+						}
+						return
+					}
+					m := re.FindAllStringSubmatchIndex(s1, i2)
+					if m == nil {
+						ret = objects.UndefinedValue
+						return
+					}
+
+					arr := &objects.Array{}
+					for _, m := range m {
+						subMatch := &objects.Array{}
+						for i := 0; i < len(m); i += 2 {
+							subMatch.Value = append(subMatch.Value, &objects.ImmutableMap{Value: map[string]objects.Object{
+								"text":  &objects.String{Value: s1[m[i]:m[i+1]]},
+								"begin": &objects.Int{Value: int64(m[i])},
+								"end":   &objects.Int{Value: int64(m[i+1])},
+							}})
+						}
+
+						arr.Value = append(arr.Value, subMatch)
+					}
+
+					ret = arr
+
+					return
+				},
+			},
+
+			// replace(src, repl) => string
+			"replace": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					if len(args) != 2 {
+						err = objects.ErrWrongNumArguments
+						return
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+						return
+					}
+
+					s2, ok := objects.ToString(args[1])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "second",
+							Expected: "string(compatible)",
+							Found:    args[1].TypeName(),
+						}
+						return
+					}
+
+					ret = &objects.String{Value: re.ReplaceAllString(s1, s2)}
+
+					return
+				},
+			},
+
+			// split(text) 			 => array(string)
+			// split(text, maxCount) => array(string)
+			"split": &objects.UserFunction{
+				Value: func(args ...objects.Object) (ret objects.Object, err error) {
+					numArgs := len(args)
+					if numArgs != 1 && numArgs != 2 {
+						err = objects.ErrWrongNumArguments
+						return
+					}
+
+					s1, ok := objects.ToString(args[0])
+					if !ok {
+						err = objects.ErrInvalidArgumentType{
+							Name:     "first",
+							Expected: "string(compatible)",
+							Found:    args[0].TypeName(),
+						}
+						return
+					}
+
+					var i2 = -1
+					if numArgs > 1 {
+						i2, ok = objects.ToInt(args[1])
+						if !ok {
+							err = objects.ErrInvalidArgumentType{
+								Name:     "second",
+								Expected: "int(compatible)",
+								Found:    args[1].TypeName(),
+							}
+							return
+						}
+					}
+
+					arr := &objects.Array{}
+					for _, s := range re.Split(s1, i2) {
+						arr.Value = append(arr.Value, &objects.String{Value: s})
+					}
+
+					ret = arr
+
+					return
+				},
+			},
+		},
+	}
+}
diff --git a/vendor/github.com/d5/tengo/stdlib/times.go b/vendor/github.com/d5/tengo/stdlib/times.go
new file mode 100644
index 00000000..16d6d146
--- /dev/null
+++ b/vendor/github.com/d5/tengo/stdlib/times.go
@@ -0,0 +1,982 @@
+package stdlib
+
+import (
+	"time"
+
+	"github.com/d5/tengo/objects"
+)
+
+var timesModule = map[string]objects.Object{
+	"format_ansic":         &objects.String{Value: time.ANSIC},
+	"format_unix_date":     &objects.String{Value: time.UnixDate},
+	"format_ruby_date":     &objects.String{Value: time.RubyDate},
+	"format_rfc822":        &objects.String{Value: time.RFC822},
+	"format_rfc822z":       &objects.String{Value: time.RFC822Z},
+	"format_rfc850":        &objects.String{Value: time.RFC850},
+	"format_rfc1123":       &objects.String{Value: time.RFC1123},
+	"format_rfc1123z":      &objects.String{Value: time.RFC1123Z},
+	"format_rfc3339":       &objects.String{Value: time.RFC3339},
+	"format_rfc3339_nano":  &objects.String{Value: time.RFC3339Nano},
+	"format_kitchen":       &objects.String{Value: time.Kitchen},
+	"format_stamp":         &objects.String{Value: time.Stamp},
+	"format_stamp_milli":   &objects.String{Value: time.StampMilli},
+	"format_stamp_micro":   &objects.String{Value: time.StampMicro},
+	"format_stamp_nano":    &objects.String{Value: time.StampNano},
+	"nanosecond":           &objects.Int{Value: int64(time.Nanosecond)},
+	"microsecond":          &objects.Int{Value: int64(time.Microsecond)},
+	"millisecond":          &objects.Int{Value: int64(time.Millisecond)},
+	"second":               &objects.Int{Value: int64(time.Second)},
+	"minute":               &objects.Int{Value: int64(time.Minute)},
+	"hour":                 &objects.Int{Value: int64(time.Hour)},
+	"january":              &objects.Int{Value: int64(time.January)},
+	"february":             &objects.Int{Value: int64(time.February)},
+	"march":                &objects.Int{Value: int64(time.March)},
+	"april":                &objects.Int{Value: int64(time.April)},
+	"may":                  &objects.Int{Value: int64(time.May)},
+	"june":                 &objects.Int{Value: int64(time.June)},
+	"july":                 &objects.Int{Value: int64(time.July)},
+	"august":               &objects.Int{Value: int64(time.August)},
+	"september":            &objects.Int{Value: int64(time.September)},
+	"october":              &objects.Int{Value: int64(time.October)},
+	"november":             &objects.Int{Value: int64(time.November)},
+	"december":             &objects.Int{Value: int64(time.December)},
+	"sleep":                &objects.UserFunction{Name: "sleep", Value: timesSleep},                              // sleep(int)
+	"parse_duration":       &objects.UserFunction{Name: "parse_duration", Value: timesParseDuration},             // parse_duration(str) => int
+	"since":                &objects.UserFunction{Name: "since", Value: timesSince},                              // since(time) => int
+	"until":                &objects.UserFunction{Name: "until", Value: timesUntil},                              // until(time) => int
+	"duration_hours":       &objects.UserFunction{Name: "duration_hours", Value: timesDurationHours},             // duration_hours(int) => float
+	"duration_minutes":     &objects.UserFunction{Name: "duration_minutes", Value: timesDurationMinutes},         // duration_minutes(int) => float
+	"duration_nanoseconds": &objects.UserFunction{Name: "duration_nanoseconds", Value: timesDurationNanoseconds}, // duration_nanoseconds(int) => int
+	"duration_seconds":     &objects.UserFunction{Name: "duration_seconds", Value: timesDurationSeconds},         // duration_seconds(int) => float
+	"duration_string":      &objects.UserFunction{Name: "duration_string", Value: timesDurationString},           // duration_string(int) => string
+	"month_string":         &objects.UserFunction{Name: "month_string", Value: timesMonthString},                 // month_string(int) => string
+	"date":                 &objects.UserFunction{Name: "date", Value: timesDate},                                // date(year, month, day, hour, min, sec, nsec) => time
+	"now":                  &objects.UserFunction{Name: "now", Value: timesNow},                                  // now() => time
+	"parse":                &objects.UserFunction{Name: "parse", Value: timesParse},                              // parse(format, str) => time
+	"unix":                 &objects.UserFunction{Name: "unix", Value: timesUnix},                                // unix(sec, nsec) => time
+	"add":                  &objects.UserFunction{Name: "add", Value: timesAdd},                                  // add(time, int) => time
+	"add_date":             &objects.UserFunction{Name: "add_date", Value: timesAddDate},                         // add_date(time, years, months, days) => time
+	"sub":                  &objects.UserFunction{Name: "sub", Value: timesSub},                                  // sub(t time, u time) => int
+	"after":                &objects.UserFunction{Name: "after", Value: timesAfter},                              // after(t time, u time) => bool
+	"before":               &objects.UserFunction{Name: "before", Value: timesBefore},                            // before(t time, u time) => bool
+	"time_year":            &objects.UserFunction{Name: "time_year", Value: timesTimeYear},                       // time_year(time) => int
+	"time_month":           &objects.UserFunction{Name: "time_month", Value: timesTimeMonth},                     // time_month(time) => int
+	"time_day":             &objects.UserFunction{Name: "time_day", Value: timesTimeDay},                         // time_day(time) => int
+	"time_weekday":         &objects.UserFunction{Name: "time_weekday", Value: timesTimeWeekday},                 // time_weekday(time) => int
+	"time_hour":            &objects.UserFunction{Name: "time_hour", Value: timesTimeHour},                       // time_hour(time) => int
+	"time_minute":          &objects.UserFunction{Name: "time_minute", Value: timesTimeMinute},                   // time_minute(time) => int
+	"time_second":          &objects.UserFunction{Name: "time_second", Value: timesTimeSecond},                   // time_second(time) => int
+	"time_nanosecond":      &objects.UserFunction{Name: "time_nanosecond", Value: timesTimeNanosecond},           // time_nanosecond(time) => int
+	"time_unix":            &objects.UserFunction{Name: "time_unix", Value: timesTimeUnix},                       // time_unix(time) => int
+	"time_unix_nano":       &objects.UserFunction{Name: "time_unix_nano", Value: timesTimeUnixNano},              // time_unix_nano(time) => int
+	"time_format":          &objects.UserFunction{Name: "time_format", Value: timesTimeFormat},                   // time_format(time, format) => string
+	"time_location":        &objects.UserFunction{Name: "time_location", Value: timesTimeLocation},               // time_location(time) => string
+	"time_string":          &objects.UserFunction{Name: "time_string", Value: timesTimeString},                   // time_string(time) => string
+	"is_zero":              &objects.UserFunction{Name: "is_zero", Value: timesIsZero},                           // is_zero(time) => bool
+	"to_local":             &objects.UserFunction{Name: "to_local", Value: timesToLocal},                         // to_local(time) => time
+	"to_utc":               &objects.UserFunction{Name: "to_utc", Value: timesToUTC},                             // to_utc(time) => time
+}
+
+func timesSleep(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	time.Sleep(time.Duration(i1))
+	ret = objects.UndefinedValue
+
+	return
+}
+
+func timesParseDuration(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	dur, err := time.ParseDuration(s1)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	ret = &objects.Int{Value: int64(dur)}
+
+	return
+}
+
+func timesSince(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(time.Since(t1))}
+
+	return
+}
+
+func timesUntil(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(time.Until(t1))}
+
+	return
+}
+
+func timesDurationHours(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Float{Value: time.Duration(i1).Hours()}
+
+	return
+}
+
+func timesDurationMinutes(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Float{Value: time.Duration(i1).Minutes()}
+
+	return
+}
+
+func timesDurationNanoseconds(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: time.Duration(i1).Nanoseconds()}
+
+	return
+}
+
+func timesDurationSeconds(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Float{Value: time.Duration(i1).Seconds()}
+
+	return
+}
+
+func timesDurationString(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: time.Duration(i1).String()}
+
+	return
+}
+
+func timesMonthString(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: time.Month(i1).String()}
+
+	return
+}
+
+func timesDate(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 7 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+	i4, ok := objects.ToInt(args[3])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+	i5, ok := objects.ToInt(args[4])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "fifth",
+			Expected: "int(compatible)",
+			Found:    args[4].TypeName(),
+		}
+		return
+	}
+	i6, ok := objects.ToInt(args[5])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "sixth",
+			Expected: "int(compatible)",
+			Found:    args[5].TypeName(),
+		}
+		return
+	}
+	i7, ok := objects.ToInt(args[6])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "seventh",
+			Expected: "int(compatible)",
+			Found:    args[6].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: time.Date(i1, time.Month(i2), i3, i4, i5, i6, i7, time.Now().Location())}
+
+	return
+}
+
+func timesNow(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 0 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	ret = &objects.Time{Value: time.Now()}
+
+	return
+}
+
+func timesParse(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := objects.ToString(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	parsed, err := time.Parse(s1, s2)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	ret = &objects.Time{Value: parsed}
+
+	return
+}
+
+func timesUnix(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := objects.ToInt64(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt64(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: time.Unix(i1, i2)}
+
+	return
+}
+
+func timesAdd(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt64(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: t1.Add(time.Duration(i2))}
+
+	return
+}
+
+func timesSub(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := objects.ToTime(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Sub(t2))}
+
+	return
+}
+
+func timesAddDate(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 4 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := objects.ToInt(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	i3, ok := objects.ToInt(args[2])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	i4, ok := objects.ToInt(args[3])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: t1.AddDate(i2, i3, i4)}
+
+	return
+}
+
+func timesAfter(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := objects.ToTime(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	if t1.After(t2) {
+		ret = objects.TrueValue
+	} else {
+		ret = objects.FalseValue
+	}
+
+	return
+}
+
+func timesBefore(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := objects.ToTime(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	if t1.Before(t2) {
+		ret = objects.TrueValue
+	} else {
+		ret = objects.FalseValue
+	}
+
+	return
+}
+
+func timesTimeYear(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Year())}
+
+	return
+}
+
+func timesTimeMonth(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Month())}
+
+	return
+}
+
+func timesTimeDay(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Day())}
+
+	return
+}
+
+func timesTimeWeekday(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Weekday())}
+
+	return
+}
+
+func timesTimeHour(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Hour())}
+
+	return
+}
+
+func timesTimeMinute(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Minute())}
+
+	return
+}
+
+func timesTimeSecond(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Second())}
+
+	return
+}
+
+func timesTimeNanosecond(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Nanosecond())}
+
+	return
+}
+
+func timesTimeUnix(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.Unix())}
+
+	return
+}
+
+func timesTimeUnixNano(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Int{Value: int64(t1.UnixNano())}
+
+	return
+}
+
+func timesTimeFormat(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 2 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := objects.ToString(args[1])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: t1.Format(s2)}
+
+	return
+}
+
+func timesIsZero(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	if t1.IsZero() {
+		ret = objects.TrueValue
+	} else {
+		ret = objects.FalseValue
+	}
+
+	return
+}
+
+func timesToLocal(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: t1.Local()}
+
+	return
+}
+
+func timesToUTC(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.Time{Value: t1.UTC()}
+
+	return
+}
+
+func timesTimeLocation(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: t1.Location().String()}
+
+	return
+}
+
+func timesTimeString(args ...objects.Object) (ret objects.Object, err error) {
+	if len(args) != 1 {
+		err = objects.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := objects.ToTime(args[0])
+	if !ok {
+		err = objects.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &objects.String{Value: t1.String()}
+
+	return
+}