Update to tengo v2 (#976)

1 files changed, 1135 insertions, 0 deletions

diff --git a/vendor/github.com/d5/tengo/v2/stdlib/times.go b/vendor/github.com/d5/tengo/v2/stdlib/times.go
new file mode 100644
index 00000000..0b6f7bd4
--- /dev/null
+++ b/vendor/github.com/d5/tengo/v2/stdlib/times.go
@@ -0,0 +1,1135 @@
+package stdlib
+
+import (
+	"time"
+
+	"github.com/d5/tengo/v2"
+)
+
+var timesModule = map[string]tengo.Object{
+	"format_ansic":        &tengo.String{Value: time.ANSIC},
+	"format_unix_date":    &tengo.String{Value: time.UnixDate},
+	"format_ruby_date":    &tengo.String{Value: time.RubyDate},
+	"format_rfc822":       &tengo.String{Value: time.RFC822},
+	"format_rfc822z":      &tengo.String{Value: time.RFC822Z},
+	"format_rfc850":       &tengo.String{Value: time.RFC850},
+	"format_rfc1123":      &tengo.String{Value: time.RFC1123},
+	"format_rfc1123z":     &tengo.String{Value: time.RFC1123Z},
+	"format_rfc3339":      &tengo.String{Value: time.RFC3339},
+	"format_rfc3339_nano": &tengo.String{Value: time.RFC3339Nano},
+	"format_kitchen":      &tengo.String{Value: time.Kitchen},
+	"format_stamp":        &tengo.String{Value: time.Stamp},
+	"format_stamp_milli":  &tengo.String{Value: time.StampMilli},
+	"format_stamp_micro":  &tengo.String{Value: time.StampMicro},
+	"format_stamp_nano":   &tengo.String{Value: time.StampNano},
+	"nanosecond":          &tengo.Int{Value: int64(time.Nanosecond)},
+	"microsecond":         &tengo.Int{Value: int64(time.Microsecond)},
+	"millisecond":         &tengo.Int{Value: int64(time.Millisecond)},
+	"second":              &tengo.Int{Value: int64(time.Second)},
+	"minute":              &tengo.Int{Value: int64(time.Minute)},
+	"hour":                &tengo.Int{Value: int64(time.Hour)},
+	"january":             &tengo.Int{Value: int64(time.January)},
+	"february":            &tengo.Int{Value: int64(time.February)},
+	"march":               &tengo.Int{Value: int64(time.March)},
+	"april":               &tengo.Int{Value: int64(time.April)},
+	"may":                 &tengo.Int{Value: int64(time.May)},
+	"june":                &tengo.Int{Value: int64(time.June)},
+	"july":                &tengo.Int{Value: int64(time.July)},
+	"august":              &tengo.Int{Value: int64(time.August)},
+	"september":           &tengo.Int{Value: int64(time.September)},
+	"october":             &tengo.Int{Value: int64(time.October)},
+	"november":            &tengo.Int{Value: int64(time.November)},
+	"december":            &tengo.Int{Value: int64(time.December)},
+	"sleep": &tengo.UserFunction{
+		Name:  "sleep",
+		Value: timesSleep,
+	}, // sleep(int)
+	"parse_duration": &tengo.UserFunction{
+		Name:  "parse_duration",
+		Value: timesParseDuration,
+	}, // parse_duration(str) => int
+	"since": &tengo.UserFunction{
+		Name:  "since",
+		Value: timesSince,
+	}, // since(time) => int
+	"until": &tengo.UserFunction{
+		Name:  "until",
+		Value: timesUntil,
+	}, // until(time) => int
+	"duration_hours": &tengo.UserFunction{
+		Name:  "duration_hours",
+		Value: timesDurationHours,
+	}, // duration_hours(int) => float
+	"duration_minutes": &tengo.UserFunction{
+		Name:  "duration_minutes",
+		Value: timesDurationMinutes,
+	}, // duration_minutes(int) => float
+	"duration_nanoseconds": &tengo.UserFunction{
+		Name:  "duration_nanoseconds",
+		Value: timesDurationNanoseconds,
+	}, // duration_nanoseconds(int) => int
+	"duration_seconds": &tengo.UserFunction{
+		Name:  "duration_seconds",
+		Value: timesDurationSeconds,
+	}, // duration_seconds(int) => float
+	"duration_string": &tengo.UserFunction{
+		Name:  "duration_string",
+		Value: timesDurationString,
+	}, // duration_string(int) => string
+	"month_string": &tengo.UserFunction{
+		Name:  "month_string",
+		Value: timesMonthString,
+	}, // month_string(int) => string
+	"date": &tengo.UserFunction{
+		Name:  "date",
+		Value: timesDate,
+	}, // date(year, month, day, hour, min, sec, nsec) => time
+	"now": &tengo.UserFunction{
+		Name:  "now",
+		Value: timesNow,
+	}, // now() => time
+	"parse": &tengo.UserFunction{
+		Name:  "parse",
+		Value: timesParse,
+	}, // parse(format, str) => time
+	"unix": &tengo.UserFunction{
+		Name:  "unix",
+		Value: timesUnix,
+	}, // unix(sec, nsec) => time
+	"add": &tengo.UserFunction{
+		Name:  "add",
+		Value: timesAdd,
+	}, // add(time, int) => time
+	"add_date": &tengo.UserFunction{
+		Name:  "add_date",
+		Value: timesAddDate,
+	}, // add_date(time, years, months, days) => time
+	"sub": &tengo.UserFunction{
+		Name:  "sub",
+		Value: timesSub,
+	}, // sub(t time, u time) => int
+	"after": &tengo.UserFunction{
+		Name:  "after",
+		Value: timesAfter,
+	}, // after(t time, u time) => bool
+	"before": &tengo.UserFunction{
+		Name:  "before",
+		Value: timesBefore,
+	}, // before(t time, u time) => bool
+	"time_year": &tengo.UserFunction{
+		Name:  "time_year",
+		Value: timesTimeYear,
+	}, // time_year(time) => int
+	"time_month": &tengo.UserFunction{
+		Name:  "time_month",
+		Value: timesTimeMonth,
+	}, // time_month(time) => int
+	"time_day": &tengo.UserFunction{
+		Name:  "time_day",
+		Value: timesTimeDay,
+	}, // time_day(time) => int
+	"time_weekday": &tengo.UserFunction{
+		Name:  "time_weekday",
+		Value: timesTimeWeekday,
+	}, // time_weekday(time) => int
+	"time_hour": &tengo.UserFunction{
+		Name:  "time_hour",
+		Value: timesTimeHour,
+	}, // time_hour(time) => int
+	"time_minute": &tengo.UserFunction{
+		Name:  "time_minute",
+		Value: timesTimeMinute,
+	}, // time_minute(time) => int
+	"time_second": &tengo.UserFunction{
+		Name:  "time_second",
+		Value: timesTimeSecond,
+	}, // time_second(time) => int
+	"time_nanosecond": &tengo.UserFunction{
+		Name:  "time_nanosecond",
+		Value: timesTimeNanosecond,
+	}, // time_nanosecond(time) => int
+	"time_unix": &tengo.UserFunction{
+		Name:  "time_unix",
+		Value: timesTimeUnix,
+	}, // time_unix(time) => int
+	"time_unix_nano": &tengo.UserFunction{
+		Name:  "time_unix_nano",
+		Value: timesTimeUnixNano,
+	}, // time_unix_nano(time) => int
+	"time_format": &tengo.UserFunction{
+		Name:  "time_format",
+		Value: timesTimeFormat,
+	}, // time_format(time, format) => string
+	"time_location": &tengo.UserFunction{
+		Name:  "time_location",
+		Value: timesTimeLocation,
+	}, // time_location(time) => string
+	"time_string": &tengo.UserFunction{
+		Name:  "time_string",
+		Value: timesTimeString,
+	}, // time_string(time) => string
+	"is_zero": &tengo.UserFunction{
+		Name:  "is_zero",
+		Value: timesIsZero,
+	}, // is_zero(time) => bool
+	"to_local": &tengo.UserFunction{
+		Name:  "to_local",
+		Value: timesToLocal,
+	}, // to_local(time) => time
+	"to_utc": &tengo.UserFunction{
+		Name:  "to_utc",
+		Value: timesToUTC,
+	}, // to_utc(time) => time
+}
+
+func timesSleep(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	time.Sleep(time.Duration(i1))
+	ret = tengo.UndefinedValue
+
+	return
+}
+
+func timesParseDuration(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := tengo.ToString(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	dur, err := time.ParseDuration(s1)
+	if err != nil {
+		ret = wrapError(err)
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(dur)}
+
+	return
+}
+
+func timesSince(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(time.Since(t1))}
+
+	return
+}
+
+func timesUntil(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(time.Until(t1))}
+
+	return
+}
+
+func timesDurationHours(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Float{Value: time.Duration(i1).Hours()}
+
+	return
+}
+
+func timesDurationMinutes(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Float{Value: time.Duration(i1).Minutes()}
+
+	return
+}
+
+func timesDurationNanoseconds(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: time.Duration(i1).Nanoseconds()}
+
+	return
+}
+
+func timesDurationSeconds(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Float{Value: time.Duration(i1).Seconds()}
+
+	return
+}
+
+func timesDurationString(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.String{Value: time.Duration(i1).String()}
+
+	return
+}
+
+func timesMonthString(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.String{Value: time.Month(i1).String()}
+
+	return
+}
+
+func timesDate(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 7 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+	i2, ok := tengo.ToInt(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+	i3, ok := tengo.ToInt(args[2])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+	i4, ok := tengo.ToInt(args[3])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+	i5, ok := tengo.ToInt(args[4])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "fifth",
+			Expected: "int(compatible)",
+			Found:    args[4].TypeName(),
+		}
+		return
+	}
+	i6, ok := tengo.ToInt(args[5])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "sixth",
+			Expected: "int(compatible)",
+			Found:    args[5].TypeName(),
+		}
+		return
+	}
+	i7, ok := tengo.ToInt(args[6])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "seventh",
+			Expected: "int(compatible)",
+			Found:    args[6].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{
+		Value: time.Date(i1,
+			time.Month(i2), i3, i4, i5, i6, i7, time.Now().Location()),
+	}
+
+	return
+}
+
+func timesNow(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 0 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	ret = &tengo.Time{Value: time.Now()}
+
+	return
+}
+
+func timesParse(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	s1, ok := tengo.ToString(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "string(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := tengo.ToString(args[1])
+	if !ok {
+		err = tengo.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 = &tengo.Time{Value: parsed}
+
+	return
+}
+
+func timesUnix(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	i1, ok := tengo.ToInt64(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "int(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := tengo.ToInt64(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{Value: time.Unix(i1, i2)}
+
+	return
+}
+
+func timesAdd(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := tengo.ToInt64(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{Value: t1.Add(time.Duration(i2))}
+
+	return
+}
+
+func timesSub(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := tengo.ToTime(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Sub(t2))}
+
+	return
+}
+
+func timesAddDate(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 4 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	i2, ok := tengo.ToInt(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "int(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	i3, ok := tengo.ToInt(args[2])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "third",
+			Expected: "int(compatible)",
+			Found:    args[2].TypeName(),
+		}
+		return
+	}
+
+	i4, ok := tengo.ToInt(args[3])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "fourth",
+			Expected: "int(compatible)",
+			Found:    args[3].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{Value: t1.AddDate(i2, i3, i4)}
+
+	return
+}
+
+func timesAfter(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := tengo.ToTime(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	if t1.After(t2) {
+		ret = tengo.TrueValue
+	} else {
+		ret = tengo.FalseValue
+	}
+
+	return
+}
+
+func timesBefore(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	t2, ok := tengo.ToTime(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	if t1.Before(t2) {
+		ret = tengo.TrueValue
+	} else {
+		ret = tengo.FalseValue
+	}
+
+	return
+}
+
+func timesTimeYear(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Year())}
+
+	return
+}
+
+func timesTimeMonth(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Month())}
+
+	return
+}
+
+func timesTimeDay(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Day())}
+
+	return
+}
+
+func timesTimeWeekday(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Weekday())}
+
+	return
+}
+
+func timesTimeHour(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Hour())}
+
+	return
+}
+
+func timesTimeMinute(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Minute())}
+
+	return
+}
+
+func timesTimeSecond(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Second())}
+
+	return
+}
+
+func timesTimeNanosecond(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: int64(t1.Nanosecond())}
+
+	return
+}
+
+func timesTimeUnix(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: t1.Unix()}
+
+	return
+}
+
+func timesTimeUnixNano(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Int{Value: t1.UnixNano()}
+
+	return
+}
+
+func timesTimeFormat(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 2 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	s2, ok := tengo.ToString(args[1])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "second",
+			Expected: "string(compatible)",
+			Found:    args[1].TypeName(),
+		}
+		return
+	}
+
+	s := t1.Format(s2)
+	if len(s) > tengo.MaxStringLen {
+
+		return nil, tengo.ErrStringLimit
+	}
+
+	ret = &tengo.String{Value: s}
+
+	return
+}
+
+func timesIsZero(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	if t1.IsZero() {
+		ret = tengo.TrueValue
+	} else {
+		ret = tengo.FalseValue
+	}
+
+	return
+}
+
+func timesToLocal(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{Value: t1.Local()}
+
+	return
+}
+
+func timesToUTC(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.Time{Value: t1.UTC()}
+
+	return
+}
+
+func timesTimeLocation(args ...tengo.Object) (
+	ret tengo.Object,
+	err error,
+) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.String{Value: t1.Location().String()}
+
+	return
+}
+
+func timesTimeString(args ...tengo.Object) (ret tengo.Object, err error) {
+	if len(args) != 1 {
+		err = tengo.ErrWrongNumArguments
+		return
+	}
+
+	t1, ok := tengo.ToTime(args[0])
+	if !ok {
+		err = tengo.ErrInvalidArgumentType{
+			Name:     "first",
+			Expected: "time(compatible)",
+			Found:    args[0].TypeName(),
+		}
+		return
+	}
+
+	ret = &tengo.String{Value: t1.String()}
+
+	return
+}