fix: fix failed unit test

* fix: 修改 README_zh-CN.md datetime 重复 IsLeapYear问题

* fix: 修改 README_zh-CN.md 18. slice 回到目录

* fix(validator): [IsChineseIdNum] fix 身份证效验 新增 省份、生日、效验码效验，修改ContainLower/IsNumber 注释错误

* fix(validator): [IsChineseIdNum] fix 修改测试

---------

Co-authored-by: dengjiaxiang <19181730103@189.cn>
Co-authored-by: dengrandpa <dengrandpapa@outlook.com>

.github/FUNDING.yml

@@ -0,0 +1,3 @@
+# These are supported funding model platforms
+liberapay: Duke_Du
+patreon: DukeDu

.gitignore

@@ -6,6 +6,10 @@ fileutil/*.txt
 fileutil/*.zip
 fileutil/*.link
 fileutil/unzip/*
+fileutil/tempdir/*
 slice/testdata/*
 cryptor/*.pem
-test
+test
+docs/node_modules
+docs/.vitepress/cache
+docs/.vitepress/dist

CONTRIBUTING.en-US.md

@@ -0,0 +1,37 @@
+# Lancet Contributing Guide
+
+Hi! Thank you for choosing Lancet.
+
+Lancet is a powerful, efficient, and reusable util function library of go. It makes Go dev easier by taking the hassle out of working with concurrency, net, math, slice, string, etc.
+
+We are excited that you are interested in contributing to lancet. Before submitting your contribution though, please make sure to take a moment and read through the following guidelines.
+
+## Issue Guidelines
+
+- Issues are exclusively for bug reports, feature requests and design-related topics. Other questions may be closed directly.
+
+- Before submitting an issue, please check if similar problems have already been issued.
+
+- Please specify which version of Lancet and Go you are using, and provide OS information. [Go Playground](https://go.dev/play/) is recommended to build a live demo so that your issue can be reproduced clearly.
+
+## Pull Request Guidelines
+
+- Fork this repository to your own account. Do not create branches here.
+
+- Commit info should be formatted as `type(scope): info about commit`. eg. `fix(package): [scrollbar] fix xxx bug`.
+
+  1. type: type must be one of [chore, docs, feat, fix, refactor, release, test].
+
+  2. scope: scope must be one of [package, file, internal].
+
+  3. header: header must not be longer than 72 characters.
+
+- Rebase before creating a PR to keep commit history clear.
+
+- Before submitting a PR, please execute the unit test command: `go test -v ./...` to ensure that all unit test tasks should pass.
+
+- Make sure PRs are created to `v2` branch instead of `master` branch.
+
+- If your PR fixes a bug, please provide a description about the related bug.
+
+- If the PR is for a new feature, make sure to complete the relevant documentation (/lancet/docs/en/api/packages).

CONTRIBUTING.zh-CN.md

@@ -0,0 +1,37 @@
+# Lancet 贡献指南
+
+Hi! 首先感谢你使用 Lancet。
+
+lancet（柳叶刀）是一个功能强大、全面、高效、可复用的go语言工具函数库。它消除了处理并发、网络、数学、切片、字符串等的麻烦，使 Go 开发变得更容易。
+
+Lancet 的成长离不开大家的支持，如果你愿意为 Lancet 贡献代码或提供建议，请阅读以下内容。
+
+## Issue 规范
+
+- issue 仅用于提交 Bug 或 Feature 以及设计相关的内容，其它内容可能会被直接关闭。
+
+- 在提交 issue 之前，请搜索相关内容是否已被提出。
+
+- 请说明 Lancet 和 Go 的版本号，并提供操作系统信息。推荐使用 [Go Playground](https://go.dev/play/) 生成在线 demo，这能够更直观地重现问题。
+
+## Pull Request 规范
+
+- 请先 fork 一份到自己的项目下，不要直接在仓库下建分支。
+
+- commit 信息要以 `type(scope): 描述信息` 的形式填写，例如 `fix(package): [scrollbar] fix xxx bug`。
+
+  1. type: 必须是 chore, docs, feat, fix, refactor, release, test 其中的一个。
+
+  2. scope: 必须是 package, file, internal 其中的一个。
+
+  3. header: 描述信息不要超过 72 个字符。
+
+- 提交 PR 前请 rebase，确保 commit 记录的整洁。
+
+- 提交 PR 前请执行单元测试命令：go test -v ./...，确保所有单元测试任务通过。
+
+- 确保 PR 是提交到 `v2` 分支，而不是 `main` 分支。
+
+- 如果是修复 bug，请在 PR 中给出描述信息。
+
+- 如果PR是新功能，确保完成相关文档(/lancet/docs/api/packages)。

compare/compare.go

@@ -10,6 +10,8 @@ import (
 	"time"
 
 	"github.com/duke-git/lancet/v2/convertor"
+	"github.com/duke-git/lancet/v2/mathutil"
+	"golang.org/x/exp/constraints"
 )
 
 // operator type
@@ -62,3 +64,9 @@ func LessOrEqual(left, right any) bool {
 func GreaterOrEqual(left, right any) bool {
 	return compareValue(greaterOrEqual, left, right)
 }
+
+// InDelta checks if two values are equal or not within a delta.
+// Play: https://go.dev/play/p/TuDdcNtMkjo
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool {
+	return float64(mathutil.Abs(left-right)) <= delta
+}

compare/compare_example_test.go

@@ -168,3 +168,29 @@ func ExampleGreaterOrEqual() {
 	// false
 	// false
 }
+
+func ExampleInDelta() {
+	result1 := InDelta(1, 1, 0)
+	result2 := InDelta(1, 2, 0)
+
+	result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+	result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+	result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+	result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+	fmt.Println(result5)
+	fmt.Println(result6)
+
+	// Output:
+	// true
+	// false
+	// true
+	// false
+	// false
+	// true
+}

compare/compare_internal.go

@@ -70,7 +70,7 @@ func compareRefValue(operator string, leftObj, rightObj any, kind reflect.Kind)
 
 			switch operator {
 			case equal:
-				if bytes.Compare(bytesObj1, bytesObj2) == 0 {
+				if bytes.Equal(bytesObj1, bytesObj2) {
 					return true
 				}
 			case lessThan:

compare/compare_test.go

@@ -138,3 +138,19 @@ func TestGreaterOrEqual(t *testing.T) {
 	assert.Equal(false, GreaterOrEqual(int64(2), 1))
 	assert.Equal(false, GreaterOrEqual("b", "c"))
 }
+
+func TestInDelta(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestInDelta")
+
+	assert.Equal(true, InDelta(1, 1, 0))
+	assert.Equal(false, InDelta(1, 2, 0))
+
+	assert.Equal(true, InDelta(2.0/3.0, 0.66667, 0.001))
+	assert.Equal(false, InDelta(2.0/3.0, 0.0, 0.001))
+
+	assert.Equal(false, InDelta(float64(74.96)-float64(20.48), 54.48, 0))
+	assert.Equal(true, InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14))
+	assert.Equal(false, InDelta(float64(float32(80.45)), float64(80.45), 0))
+	assert.Equal(true, InDelta(float64(float32(80.45)), float64(80.45), 1e-5))
+}

convertor/convertor_internal.go

@@ -99,7 +99,7 @@ func (c *cloner) cloneArray(v reflect.Value) reflect.Value {
 	for i := 0; i < v.Len(); i++ {
 		val := c.clone(v.Index(i))
 
-		if val.IsValid() {
+		if !val.IsValid() {
 			continue
 		}
 

convertor/convertor_test.go

@@ -337,6 +337,7 @@ func TestDeepClone(t *testing.T) {
 			Nil:   nil,
 			// unexported: "can't be cloned",
 		},
+		[]interface{}{1, &Struct{Str: "test"}, Struct{Str: "test2"}},
 	}
 
 	for i, item := range cases {

cryptor/basic.go

@@ -40,14 +40,30 @@ func Md5String(s string) string {
 	return hex.EncodeToString(h.Sum(nil))
 }
 
-// Md5String return the md5 string of byte slice.
-// Play: todo
+// Md5StringWithBase64 return the md5 value of string with base64.
+// Play: https://go.dev/play/p/Lx4gH7Vdr5_y
+func Md5StringWithBase64(s string) string {
+	h := md5.New()
+	h.Write([]byte(s))
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
+// Md5Byte return the md5 string of byte slice.
+// Play: https://go.dev/play/p/suraalH8lyC
 func Md5Byte(data []byte) string {
 	h := md5.New()
 	h.Write(data)
 	return hex.EncodeToString(h.Sum(nil))
 }
 
+// Md5ByteWithBase64 return the md5 string of byte slice with base64.
+// Play: https://go.dev/play/p/Tcb-Z7LN2ax
+func Md5ByteWithBase64(data []byte) string {
+	h := md5.New()
+	h.Write(data)
+	return base64.StdEncoding.EncodeToString(h.Sum(nil))
+}
+
 // Md5File return the md5 value of file.
 func Md5File(filename string) (string, error) {
 	if fileInfo, err := os.Stat(filename); err != nil {
@@ -82,56 +98,112 @@ func Md5File(filename string) (string, error) {
 
 // HmacMd5 return the hmac hash of string use md5.
 // Play: https://go.dev/play/p/uef0q1fz53I
-func HmacMd5(data, key string) string {
+func HmacMd5(str, key string) string {
+	h := hmac.New(md5.New, []byte(key))
+	h.Write([]byte(str))
+	return hex.EncodeToString(h.Sum([]byte("")))
+}
+
+// HmacMd5WithBase64 return the hmac hash of string use md5 with base64.
+// https://go.dev/play/p/UY0ng2AefFC
+func HmacMd5WithBase64(data, key string) string {
 	h := hmac.New(md5.New, []byte(key))
 	h.Write([]byte(data))
-	return hex.EncodeToString(h.Sum([]byte("")))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
 }
 
 // HmacSha1 return the hmac hash of string use sha1.
 // Play: https://go.dev/play/p/1UI4oQ4WXKM
-func HmacSha1(data, key string) string {
+func HmacSha1(str, key string) string {
 	h := hmac.New(sha1.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
+// HmacSha1WithBase64 return the hmac hash of string use sha1 with base64.
+// Play: https://go.dev/play/p/47JmmGrnF7B
+func HmacSha1WithBase64(str, key string) string {
+	h := hmac.New(sha1.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
 // HmacSha256 return the hmac hash of string use sha256.
 // Play: https://go.dev/play/p/HhpwXxFhhC0
-func HmacSha256(data, key string) string {
+func HmacSha256(str, key string) string {
 	h := hmac.New(sha256.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
+// HmacSha256WithBase64 return the hmac hash of string use sha256 with base64.
+// Play: https://go.dev/play/p/EKbkUvPTLwO
+func HmacSha256WithBase64(str, key string) string {
+	h := hmac.New(sha256.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
 // HmacSha512 return the hmac hash of string use sha512.
 // Play: https://go.dev/play/p/59Od6m4A0Ud
-func HmacSha512(data, key string) string {
+func HmacSha512(str, key string) string {
 	h := hmac.New(sha512.New, []byte(key))
-	h.Write([]byte(data))
+	h.Write([]byte(str))
 	return hex.EncodeToString(h.Sum([]byte("")))
 }
 
+// HmacSha512WithBase64 return the hmac hash of string use sha512 with base64.
+// Play: https://go.dev/play/p/c6dSe3E2ydU
+func HmacSha512WithBase64(str, key string) string {
+	h := hmac.New(sha512.New, []byte(key))
+	h.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(h.Sum([]byte("")))
+}
+
 // Sha1 return the sha1 value (SHA-1 hash algorithm) of string.
 // Play: https://go.dev/play/p/_m_uoD1deMT
-func Sha1(data string) string {
+func Sha1(str string) string {
 	sha1 := sha1.New()
-	sha1.Write([]byte(data))
+	sha1.Write([]byte(str))
 	return hex.EncodeToString(sha1.Sum([]byte("")))
 }
 
+// Sha1WithBase64 return the sha1 value (SHA-1 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/fSyx-Gl2l2-
+func Sha1WithBase64(str string) string {
+	sha1 := sha1.New()
+	sha1.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha1.Sum([]byte("")))
+}
+
 // Sha256 return the sha256 value (SHA256 hash algorithm) of string.
 // Play: https://go.dev/play/p/tU9tfBMIAr1
-func Sha256(data string) string {
+func Sha256(str string) string {
 	sha256 := sha256.New()
-	sha256.Write([]byte(data))
+	sha256.Write([]byte(str))
 	return hex.EncodeToString(sha256.Sum([]byte("")))
 }
 
+// Sha256WithBase64 return the sha256 value (SHA256 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/85IXJHIal1k
+func Sha256WithBase64(str string) string {
+	sha256 := sha256.New()
+	sha256.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha256.Sum([]byte("")))
+}
+
 // Sha512 return the sha512 value (SHA512 hash algorithm) of string.
 // Play: https://go.dev/play/p/3WsvLYZxsHa
-func Sha512(data string) string {
+func Sha512(str string) string {
 	sha512 := sha512.New()
-	sha512.Write([]byte(data))
+	sha512.Write([]byte(str))
 	return hex.EncodeToString(sha512.Sum([]byte("")))
 }
+
+// Sha512WithBase64 return the sha512 value (SHA512 hash algorithm) of base64 string.
+// Play: https://go.dev/play/p/q_fY2rA-k5I
+func Sha512WithBase64(str string) string {
+	sha512 := sha512.New()
+	sha512.Write([]byte(str))
+	return base64.StdEncoding.EncodeToString(sha512.Sum([]byte("")))
+}

cryptor/basic_test.go

@@ -27,6 +27,13 @@ func TestMd5String(t *testing.T) {
 	assert.Equal("5d41402abc4b2a76b9719d911017c592", Md5String("hello"))
 }
 
+func TestMd5StringWithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMd5StringWithBase64")
+	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5StringWithBase64("hello"))
+}
+
 func TestMd5Byte(t *testing.T) {
 	t.Parallel()
 
@@ -35,6 +42,13 @@ func TestMd5Byte(t *testing.T) {
 	assert.Equal("0cc175b9c0f1b6a831c399e269772661", Md5Byte(data))
 }
 
+func TestMd5ByteWithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestMd5ByteWithBase64")
+	assert.Equal("XUFAKrxLKna5cZ2REBfFkg==", Md5ByteWithBase64([]byte("hello")))
+}
+
 func TestMd5File(t *testing.T) {
 	t.Parallel()
 
@@ -51,6 +65,13 @@ func TestHmacMd5(t *testing.T) {
 	assert.Equal("5f4c9faaff0a1ad3007d9ddc06abe36d", HmacMd5("hello world", "12345"))
 }
 
+func TestHmacMd5WithBase64(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHmacMd5WithBase64")
+	assert.Equal("6DQwbquJLYclJdSRinpjmg==", HmacMd5WithBase64("hello", "12345"))
+}
+
 func TestHmacSha1(t *testing.T) {
 	t.Parallel()
 
@@ -63,18 +84,42 @@ func TestHmacSha1(t *testing.T) {
 	assert.Equal(expected, hmacSha1)
 }
 
+func TestHmacSha1WithBase64(t *testing.T) {
+	t.Parallel()
+
+	s := "hello"
+	key := "12345"
+	hmacSha1 := HmacSha1WithBase64(s, key)
+	expected := "XGqdsMzLkuNu0DI/0Jt/k23prOA="
+
+	assert := internal.NewAssert(t, "TestHmacSha1")
+	assert.Equal(expected, hmacSha1)
+}
+
 func TestHmacSha256(t *testing.T) {
 	t.Parallel()
 
-	s := "hello world"
+	str := "hello world"
 	key := "12345"
-	hmacSha256 := HmacSha256(s, key)
+	hmacSha256 := HmacSha256(str, key)
 	expected := "9dce2609f2d67d41f74c7f9efc8ccd44370d41ad2de52982627588dfe7289ab8"
 
 	assert := internal.NewAssert(t, "TestHmacSha256")
 	assert.Equal(expected, hmacSha256)
 }
 
+func TestHmacSha256WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := "hello"
+	key := "12345"
+	hms := HmacSha256WithBase64(str, key)
+	expected := "MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU="
+
+	assert := internal.NewAssert(t, "TestHmacSha256WithBase64")
+	assert.Equal(expected, hms)
+}
+
 func TestHmacSha512(t *testing.T) {
 	t.Parallel()
 
@@ -87,6 +132,18 @@ func TestHmacSha512(t *testing.T) {
 	assert.Equal(expected, hmacSha512)
 }
 
+func TestHmacSha512WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := "hello"
+	key := "12345"
+	hms := HmacSha512WithBase64(str, key)
+	expected := "3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A=="
+
+	assert := internal.NewAssert(t, "TestHmacSha512WithBase64")
+	assert.Equal(expected, hms)
+}
+
 func TestSha1(t *testing.T) {
 	t.Parallel()
 
@@ -98,6 +155,16 @@ func TestSha1(t *testing.T) {
 	assert.Equal(expected, sha1)
 }
 
+func TestSha1WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha1WithBase64("hello")
+	expected := "qvTGHdzF6KLavt4PO0gs2a6pQ00="
+
+	assert := internal.NewAssert(t, "TestSha1WithBase64")
+	assert.Equal(expected, str)
+}
+
 func TestSha256(t *testing.T) {
 	t.Parallel()
 
@@ -109,6 +176,16 @@ func TestSha256(t *testing.T) {
 	assert.Equal(expected, sha256)
 }
 
+func TestSha256WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha256WithBase64("hello")
+	expected := "LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ="
+
+	assert := internal.NewAssert(t, "TestSha256WithBase64")
+	assert.Equal(expected, str)
+}
+
 func TestSha512(t *testing.T) {
 	t.Parallel()
 
@@ -119,3 +196,13 @@ func TestSha512(t *testing.T) {
 	assert := internal.NewAssert(t, "TestSha512")
 	assert.Equal(expected, sha512)
 }
+
+func TestSha512WithBase64(t *testing.T) {
+	t.Parallel()
+
+	str := Sha512WithBase64("hello")
+	expected := "m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw=="
+
+	assert := internal.NewAssert(t, "TestSha512WithBase64")
+	assert.Equal(expected, str)
+}

cryptor/crypto.go

@@ -13,6 +13,7 @@ import (
 	"crypto/des"
 	"crypto/rand"
 	"crypto/rsa"
+	"crypto/sha256"
 	"crypto/x509"
 	"encoding/pem"
 	"io"
@@ -505,3 +506,32 @@ func RsaDecrypt(data []byte, privateKeyFileName string) []byte {
 	}
 	return plainText
 }
+
+// GenerateRsaKeyPair create rsa private and public key.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey) {
+	privateKey, _ := rsa.GenerateKey(rand.Reader, keySize)
+	return privateKey, &privateKey.PublicKey
+}
+
+// RsaEncryptOAEP encrypts the given data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error) {
+	encryptedBytes, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, &key, data, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return encryptedBytes, nil
+}
+
+// RsaDecryptOAEP decrypts the data with RSA-OAEP.
+// Play: https://go.dev/play/p/sSVmkfENKMz
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error) {
+	decryptedBytes, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, &key, ciphertext, label)
+	if err != nil {
+		return nil, err
+	}
+
+	return decryptedBytes, nil
+}

cryptor/crypto_example_test.go

@@ -1,6 +1,8 @@
 package cryptor
 
-import "fmt"
+import (
+	"fmt"
+)
 
 func ExampleAesEcbEncrypt() {
 	data := "hello"
@@ -322,49 +324,89 @@ func ExampleHmacMd5() {
 	key := "12345"
 
 	hms := HmacMd5(str, key)
-
 	fmt.Println(hms)
 
 	// Output:
 	// e834306eab892d872525d4918a7a639a
 }
 
+func ExampleHmacMd5WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacMd5WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 6DQwbquJLYclJdSRinpjmg==
+}
+
 func ExampleHmacSha1() {
 	str := "hello"
 	key := "12345"
 
 	hms := HmacSha1(str, key)
-
 	fmt.Println(hms)
 
 	// Output:
 	// 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
 }
 
+func ExampleHmacSha1WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha1WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+
 func ExampleHmacSha256() {
 	str := "hello"
 	key := "12345"
 
 	hms := HmacSha256(str, key)
-
 	fmt.Println(hms)
 
 	// Output:
 	// 315bb93c4e989862ba09cb62e05d73a5f376cb36f0d786edab0c320d059fde75
 }
 
+func ExampleHmacSha256WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha256WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+
 func ExampleHmacSha512() {
 	str := "hello"
 	key := "12345"
 
 	hms := HmacSha512(str, key)
-
 	fmt.Println(hms)
 
 	// Output:
 	// dd8f1290a9dd23d354e2526d9a2e9ce8cffffdd37cb320800d1c6c13d2efc363288376a196c5458daf53f8e1aa6b45a6d856303d5c0a2064bff9785861d48cfc
 }
 
+func ExampleHmacSha512WithBase64() {
+	str := "hello"
+	key := "12345"
+
+	hms := HmacSha512WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+
 func ExampleMd5String() {
 	md5Str := Md5String("hello")
 	fmt.Println(md5Str)
@@ -373,6 +415,14 @@ func ExampleMd5String() {
 	// 5d41402abc4b2a76b9719d911017c592
 }
 
+func ExampleMd5StringWithBase64() {
+	md5Str := Md5StringWithBase64("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+
 func ExampleMd5Byte() {
 	md5Str := Md5Byte([]byte{'a'})
 	fmt.Println(md5Str)
@@ -380,6 +430,15 @@ func ExampleMd5Byte() {
 	// Output:
 	// 0cc175b9c0f1b6a831c399e269772661
 }
+
+func ExampleMd5ByteWithBase64() {
+	md5Str := Md5ByteWithBase64([]byte("hello"))
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+
 func ExampleSha1() {
 	result := Sha1("hello")
 	fmt.Println(result)
@@ -388,6 +447,14 @@ func ExampleSha1() {
 	// aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
 }
 
+func ExampleSha1WithBase64() {
+	result := Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+
 func ExampleSha256() {
 	result := Sha256("hello")
 	fmt.Println(result)
@@ -396,6 +463,14 @@ func ExampleSha256() {
 	// 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
 }
 
+func ExampleSha256WithBase64() {
+	result := Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+
 func ExampleSha512() {
 	result := Sha512("hello")
 	fmt.Println(result)
@@ -403,3 +478,33 @@ func ExampleSha512() {
 	// Output:
 	// 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
 }
+
+func ExampleSha512WithBase64() {
+	result := Sha512WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}
+
+func ExampleRsaEncryptOAEP() {
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	if err != nil {
+		return
+	}
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+	if err != nil {
+		return
+	}
+
+	fmt.Println(string(decrypted))
+
+	// Output:
+	// hello world
+}

cryptor/crypto_test.go

@@ -150,3 +150,21 @@ func TestRsaEncrypt(t *testing.T) {
 	assert := internal.NewAssert(t, "TestRsaEncrypt")
 	assert.Equal(string(data), string(decrypted))
 }
+
+func TestRsaEncryptOAEP(t *testing.T) {
+	assert := internal.NewAssert(t, "TestRsaEncrypt")
+	t.Parallel()
+
+	pri, pub := GenerateRsaKeyPair(1024)
+
+	data := []byte("hello world")
+	label := []byte("123456")
+
+	encrypted, err := RsaEncryptOAEP(data, label, *pub)
+	assert.IsNil(err)
+
+	decrypted, err := RsaDecryptOAEP([]byte(encrypted), label, *pri)
+
+	assert.IsNil(err)
+	assert.Equal("hello world", string(decrypted))
+}

datastructure/hashmap/hashmap.go

@@ -7,6 +7,7 @@ package datastructure
 import (
 	"fmt"
 	"hash/fnv"
+	"reflect"
 )
 
 var defaultMapCapacity uint64 = 1 << 10
@@ -45,13 +46,24 @@ func NewHashMapWithCapacity(size, capacity uint64) *HashMap {
 func (hm *HashMap) Get(key any) any {
 	hashValue := hm.hash(key)
 	node := hm.table[hashValue]
-	if node != nil {
-		return node.value
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return node.value
+		}
+		node = node.next
 	}
-
 	return nil
 }
 
+// GetOrDefault return the value of given key in hashmap, if not found return default value
+func (hm *HashMap) GetOrDefault(key any, defaultValue any) any {
+	value := hm.Get(key)
+	if value == nil {
+		return defaultValue
+	}
+	return value
+}
+
 // Put new key value in hashmap
 func (hm *HashMap) Put(key any, value any) {
 	hm.putValue(hm.hash(key), key, value)
@@ -90,7 +102,13 @@ func (hm *HashMap) Delete(key any) {
 // Contains checks if given key is in hashmap or not
 func (hm *HashMap) Contains(key any) bool {
 	node := hm.table[hm.hash(key)]
-	return node != nil
+	for node != nil {
+		if reflect.DeepEqual(node.key, key) {
+			return true
+		}
+		node = node.next
+	}
+	return false
 }
 
 // Iterate executes iteratee funcation for every key and value pair of hashmap (random order)

datastructure/hashmap/hashmap_test.go

@@ -74,3 +74,34 @@ func TestHashMap_KeysValues(t *testing.T) {
 	assert.Equal(3, len(values))
 	assert.Equal(3, len(keys))
 }
+
+func TestHashMap_Keys(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_Keys")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	keys := hm.Keys()
+
+	assert.Equal(3, len(keys))
+}
+
+func TestHashMap_GetOrDefault(t *testing.T) {
+	t.Parallel()
+
+	assert := internal.NewAssert(t, "TestHashMap_GetOrDefault")
+
+	hm := NewHashMap()
+
+	hm.Put("a", 1)
+	hm.Put("b", 2)
+	hm.Put("c", 3)
+
+	assert.Equal(1, hm.GetOrDefault("a", 5))
+	assert.Equal(5, hm.GetOrDefault("d", 5))
+}

datastructure/list/copyonwritelist.go

@@ -0,0 +1,350 @@
+package datastructure
+
+import (
+	"reflect"
+	"sort"
+	"sync"
+)
+
+type CopyOnWriteList[T any] struct {
+	data []T
+	lock sync.Locker
+}
+
+// NewCopyOnWriteList Creates an empty list.
+func NewCopyOnWriteList[T any](data []T) *CopyOnWriteList[T] {
+	return &CopyOnWriteList[T]{data: data, lock: &sync.RWMutex{}}
+}
+
+func (c *CopyOnWriteList[T]) getList() []T {
+	return c.data
+}
+func (c *CopyOnWriteList[T]) setList(data []T) {
+	c.data = data
+}
+
+// Size returns the number of elements in this list.
+func (c *CopyOnWriteList[T]) Size() int {
+	return len(c.getList())
+}
+
+// IsEmpty returns true if this list contains no elements.
+func (c *CopyOnWriteList[T]) IsEmpty() bool {
+	return c.Size() == 0
+}
+
+// Contain returns true if this list contains the specified element.
+func (c *CopyOnWriteList[T]) Contain(e T) bool {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size()) >= 0
+}
+
+// ValueOf returns the index of the first occurrence of the specified element in this list, or null if this list does not contain the element.
+func (c *CopyOnWriteList[T]) ValueOf(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(c.data) {
+		return nil, false
+	}
+	return get(list, index), true
+}
+
+// IndexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) IndexOf(e T) int {
+	list := c.getList()
+	return indexOf(e, list, 0, c.Size())
+}
+
+// indexOf returns the index of the first occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func indexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := start; i < end; i++ {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// LastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int {
+	list := c.getList()
+	return lastIndexOf(e, list, 0, c.Size())
+}
+
+// lastIndexOf returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain the element.
+// start the start position of the search (inclusive)
+// end the end position of the search (exclusive)
+func lastIndexOf[T any](o T, e []T, start int, end int) int {
+	if start >= end {
+		return -1
+	}
+	for i := end - 1; i >= start; i-- {
+		if reflect.DeepEqual(e[i], o) {
+			return i
+		}
+	}
+	return -1
+}
+
+// get returns the element at the specified position in this list.
+func get[T any](o []T, index int) *T {
+	return &o[index]
+}
+
+// Get returns the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) Get(index int) *T {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil
+	}
+	return get(list, index)
+}
+
+func (c *CopyOnWriteList[T]) set(index int, e T) (oldValue *T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+	list := c.getList()
+	oldValue = get(list, index)
+
+	if reflect.DeepEqual(oldValue, e) {
+		c.setList(list)
+	} else {
+		newList := make([]T, len(list))
+		copy(newList, list)
+		newList[index] = e
+		c.setList(newList)
+	}
+	return
+}
+
+// Set replaces the element at the specified position in this list with the specified element.
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return oldValue, false
+	}
+	return c.set(index, e), true
+}
+
+// Add appends the specified element to the end of this list.
+func (c *CopyOnWriteList[T]) Add(e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+1)
+	copy(newList, list)
+	newList[len(list)] = e
+	c.setList(newList)
+	return true
+}
+
+// AddAll appends all the elements in the specified collection to the end of this list
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	newList := make([]T, len(list)+len(e))
+	copy(newList, list)
+	copy(newList[len(list):], e)
+	c.setList(newList)
+	return true
+}
+
+// AddByIndex inserts the specified element at the specified position in this list.
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if index < 0 || index > length {
+		return false
+	}
+	var newList []T
+	var numMove = length - index
+	if numMove == 0 {
+		newList = make([]T, length+1)
+		copy(newList, list)
+	} else {
+		newList = make([]T, length+1)
+		copy(newList, list[:index])
+		copy(newList[index+1:], list[index:])
+	}
+	newList[index] = e
+	c.setList(newList)
+	return true
+}
+
+// delete removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) delete(index int) *T {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+
+	oldValue := get(list, index)
+	numMove := length - index - 1
+	var newList []T
+	if numMove == 0 {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+	} else {
+		newList = make([]T, length-1)
+		copy(newList, list[:index])
+		copy(newList[index:], list[index+1:])
+	}
+
+	c.setList(newList)
+	return oldValue
+}
+
+// DeleteAt removes the element at the specified position in this list.
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (*T, bool) {
+	list := c.getList()
+	if index < 0 || index >= len(list) {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteBy removes the first occurrence of the specified element from this list, if it is present.
+func (c *CopyOnWriteList[T]) DeleteBy(o T) (*T, bool) {
+	list := c.getList()
+	index := indexOf(o, list, 0, len(list))
+	if index == -1 {
+		return nil, false
+	}
+	return c.delete(index), true
+}
+
+// DeleteRange removes from this list all the elements whose index is between fromIndex, inclusive, and toIndex, exclusive.
+// left close and right open
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	if start < 0 || end > length || start > end {
+		return
+	}
+	var newList []T
+	numMove := length - end
+	if numMove == 0 {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+	} else {
+		newList = make([]T, length-(end-start))
+		copy(newList, list[:start])
+		copy(newList[start:], list[end:])
+	}
+	c.setList(newList)
+}
+
+// DeleteIf removes all the elements of this collection that satisfy the given predicate.
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	length := len(list)
+	var newList []T
+	for i := 0; i < length; i++ {
+		if !f(list[i]) {
+			newList = append(newList, list[i])
+		}
+	}
+	c.setList(newList)
+}
+
+// Equal returns true if the specified object is equal to this list.
+func (c *CopyOnWriteList[T]) Equal(other *[]T) bool {
+	if other == nil {
+		return false
+	}
+	if c.Size() != len(*other) {
+		return false
+	}
+	list := c.getList()
+	otherList := NewCopyOnWriteList(*other).getList()
+	for i := 0; i < len(list); i++ {
+		if !reflect.DeepEqual(list[i], otherList[i]) {
+			return false
+		}
+	}
+	return true
+}
+
+// Clear removes all the elements from this list.
+func (c *CopyOnWriteList[T]) Clear() {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = make([]T, 0)
+	c.setList(list)
+}
+
+// Merge a tow list to one, change the list
+func (c *CopyOnWriteList[T]) Merge(other []T) {
+	lock := c.lock
+	lock.Lock()
+	defer lock.Unlock()
+
+	list := c.getList()
+	list = append(list, other...)
+	c.setList(list)
+}
+
+// ForEach performs the given action for each element of the Iterable until all elements have been processed
+// or the action throws an exception.
+func (c *CopyOnWriteList[T]) ForEach(f func(T)) {
+	list := c.getList()
+	for i := 0; i < len(list); i++ {
+		f(list[i])
+	}
+
+}
+
+// Sort sorts this list according to the order induced by the specified Comparator.
+func (c *CopyOnWriteList[T]) Sort(compare func(o1 T, o2 T) bool) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+
+	sort.Slice(list, func(i, j int) bool {
+		return compare(list[i], list[j])
+	})
+
+	c.setList(list)
+}
+
+func (c *CopyOnWriteList[T]) SubList(start int, end int) (newList []T) {
+	lock := c.lock
+	lock.Lock()
+	list := c.getList()
+	length := len(list)
+	defer lock.Unlock()
+	if start < 0 || end > length || start > end {
+		return []T{}
+	}
+	newList = make([]T, end-start)
+	copy(newList, list[start:end])
+	c.setList(newList)
+	return
+}

datastructure/list/copyonwritelist_test.go

@@ -0,0 +1,235 @@
+package datastructure
+
+import (
+	"github.com/duke-git/lancet/v2/internal"
+	"testing"
+)
+
+func TestCopyOnWriteList_ValueOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+	of, ok := list.ValueOf(3)
+	assert.Equal(4, *of)
+	assert.Equal(true, ok)
+
+	_, ok = list.ValueOf(6)
+	assert.Equal(false, ok)
+}
+
+func TestCopyOnWriteList_Contain(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Contains")
+	assert.Equal(true, list.Contain(3))
+}
+
+func TestCopyOnWriteList_IsEmpty(t *testing.T) {
+	list := NewCopyOnWriteList([]int{})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IsEmpty")
+	assert.Equal(true, list.IsEmpty())
+}
+
+func TestCopyOnWriteList_Size(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_size")
+	assert.Equal(5, list.Size())
+}
+
+func TestCopyOnWriteList_GetList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_GetList")
+	assert.Equal([]int{1, 2, 3, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_Get(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Get")
+	i := list.Get(2)
+	assert.Equal(3, *i)
+}
+
+func TestCopyOnWriteList_Set(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Set")
+	list.Set(2, 6)
+	assert.Equal(6, list.getList()[2])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 6)
+	assert.Equal(6, list.getList()[0])
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.Set(0, 1)
+	assert.Equal(1, list.getList()[0])
+}
+
+func TestCopyOnWriteList_Add(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Add")
+	list.Add(6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_AddAll(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddAll")
+	list.AddAll([]int{6, 7, 8})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8}, list.getList())
+}
+
+func TestCopyOnWriteList_AddByIndex(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_AddByIndex")
+	list.AddByIndex(2, 6)
+	assert.Equal([]int{1, 2, 6, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(0, 6)
+	assert.Equal([]int{6, 1, 2, 3, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.AddByIndex(5, 6)
+	assert.Equal([]int{1, 2, 3, 4, 5, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteAt2(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByIndex")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteAt(4)
+	assert.Equal([]int{1, 2, 3, 4}, list.getList())
+}
+
+func TestCopyOnWriteList_RemoveByValue(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveByValue")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteRange(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	assert := internal.NewAssert(t, "CopyOnWriteList_RemoveRange")
+	list.DeleteRange(1, 3)
+	assert.Equal([]int{1, 4, 5}, list.getList())
+
+	list = NewCopyOnWriteList([]int{1, 2, 3, 4, 5})
+	list.DeleteRange(0, 5)
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_LastIndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_LastIndexOf")
+	assert.Equal(5, list.LastIndexOf(3))
+}
+
+func TestCopyOnWriteList_DeleteAt(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteAt")
+	list.DeleteAt(2)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteBy(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteBy")
+	list.DeleteBy(3)
+	assert.Equal([]int{1, 2, 4, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_DeleteIf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_DeleteIf")
+
+	list.DeleteIf(func(i int) bool {
+		return i%2 == 0
+	})
+
+	assert.Equal([]int{1, 3, 5, 3}, list.getList())
+}
+
+func TestCopyOnWriteList_Equal(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Equal")
+
+	assert.Equal(true, list.Equal(&[]int{1, 2, 3, 4, 5, 3, 6}))
+}
+
+func TestCopyOnWriteList_ForEach(t *testing.T) {
+	testList := make([]int, 0)
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_ForEach")
+
+	list.ForEach(func(i int) {
+		testList = append(testList, i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6}, testList)
+
+	list.ForEach(func(i int) {
+		list.Add(i)
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 3, 6, 1, 2, 3, 4, 5, 3, 6}, list.getList())
+}
+
+func TestCopyOnWriteList_Clear(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 2, 3, 4, 5, 3, 6})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Clear")
+
+	list.Clear()
+	assert.Equal([]int{}, list.getList())
+}
+
+func TestCopyOnWriteList_Merge(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Merge")
+
+	list.Merge([]int{2, 4, 6, 8, 10})
+	assert.Equal([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10}, list.getList())
+
+}
+
+func TestCopyOnWriteList_Sort(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_Sort")
+
+	list.Sort(func(i, j int) bool {
+		return i < j
+	})
+	assert.Equal([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, list.getList())
+}
+
+func TestCopyOnWriteList_IndexOf(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert := internal.NewAssert(t, "CopyOnWriteList_IndexOf")
+
+	assert.Equal(0, list.IndexOf(1))
+	assert.Equal(9, list.IndexOf(10))
+	assert.Equal(-1, list.IndexOf(11))
+}
+
+func TestCopyOnWriteList_SubList(t *testing.T) {
+	list := NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+
+	assert := internal.NewAssert(t, "CopyOnWriteList_SubList")
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList := list.SubList(1, 3)
+	assert.Equal([]int{3, 5}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(1, 1)
+	assert.Equal([]int{}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	assert.Equal(10, list.Size())
+	subList = list.SubList(1, 10)
+	assert.Equal([]int{3, 5, 7, 9, 2, 4, 6, 8, 10}, subList)
+
+	list = NewCopyOnWriteList([]int{1, 3, 5, 7, 9, 2, 4, 6, 8, 10})
+	subList = list.SubList(11, 1)
+	assert.Equal([]int{}, subList)
+}

datastructure/list/list.go

@@ -271,7 +271,7 @@ func (l *List[T]) Reverse() {
 	}
 }
 
-// Unique remove duplicate items in list.
+// Unique delete duplicate items in list.
 func (l *List[T]) Unique() {
 	data := l.data
 	size := len(data)
@@ -294,7 +294,7 @@ func (l *List[T]) Unique() {
 	l.data = uniqueData
 }
 
-// Union creates a new list contain all element in list l and other, remove duplicate element.
+// Union creates a new list contain all element in list l and other, delete duplicate element.
 func (l *List[T]) Union(other *List[T]) *List[T] {
 	result := NewList([]T{})
 

datastructure/queue/arrayqueue.go

@@ -12,7 +12,7 @@ import (
 
 // ArrayQueue implements queue with slice
 type ArrayQueue[T any] struct {
-	items    []T
+	data     []T
 	head     int
 	tail     int
 	capacity int
@@ -21,7 +21,7 @@ type ArrayQueue[T any] struct {
 
 func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 	return &ArrayQueue[T]{
-		items:    make([]T, 0, capacity),
+		data:     make([]T, 0, capacity),
 		head:     0,
 		tail:     0,
 		capacity: capacity,
@@ -33,7 +33,7 @@ func NewArrayQueue[T any](capacity int) *ArrayQueue[T] {
 func (q *ArrayQueue[T]) Data() []T {
 	items := []T{}
 	for i := q.head; i < q.tail; i++ {
-		items = append(items, q.items[i])
+		items = append(items, q.data[i])
 	}
 	return items
 }
@@ -55,40 +55,71 @@ func (q *ArrayQueue[T]) IsFull() bool {
 
 // Front return front value of queue
 func (q *ArrayQueue[T]) Front() T {
-	return q.items[0]
+	return q.data[0]
 }
 
 // Back return back value of queue
 func (q *ArrayQueue[T]) Back() T {
-	return q.items[q.size-1]
+	return q.data[q.size-1]
 }
 
 // EnQueue put element into queue
 func (q *ArrayQueue[T]) Enqueue(item T) bool {
-	if q.head == 0 && q.tail == q.capacity {
-		return false
-	} else if q.head != 0 && q.tail == q.capacity {
-		for i := q.head; i < q.tail; i++ {
-			q.items[i-q.head] = q.items[i]
+	if q.tail < q.capacity {
+		q.data = append(q.data, item)
+		// q.tail++
+		q.data[q.tail] = item
+	} else {
+		//upgrade
+		if q.head > 0 {
+			for i := 0; i < q.tail-q.head; i++ {
+				q.data[i] = q.data[i+q.head]
+			}
+			q.tail -= q.head
+			q.head = 0
+		} else {
+			if q.capacity < 65536 {
+				if q.capacity == 0 {
+					q.capacity = 1
+				}
+				q.capacity *= 2
+			} else {
+				q.capacity += 2 ^ 16
+			}
+
+			tmp := make([]T, q.capacity, q.capacity)
+			copy(tmp, q.data)
+			q.data = tmp
 		}
-		q.tail = q.tail - q.head
-		q.head = 0
+
+		q.data[q.tail] = item
 	}
 
-	q.items = append(q.items, item)
 	q.tail++
 	q.size++
+
 	return true
 }
 
 // DeQueue remove head element of queue and return it, if queue is empty, return nil and error
 func (q *ArrayQueue[T]) Dequeue() (T, bool) {
 	var item T
-	if q.head == q.tail {
+	if q.size == 0 {
 		return item, false
 	}
-	item = q.items[q.head]
+
+	item = q.data[q.head]
 	q.head++
+
+	if q.head >= 1024 || q.head*2 > q.tail {
+		q.capacity -= q.head
+		q.tail -= q.head
+		tmp := make([]T, q.capacity, q.capacity)
+		copy(tmp, q.data[q.head:])
+		q.data = tmp
+		q.head = 0
+	}
+
 	q.size--
 	return item, true
 }
@@ -96,7 +127,7 @@ func (q *ArrayQueue[T]) Dequeue() (T, bool) {
 // Clear the queue data
 func (q *ArrayQueue[T]) Clear() {
 	capacity := q.capacity
-	q.items = make([]T, 0, capacity)
+	q.data = make([]T, 0, capacity)
 	q.head = 0
 	q.tail = 0
 	q.size = 0
@@ -105,7 +136,7 @@ func (q *ArrayQueue[T]) Clear() {
 
 // Contain checks if the value is in queue or not
 func (q *ArrayQueue[T]) Contain(value T) bool {
-	for _, v := range q.items {
+	for _, v := range q.data {
 		if reflect.DeepEqual(v, value) {
 			return true
 		}
@@ -117,7 +148,7 @@ func (q *ArrayQueue[T]) Contain(value T) bool {
 func (q *ArrayQueue[T]) Print() {
 	info := "["
 	for i := q.head; i < q.tail; i++ {
-		info += fmt.Sprintf("%+v, ", q.items[i])
+		info += fmt.Sprintf("%+v, ", q.data[i])
 	}
 	info += "]"
 	fmt.Println(info)

datastructure/queue/arrayqueue_test.go

@@ -11,7 +11,7 @@ func TestArrayQueue_Enqueue(t *testing.T) {
 
 	assert := internal.NewAssert(t, "TestArrayQueue_Enqueue")
 
-	queue := NewArrayQueue[int](5)
+	queue := NewArrayQueue[int](2)
 	queue.Enqueue(1)
 	queue.Enqueue(2)
 	queue.Enqueue(3)

datetime/datetime.go

@@ -3,7 +3,7 @@
 
 // Package datetime implements some functions to format date and time.
 // Note:
-// 1. `format` param in FormatTimeToStr function should be as flow:
+// 1. `format` param in FormatTimeToStr function should be as flow (case no sensitive):
 // "yyyy-mm-dd hh:mm:ss"
 // "yyyy-mm-dd hh:mm"
 // "yyyy-mm-dd hh"
@@ -18,14 +18,19 @@
 // "yyyy/mm"
 // "mm/dd"
 // "dd/mm/yy hh:mm:ss"
+// "yyyymmdd"
+// "mmddyy"
 // "yyyy"
+// "yy"
 // "mm"
 // "hh:mm:ss"
+// "hh:mm"
 // "mm:ss"
 package datetime
 
 import (
 	"fmt"
+	"strings"
 	"time"
 )
 
@@ -47,9 +52,13 @@ func init() {
 		"yyyy/mm":             "2006/01",
 		"mm/dd":               "01/02",
 		"dd/mm/yy hh:mm:ss":   "02/01/06 15:04:05",
+		"yyyymmdd":            "20060102",
+		"mmddyy":              "010206",
 		"yyyy":                "2006",
+		"yy":                  "06",
 		"mm":                  "01",
 		"hh:mm:ss":            "15:04:05",
+		"hh:mm":               "15:04",
 		"mm:ss":               "04:05",
 	}
 }
@@ -97,13 +106,13 @@ func GetNowDateTime() string {
 }
 
 // GetTodayStartTime return the start time of today, format: yyyy-mm-dd 00:00:00.
-// Play: todo
+// Play: https://go.dev/play/p/84siyYF7t99
 func GetTodayStartTime() string {
 	return time.Now().Format("2006-01-02") + " 00:00:00"
 }
 
 // GetTodayEndTime return the end time of today, format: yyyy-mm-dd 23:59:59.
-// Play: todo
+// Play: https://go.dev/play/p/jjrLnfoqgn3
 func GetTodayEndTime() string {
 	return time.Now().Format("2006-01-02") + " 23:59:59"
 }
@@ -124,19 +133,40 @@ func GetNightTimestamp() int64 {
 
 // FormatTimeToStr convert time to string.
 // Play: https://go.dev/play/p/_Ia7M8H_OvE
-func FormatTimeToStr(t time.Time, format string) string {
-	return t.Format(timeFormat[format])
+func FormatTimeToStr(t time.Time, format string, timezone ...string) string {
+	tf, ok := timeFormat[strings.ToLower(format)]
+	if !ok {
+		return ""
+	}
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return ""
+		}
+		return t.In(loc).Format(tf)
+	}
+	return t.Format(tf)
 }
 
 // FormatStrToTime convert string to time.
 // Play: https://go.dev/play/p/1h9FwdU8ql4
-func FormatStrToTime(str, format string) (time.Time, error) {
-	v, ok := timeFormat[format]
+func FormatStrToTime(str, format string, timezone ...string) (time.Time, error) {
+	tf, ok := timeFormat[strings.ToLower(format)]
 	if !ok {
-		return time.Time{}, fmt.Errorf("format %s not found", format)
+		return time.Time{}, fmt.Errorf("format %s not support", format)
 	}
 
-	return time.Parse(v, str)
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return time.Time{}, err
+		}
+
+		return time.ParseInLocation(tf, str, loc)
+	}
+
+	return time.Parse(tf, str)
 }
 
 // BeginOfMinute return beginning minute time of day.
@@ -262,6 +292,92 @@ func DayOfYear(t time.Time) int {
 
 // IsWeekend checks if passed time is weekend or not.
 // Play: https://go.dev/play/p/cupRM5aZOIY
+// Deprecated Use '== Weekday' instead
 func IsWeekend(t time.Time) bool {
 	return time.Saturday == t.Weekday() || time.Sunday == t.Weekday()
 }
+
+// NowDateOrTime return current datetime with specific format and timezone.
+// Play: https://go.dev/play/p/EZ-begEjtT0
+func NowDateOrTime(format string, timezone ...string) string {
+	tf, ok := timeFormat[strings.ToLower(format)]
+	if !ok {
+		return ""
+	}
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return ""
+		}
+
+		return time.Now().In(loc).Format(tf)
+	}
+
+	return time.Now().Format(tf)
+}
+
+// Timestamp return current second timestamp.
+// Play: https://go.dev/play/p/iU5b7Vvjx6x
+func Timestamp(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+
+		t = t.In(loc)
+	}
+
+	return t.Unix()
+}
+
+// TimestampMilli return current mill second timestamp.
+// Play: https://go.dev/play/p/4gvEusOTu1T
+func TimestampMilli(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return int64(time.Nanosecond) * t.UnixNano() / int64(time.Millisecond)
+}
+
+// TimestampMicro return current micro second timestamp.
+// Play: https://go.dev/play/p/2maANglKHQE
+func TimestampMicro(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return int64(time.Nanosecond) * t.UnixNano() / int64(time.Microsecond)
+}
+
+// TimestampNano return current nano second timestamp.
+// Play: https://go.dev/play/p/A9Oq_COrcCF
+func TimestampNano(timezone ...string) int64 {
+	t := time.Now()
+
+	if timezone != nil && timezone[0] != "" {
+		loc, err := time.LoadLocation(timezone[0])
+		if err != nil {
+			return 0
+		}
+		t = t.In(loc)
+	}
+
+	return t.UnixNano()
+}

datetime/datetime_test.go

@@ -147,6 +147,9 @@ func TestFormatTimeToStr(t *testing.T) {
 		actual := FormatTimeToStr(datetime, cases[i])
 		assert.Equal(expected[i], actual)
 	}
+
+	ds := FormatTimeToStr(datetime, "yyyy-mm-dd hh:mm:ss", "EST")
+	t.Log(ds)
 }
 
 func TestFormatStrToTime(t *testing.T) {
@@ -163,19 +166,23 @@ func TestFormatStrToTime(t *testing.T) {
 		"dd-mm-yy hh:mm:ss", "yyyy/mm/dd hh:mm:ss",
 		"yyyy/mm"}
 
-	datetimeStr := []string{
+	expected := []string{
 		"2021-01-02 16:04:08", "2021-01-02",
 		"02-01-21 16:04:08", "2021/01/02 16:04:08",
 		"2021/01"}
 
 	for i := 0; i < len(cases); i++ {
-		actual, err := FormatStrToTime(datetimeStr[i], cases[i])
+		actual, err := FormatStrToTime(expected[i], cases[i])
 		if err != nil {
 			t.Fatal(err)
 		}
-		expected, _ := time.Parse(formats[i], datetimeStr[i])
+		expected, _ := time.Parse(formats[i], expected[i])
 		assert.Equal(expected, actual)
 	}
+
+	estTime, err := FormatStrToTime("2021-01-02 16:04:08", "yyyy-mm-dd hh:mm:ss", "EST")
+	t.Log(estTime)
+	assert.IsNil(err)
 }
 
 func TestBeginOfMinute(t *testing.T) {
@@ -368,3 +375,38 @@ func TestIsWeekend(t *testing.T) {
 	result2 := IsWeekend(date2)
 	assert.Equal(false, result2)
 }
+
+func TestNowDateOrTime(t *testing.T) {
+	t.Parallel()
+
+	formats := []string{
+		"yyyy-mm-dd hh:mm:ss",
+		"yyyy-mm-dd",
+		"dd-mm-yy hh:mm:ss",
+		"yyyy/mm/dd hh:mm:ss",
+		"hh:mm:ss",
+		"yyyy/mm",
+		"yyyy-mm-dd hh",
+	}
+
+	for i := 0; i < len(formats); i++ {
+		result := NowDateOrTime(formats[i], "UTC")
+		t.Log(result)
+	}
+}
+
+func TestTimestamp(t *testing.T) {
+	t.Parallel()
+
+	ts1 := Timestamp()
+	t.Log(ts1)
+
+	ts2 := TimestampMilli()
+	t.Log(ts2)
+
+	ts3 := TimestampMicro()
+	t.Log(ts3)
+
+	ts4 := TimestampNano()
+	t.Log(ts4)
+}

docs/.vitepress/common.ts

@@ -0,0 +1,89 @@
+import { defineConfig, HeadConfig } from 'vitepress'
+
+export const META_IMAGE = '/lancet_logo.png'
+export const isProduction = process.env.NETLIFY && process.env.CONTEXT === 'production'
+
+if (process.env.NETLIFY) {
+    console.log('Netlify build', process.env.CONTEXT)
+}
+
+const productionHead: HeadConfig[] = [
+    [
+        'script',
+        {
+            src: 'https://unpkg.com/thesemetrics@latest',
+            async: '',
+            type: 'text/javascript',
+        },
+    ],
+]
+
+const rControl = /[\u0000-\u001f]/g
+const rSpecial = /[\s~`!@#$%^&*()\-_+=[\]{}|\\;:"'“”‘’<>,.?/]+/g
+const rCombining = /[\u0300-\u036F]/g
+
+/**
+ * Default slugification function
+ */
+export const slugify = (str: string): string =>
+    str
+        .normalize('NFKD')
+        // Remove accents
+        .replace(rCombining, '')
+        // Remove control characters
+        .replace(rControl, '')
+        // Replace special characters
+        .replace(rSpecial, '-')
+        // ensure it doesn't start with a number
+        .replace(/^(\d)/, '_$1')
+
+export const commonConfig = defineConfig({
+    title: 'Lancet',
+    appearance: true,
+
+    markdown: {
+        theme: {
+            dark: 'dracula-soft',
+            light: 'vitesse-light',
+        },
+
+        attrs: {
+            leftDelimiter: '%{',
+            rightDelimiter: '}%',
+        },
+
+        anchor: {
+            slugify,
+        },
+    },
+
+    head: [
+        // ['link', { rel: 'icon', type: 'image/svg+xml', href: '/logo.svg' }],
+        ['link', { rel: 'icon', type: 'image/png', href: '/lancet_logo_mini.png' }],
+        ['meta', { name: 'theme-color', content: '#5f67ee' }],
+        ['meta', { name: 'og:type', content: 'website' }],
+        ['meta', { name: 'og:locale', content: 'zh' }],
+
+        ...(isProduction ? productionHead : []),
+    ],
+
+    themeConfig: {
+        logo: { src: '/lancet_logo_mini.png', width: 24, height: 24 },
+        outline: [2, 3],
+
+        search: {
+            provider: 'local',
+        },
+        socialLinks: [
+            {
+                icon: 'github',
+                link: 'https://github.com/duke-git/lancet',
+            },
+        ],
+
+        footer: {
+            copyright: 'Copyright © 2023-present Duke Du',
+            message: '备案号: 京ICP备2023022770号',
+        },
+    },
+})

docs/.vitepress/config.mts

@@ -0,0 +1,14 @@
+import { defineConfig } from 'vitepress'
+import { commonConfig } from './common'
+import { zhConfig } from './zh'
+import { enConfig } from './en'
+
+// https://vitepress.dev/reference/site-config
+export default defineConfig({
+    ...commonConfig,
+
+    locales: {
+        root: { label: '简体中文', lang: 'zh-CN', link: '/', ...zhConfig },
+        en: { label: 'English', lang: 'en-US', link: '/en/', ...enConfig },
+    },
+})

docs/.vitepress/en.ts

@@ -0,0 +1,139 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn/en/'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = 'A powerful util function library of Go'
+
+export const enConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: 'Suggest changes to this page',
+        },
+        nav: [
+            {
+                text: 'Home',
+                link: '/en/',
+                activeMatch: '^/en/',
+            },
+            {
+                text: 'Guide',
+                link: '/en/guide/introduction',
+                activeMatch: '^/en/guide/',
+            },
+            { text: 'API', link: '/en/api/overview', activeMatch: '^/en/api/' },
+            {
+                text: 'Links',
+                items: [
+                    {
+                        text: 'Discussion',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: 'Changelog',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: 'Contribution',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTING.en-US.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/en/guide/': [
+                {
+                    text: 'Introduction',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'What is Lancet？',
+                            link: '/en/guide/introduction',
+                        },
+                        {
+                            text: 'Getting started',
+                            link: '/en/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: 'Contribute Code',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Contribution guide',
+                            link: '/en/guide/contribution_guide',
+                        },
+                        {
+                            text: 'Contributors',
+                            link: '/en/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API Reference',
+                    link: '/en/api/overview'
+                },
+            ],
+            '/en/api/': [
+                {
+                    text: 'Overview',
+                    items: [{ text: 'API overview', link: '/en/api/overview' }],
+                },
+                {
+                    text: 'Packages',
+                    collapsed: false,
+                    items: [
+                        { text: 'algorithm', link: '/en/api/packages/algorithm' },
+                        { text: 'compare', link: '/en/api/packages/compare' },
+                        { text: 'concurrency', link: '/en/api/packages/concurrency' },
+                        { text: 'condition', link: '/en/api/packages/condition' },
+                        { text: 'convertor', link: '/en/api/packages/convertor' },
+                        { text: 'cryptor', link: '/en/api/packages/cryptor' },
+                        {
+                            text: 'datastructure',
+                            collapsed: true,
+                            items: [
+                                { text: 'list', link: '/en/api/packages/datastructure/list' },
+                                { text: 'safelist', link: '/en/api/packages/datastructure/copyonwritelist' },
+                                { text: 'link', link: '/en/api/packages/datastructure/link' },
+                                { text: 'stack', link: '/en/api/packages/datastructure/stack' },
+                                { text: 'queue', link: '/en/api/packages/datastructure/queue' },
+                                { text: 'heap', link: '/en/api/packages/datastructure/heap' },
+                                { text: 'tree', link: '/en/api/packages/datastructure/tree' },
+                                { text: 'set', link: '/en/api/packages/datastructure/set' },
+                                { text: 'hashmap', link: '/en/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: 'datetime', link: '/en/api/packages/datetime' },
+                        { text: 'fileutil', link: '/en/api/packages/fileutil' },
+                        { text: 'formatter', link: '/en/api/packages/formatter' },
+                        { text: 'function', link: '/en/api/packages/function' },
+                        { text: 'mathutil', link: '/en/api/packages/mathutil' },
+                        { text: 'maputil', link: '/en/api/packages/maputil' },
+                        { text: 'netutil', link: '/en/api/packages/netutil' },
+                        { text: 'pointer', link: '/en/api/packages/pointer' },
+                        { text: 'random', link: '/en/api/packages/random' },
+                        { text: 'retry', link: '/en/api/packages/retry' },
+                        { text: 'slice', link: '/en/api/packages/slice' },
+                        { text: 'stream', link: '/en/api/packages/stream' },
+                        { text: 'struct', link: '/en/api/packages/struct' },
+                        { text: 'strutil', link: '/en/api/packages/strutil' },
+                        { text: 'system', link: '/en/api/packages/system' },
+                        { text: 'tuple', link: '/en/api/packages/tuple' },
+                        { text: 'validator', link: '/en/api/packages/validator' },
+                        { text: 'xerror', link: '/en/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/.vitepress/zh.ts

@@ -0,0 +1,152 @@
+import type { DefaultTheme, LocaleSpecificConfig } from 'vitepress'
+
+export const META_URL = 'https://www.golancet.cn'
+export const META_TITLE = 'Lancet'
+export const META_DESCRIPTION = '一个强大的Go语言工具函数库'
+
+export const zhConfig: LocaleSpecificConfig<DefaultTheme.Config> = {
+    description: META_DESCRIPTION,
+
+    head: [
+        ['meta', { property: 'og:url', content: META_URL }],
+        ['meta', { property: 'og:description', content: META_DESCRIPTION }],
+    ],
+
+    themeConfig: {
+        editLink: {
+            pattern: 'https://github.com/duke-git/lancet/edit/v2/docs/:path',
+            text: '对本页提出修改建议',
+        },
+        outline: {
+            label: '本页内容',
+        },
+
+        docFooter: {
+            prev: '上一页',
+            next: '下一页',
+        },
+
+        nav: [
+            {
+                text: '首页',
+                link: '/',
+                activeMatch: '^/',
+            },
+            {
+                text: '指南',
+                link: '/guide/introduction',
+                activeMatch: '^/guide/',
+            },
+            { text: 'API', link: '/api/overview', activeMatch: '^/api/' },
+            {
+                text: '相关链接',
+                items: [
+                    {
+                        text: '论坛',
+                        link: 'https://github.com/duke-git/lancet/discussions',
+                    },
+                    {
+                        text: '更新日志',
+                        link: 'https://github.com/duke-git/lancet/releases',
+                    },
+                    {
+                        text: '参与贡献',
+                        link: 'https://github.com/duke-git/lancet/blob/main/CONTRIBUTING.zh-CN.md',
+                    },
+                ],
+            },
+        ],
+
+        sidebar: {
+            '/guide/': [
+                {
+                    text: '介绍',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: 'Lancet是什么？',
+                            link: '/guide/introduction',
+                        },
+                        {
+                            text: '开始',
+                            link: '/guide/getting_started',
+                        },
+                    ],
+                },
+                {
+                    text: '贡献代码',
+                    collapsed: false,
+                    items: [
+                        {
+                            text: '贡献指南',
+                            link: '/guide/contribution_guide',
+                        },
+                        {
+                            text: '贡献者',
+                            link: '/guide/contributors',
+                        },
+                    ],
+                },
+                {
+                    text: 'API手册',
+                    link: '/api/overview'
+                },
+            ],
+
+            '/api/': [
+                {
+                    text: '概览',
+                    items: [{ text: 'API概述', link: '/api/overview' }],
+                },
+                {
+                    text: 'API文档',
+                    collapsed: false,
+                    items: [
+                        { text: '算法', link: '/api/packages/algorithm' },
+                        { text: '比较器', link: '/api/packages/compare' },
+                        { text: '并发处理', link: '/api/packages/concurrency' },
+                        { text: '条件判断', link: '/api/packages/condition' },
+                        { text: '类型转换', link: '/api/packages/convertor' },
+                        { text: '加密&解密', link: '/api/packages/cryptor' },
+                        {
+                            text: '数据结构',
+                            collapsed: true,
+                            items: [
+                                { text: '线性表', link: '/api/packages/datastructure/list' },
+                                {
+                                    text: '线性表(线程安全)',
+                                    link: '/api/packages/datastructure/copyonwritelist',
+                                },
+                                { text: '链表', link: '/api/packages/datastructure/link' },
+                                { text: '栈', link: '/api/packages/datastructure/stack' },
+                                { text: '队列', link: '/api/packages/datastructure/queue' },
+                                { text: '堆', link: '/api/packages/datastructure/heap' },
+                                { text: '树', link: '/api/packages/datastructure/tree' },
+                                { text: '集合', link: '/api/packages/datastructure/set' },
+                                { text: 'HashMap', link: '/api/packages/datastructure/hashmap' },
+                            ],
+                        },
+                        { text: '日期&时间', link: '/api/packages/datetime' },
+                        { text: '文件', link: '/api/packages/fileutil' },
+                        { text: '格式化工具', link: '/api/packages/formatter' },
+                        { text: '函数', link: '/api/packages/function' },
+                        { text: '数学工具', link: '/api/packages/mathutil' },
+                        { text: 'Map', link: '/api/packages/maputil' },
+                        { text: '网络', link: '/api/packages/netutil' },
+                        { text: '指针', link: '/api/packages/pointer' },
+                        { text: '随机数', link: '/api/packages/random' },
+                        { text: '重试', link: '/api/packages/retry' },
+                        { text: '切片', link: '/api/packages/slice' },
+                        { text: '流', link: '/api/packages/stream' },
+                        { text: '结构体', link: '/api/packages/struct' },
+                        { text: '字符串', link: '/api/packages/strutil' },
+                        { text: '系统', link: '/api/packages/system' },
+                        { text: '元组', link: '/api/packages/tuple' },
+                        { text: '验证器', link: '/api/packages/validator' },
+                        { text: '错误处理', link: '/api/packages/xerror' },
+                    ],
+                },
+            ],
+        },
+    },
+}

docs/api/overview.md

@@ -0,0 +1,69 @@
+---
+outline: deep
+---
+
+# API概述
+
+<b>lancet（柳叶刀）是一个功能强大、全面、高效、可复用的go语言工具函数库。包含25个包，超过600个工具函数。功能涵盖字符串处理、切片处理、网络、并发、加解密、文件处理、时间/日期、流处理、迭代器等等。</b>
+
+
+<style>
+.package-title {
+    color: black;
+    font-size: 18px;
+    text-align: center;
+    font-weight: bold;
+}
+.package-container {
+    font-size: 16px;
+    border: 1px dashed;
+    padding: 10px;
+    text-align: center;
+}
+
+.package-cell {
+    height: 40px;
+    width: 140px;
+    display: inline-block;
+    vertical-align: middle;
+    line-height: 40px;
+    background: #10b981;
+    border: 1px solid;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    font-weight: bold;
+}
+</style>
+
+<div>
+    <p class="package-title">lancet功能模块</p>
+    <div class="package-container">
+        <div class="package-cell">algorithm</div>
+        <div class="package-cell">compare</div>
+        <div class="package-cell">concurrency</div>
+        <div class="package-cell">condition</div>
+        <div class="package-cell">convertor</div>
+        <div class="package-cell">cryptor</div>
+        <div class="package-cell">datastructure</div>
+        <div class="package-cell">datetime</div>
+        <div class="package-cell">fileutil</div>
+        <div class="package-cell">formatter</div>
+        <div class="package-cell">function</div>
+        <div class="package-cell">iterator</div>
+        <div class="package-cell">maputil</div>
+        <div class="package-cell">mathutil</div>
+        <div class="package-cell">netutil</div>
+        <div class="package-cell">pointer</div>
+        <div class="package-cell">random</div>
+        <div class="package-cell">retry</div>
+        <div class="package-cell">slice</div>
+        <div class="package-cell">stream</div>
+        <div class="package-cell">structs</div>
+        <div class="package-cell">strutil</div>
+        <div class="package-cell">system</div>
+        <div class="package-cell">tuple</div>
+        <div class="package-cell">validator</div>
+        <div class="package-cell">xerror</div>
+    </div>
+</div>

docs/api/packages/algorithm.md

@@ -51,7 +51,7 @@ import (
 func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 package main
@@ -99,7 +99,7 @@ func main() {
 func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
 
 ```go
 package main
@@ -162,7 +162,7 @@ func main() {
 func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oXovbkekayS)</span></b>
 
 ```go
 package main
@@ -210,7 +210,7 @@ func main() {
 func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3ibkszpJEu3)</span></b>
 
 ```go
 package main
@@ -258,7 +258,7 @@ func main() {
 func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
 
 ```go
 package main
@@ -306,7 +306,7 @@ func main() {
 func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
 
 ```go
 package main
@@ -354,7 +354,7 @@ func main() {
 func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ydinn9YzUJn)</span></b>
 
 ```go
 package main
@@ -402,7 +402,7 @@ func main() {
 func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
 
 ```go
 package main
@@ -451,7 +451,7 @@ func main() {
 func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/t6MeGiUSN47)</span></b>
 
 ```go
 package main
@@ -502,7 +502,7 @@ func main() {
 func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Anozfr8ZLH3)</span></b>
 
 ```go
 package main
@@ -553,7 +553,7 @@ func main() {
 func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool
 func (l *LRUCache[K, V]) Len() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/-EZjgOURufP)</span></b>
 
 ```go
 package main

docs/api/packages/compare.md

@@ -30,10 +30,12 @@ import (
 -   [GreaterThan](#GreaterThan)
 -   [LessOrEqual](#LessOrEqual)
 -   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
+
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Equal">Equal</span>
 
@@ -45,7 +47,7 @@ import (
 func Equal(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wmVxR-to4lz)</span></b>
 
 ```go
 package main
@@ -94,7 +96,7 @@ func main() {
 func EqualValue(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -133,7 +135,7 @@ func main() {
 func LessThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cYh7FQQj0ne)</span></b>
 
 ```go
 package main
@@ -182,7 +184,7 @@ func main() {
 func GreaterThan(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9-NYDFZmIMp)</span></b>
 
 ```go
 package main
@@ -234,7 +236,7 @@ func main() {
 func LessOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e4T_scwoQzp)</span></b>
 
 ```go
 package main
@@ -283,7 +285,7 @@ func main() {
 func GreaterOrEqual(left, right any) bool
 ```
 
-<b>示例:</b>
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vx8mP0U8DFk)</span></b>
 
 ```go
 package main
@@ -324,3 +326,50 @@ func main() {
     // false
 }
 ```
+
+### <span id="InDelta">InDelta</span>
+
+<p>检查增量内两个值是否相等。</p>
+
+<b>函数签名:</b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>示例: <span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/api/packages/concurrency.md

@@ -1,15 +1,17 @@
 # Concurrency
-并发包包含一些支持并发编程的功能。例如：goroutine, channel等。
+
+并发包包含一些支持并发编程的功能。例如：goroutine, channel 等。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
+-   [https://github.com/duke-git/lancet/blob/main/concurrency/channel.go](https://github.com/duke-git/lancet/blob/main/concurrency/channel.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/concurrency"
@@ -19,25 +21,28 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
+
 ### Channel
-- [NewChannel](#NewChannel)
-- [Bridge](#Bridge)
-- [FanIn](#FanIn)
-- [Generate](#Generate)
-- [Or](#Or)
-- [OrDone](#OrDone)
-- [Repeat](#Repeat)
-- [RepeatFn](#RepeatFn)
-- [Take](#Take)
-- [Tee](#Tee)
+
+-   [NewChannel](#NewChannel)
+-   [Bridge](#Bridge)
+-   [FanIn](#FanIn)
+-   [Generate](#Generate)
+-   [Or](#Or)
+-   [OrDone](#OrDone)
+-   [Repeat](#Repeat)
+-   [RepeatFn](#RepeatFn)
+-   [Take](#Take)
+-   [Tee](#Tee)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
 ### Channel
+
 ### <span id="NewChannel">NewChannel</span>
+
 <p>返回一个Channel指针实例</p>
 
 <b>函数签名:</b>
@@ -46,7 +51,8 @@ import (
 type Channel[T any] struct
 func NewChannel[T any]() *Channel[T]
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -70,7 +76,8 @@ func main() {
 ```go
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
 
 ```go
 package main
@@ -122,7 +129,8 @@ func main() {
 ```go
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2VYFMexEvTm)</span></b>
 
 ```go
 package main
@@ -161,7 +169,8 @@ func main() {
 ```go
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -199,7 +208,8 @@ func main() {
 ```go
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
 
 ```go
 package main
@@ -238,7 +248,8 @@ func main() {
 ```go
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4J1zAWttP85)</span></b>
 
 ```go
 package main
@@ -279,7 +290,8 @@ func main() {
 ```go
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Wqz9rwioPww)</span></b>
 
 ```go
 package main
@@ -322,7 +334,8 @@ func main() {
 ```go
 func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
 
 ```go
 package main
@@ -360,7 +373,8 @@ func main() {
 ```go
 func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
 
 ```go
 package main
@@ -406,7 +420,8 @@ func main() {
 ```go
 func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3TQPKnCirrP)</span></b>
 
 ```go
 package main
@@ -436,4 +451,4 @@ func main() {
     // 1
     // 1
 }
-```
+```

docs/api/packages/condition.md

@@ -18,7 +18,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Index
+## 目录
 
 - [Bool](#Bool)
 - [And](#And)
@@ -31,7 +31,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## 目录
+## 文档
 
 ### <span id="Bool">Bool</span>
 <p>返回传入参数的bool值.<br/>
@@ -45,7 +45,7 @@ slices和map的length大于0时，返回true，否则返回false<br/>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
 
 ```go
 package main
@@ -109,7 +109,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
 
 ```go
 package main
@@ -135,7 +135,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
 
 ```go
 package main
@@ -161,7 +161,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
 
 ```go
 package main
@@ -187,7 +187,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
 
 ```go
 package main
@@ -213,7 +213,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
 
 ```go
 package main
@@ -239,7 +239,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
 
 ```go
 package main
@@ -265,7 +265,7 @@ func main() {
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
 
 ```go
 package main

docs/api/packages/convertor.md

@@ -58,7 +58,7 @@ import (
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/o7_ft-JCJBV)</span></b>
 
 ```go
 package main
@@ -89,7 +89,7 @@ func main() {
 func ColorRGBToHex(red, green, blue int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nzKS2Ro87J1)</span></b>
 
 ```go
 package main
@@ -122,7 +122,7 @@ func main() {
 func ToBool(s string) (bool, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ARht2WnGdIN)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func ToBytes(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fAMXYFDvOvr)</span></b>
 
 ```go
 package main
@@ -196,7 +196,7 @@ func main() {
 func ToChar(s string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JJ1SvbFkVdM)</span></b>
 
 ```go
 package main
@@ -232,7 +232,7 @@ func main() {
 func ToChannel[T any](array []T) <-chan T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hOx_oYZbAnL)</span></b>
 
 ```go
 package main
@@ -269,7 +269,7 @@ func main() {
 func ToFloat(value any) (float64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4YTmPCibqHJ)</span></b>
 
 ```go
 package main
@@ -314,7 +314,7 @@ func main() {
 func ToInt(value any) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9_h9vIt-QZ_b)</span></b>
 
 ```go
 package main
@@ -356,7 +356,7 @@ func main() {
 func ToJson(value any) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2rLIkMmXWvR)</span></b>
 
 ```go
 package main
@@ -391,7 +391,7 @@ func main() {
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tVFy7E-t24l)</span></b>
 
 ```go
 package main
@@ -432,7 +432,7 @@ func main() {
 func ToPointer[T any](value T) *T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ASf_etHNlw1)</span></b>
 
 ```go
 package main
@@ -461,7 +461,7 @@ func main() {
 func ToString(value any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nF1zOOslpQq)</span></b>
 
 ```go
 package main
@@ -509,7 +509,7 @@ func main() {
 func StructToMap(value any) (map[string]any, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KYGYJqNUBOI)</span></b>
 
 ```go
 package main
@@ -547,7 +547,7 @@ func main() {
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dmX4Ix5V6Wl)</span></b>
 
 ```go
 package main
@@ -577,7 +577,7 @@ func main() {
 func EncodeByte(data any) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DVmM1G5JfuP)</span></b>
 
 ```go
 package main
@@ -606,7 +606,7 @@ func main() {
 func DecodeByte(data []byte, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -642,7 +642,7 @@ func main() {
 func DeepClone[T any](src T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j4DP5dquxnk)</span></b>
 
 ```go
 package main
@@ -706,7 +706,7 @@ func main() {
 func CopyProperties[T, U any](dst T, src U) (err error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/oZujoB5Sgg5)</span></b>
 
 ```go
 package main
@@ -785,7 +785,7 @@ func main() {
 func ToInterface(v reflect.Value) (value interface{}, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
 
 ```go
 package main
@@ -820,7 +820,7 @@ func main() {
 func Utf8ToGbk(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9FlIaFLArIL)</span></b>
 
 ```go
 package main
@@ -854,7 +854,7 @@ func main() {
 func GbkToUtf8(bs []byte) ([]byte, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OphmHCN_9u8)</span></b>
 
 ```go
 package main

docs/api/packages/cryptor.md

@@ -1,16 +1,18 @@
 # Cryptor
-cryptor加密包支持数据加密和解密，获取md5，hash值。支持base64, md5, hmac, aes, des, rsa。
+
+cryptor 包包含数据加密和解密功能。支持 base64, md5, hmac, hash, aes, des, rsa。
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
-- [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
-- [https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go](https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 用法:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/cryptor"
@@ -20,47 +22,57 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录
-- [AesEcbEncrypt](#AesEcbEncrypt)
-- [AesEcbDecrypt](#AesEcbDecrypt)
-- [AesCbcEncrypt](#AesCbcEncrypt)
-- [AesCbcDecrypt](#AesCbcDecrypt)
-- [AesCtrCrypt](#AesCtrCrypt)
-- [AesCfbEncrypt](#AesCfbEncrypt)
-- [AesCfbDecrypt](#AesCfbDecrypt)
-- [AesOfbEncrypt](#AesOfbEncrypt)
-- [AesOfbDecrypt](#AesOfbDecrypt)
-- [Base64StdEncode](#Base64StdEncode)
-- [Base64StdDecode](#Base64StdDecode)
-- [DesEcbEncrypt](#DesEcbEncrypt)
-- [DesEcbDecrypt](#DesEcbDecrypt)
-- [DesCbcEncrypt](#DesCbcEncrypt)
-- [DesCbcDecrypt](#DesCbcDecrypt)
-- [DesCtrCrypt](#DesCtrCrypt)
-- [DesCfbEncrypt](#DesCfbEncrypt)
-- [DesCfbDecrypt](#DesCfbDecrypt)
-- [DesOfbEncrypt](#DesOfbEncrypt)
-- [DesOfbDecrypt](#DesOfbDecrypt)
-- [HmacMd5](#HmacMd5)
-- [HmacSha1](#HmacSha1)
-- [HmacSha256](#HmacSha256)
-- [HmacSha512](#HmacSha512)
-- [Md5String](#Md5String)
-- [Md5Byte](#Md5Byte)
-- [Md5File](#Md5File)
-- [Sha1](#Sha1)
-- [Sha256](#Sha256)
-- [Sha512](#Sha512)
-- [GenerateRsaKey](#GenerateRsaKey)
-- [RsaEncrypt](#RsaEncrypt)
-- [RsaDecrypt](#RsaDecrypt)
 
+-   [AesEcbEncrypt](#AesEcbEncrypt)
+-   [AesEcbDecrypt](#AesEcbDecrypt)
+-   [AesCbcEncrypt](#AesCbcEncrypt)
+-   [AesCbcDecrypt](#AesCbcDecrypt)
+-   [AesCtrCrypt](#AesCtrCrypt)
+-   [AesCfbEncrypt](#AesCfbEncrypt)
+-   [AesCfbDecrypt](#AesCfbDecrypt)
+-   [AesOfbEncrypt](#AesOfbEncrypt)
+-   [AesOfbDecrypt](#AesOfbDecrypt)
+-   [Base64StdEncode](#Base64StdEncode)
+-   [Base64StdDecode](#Base64StdDecode)
+-   [DesEcbEncrypt](#DesEcbEncrypt)
+-   [DesEcbDecrypt](#DesEcbDecrypt)
+-   [DesCbcEncrypt](#DesCbcEncrypt)
+-   [DesCbcDecrypt](#DesCbcDecrypt)
+-   [DesCtrCrypt](#DesCtrCrypt)
+-   [DesCfbEncrypt](#DesCfbEncrypt)
+-   [DesCfbDecrypt](#DesCfbDecrypt)
+-   [DesOfbEncrypt](#DesOfbEncrypt)
+-   [DesOfbDecrypt](#DesOfbDecrypt)
+-   [HmacMd5](#HmacMd5)
+-   [HmacMd5WithBase64](#HmacMd5WithBase64)
+-   [HmacSha1](#HmacSha1)
+-   [HmacSha1WithBase64](#HmacSha1WithBase64)
+-   [HmacSha256](#HmacSha256)
+-   [HmacSha256WithBase64](#HmacSha256WithBase64)
+-   [HmacSha512](#HmacSha512)
+-   [HmacSha512WithBase64](#HmacSha512WithBase64)
+-   [Md5String](#Md5String)
+-   [Md5StringWithBase64](#Md5StringWithBase64)
+-   [Md5Byte](#Md5Byte)
+-   [Md5ByteWithBase64](#Md5ByteWithBase64)
+-   [Md5File](#Md5File)
+-   [Sha1](#Sha1)
+-   [Sha1WithBase64](#Sha1WithBase64)
+-   [Sha256](#Sha256)
+-   [Sha256WithBase64](#Sha256WithBase64)
+-   [Sha512](#Sha512)
+-   [Sha512WithBase64](#Sha512WithBase64)
+-   [GenerateRsaKey](#GenerateRsaKey)
+-   [RsaEncrypt](#RsaEncrypt)
+-   [RsaDecrypt](#RsaDecrypt)
+-   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
+-   [RsaEncryptOAEP](#RsaEncryptOAEP)
+-   [RsaDecryptOAEP](#RsaDecryptOAEP)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 文档
 
-
-
 ### <span id="AesEcbEncrypt">AesEcbEncrypt</span>
 
 <p>使用AES ECB算法模式加密数据. 参数`key`的长度是16, 24 or 32。</p>
@@ -70,7 +82,8 @@ import (
 ```go
 func AesEcbEncrypt(data, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -103,7 +116,8 @@ func main() {
 ```go
 func AesEcbDecrypt(encrypted, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -136,7 +150,8 @@ func main() {
 ```go
 func AesCbcEncrypt(data, key []byte) []byte
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -170,7 +185,7 @@ func main() {
 func AesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -204,7 +219,7 @@ func main() {
 func AesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/SpaZO0-5Nsp)</span></b>
 
 ```go
 package main
@@ -238,7 +253,7 @@ func main() {
 func AesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -272,7 +287,7 @@ func main() {
 func AesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -306,7 +321,7 @@ func main() {
 func AesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -329,6 +344,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="AesCfbDecrypt">AesOfbDecrypt</span>
 
 <p>使用AES OFB算法模式解密数据，参数`key`的长度是16, 24 or 32。</p>
@@ -339,7 +355,7 @@ func main() {
 func AesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -372,7 +388,8 @@ func main() {
 ```go
 func Base64StdEncode(s string) string
 ```
-<b>示例:</b>
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VOaUyQUreoK)</span></b>
 
 ```go
 package main
@@ -390,6 +407,7 @@ func main() {
     // aGVsbG8=
 }
 ```
+
 ### <span id="Base64StdDecode">Base64StdDecode</span>
 
 <p>解码base64字符串。</p>
@@ -400,7 +418,7 @@ func main() {
 func Base64StdDecode(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RWQylnJVgIe)</span></b>
 
 ```go
 package main
@@ -429,7 +447,7 @@ func main() {
 func DesEcbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -453,6 +471,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesEcbDecrypt">DesEcbDecrypt</span>
 
 <p>使用DES ECB算法模式解决密数据，参数`key`的长度是8。</p>
@@ -463,7 +482,7 @@ func main() {
 func DesEcbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -498,7 +517,7 @@ func main() {
 func DesCbcEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -532,7 +551,7 @@ func main() {
 func DesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -555,6 +574,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCtrCrypt">DesCtrCrypt</span>
 
 <p>使用DES CTR算法模式加密/解密数据，参数`key`的长度是8</p>
@@ -565,7 +585,7 @@ func main() {
 func DesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9-T6OjKpcdw)</span></b>
 
 ```go
 package main
@@ -599,7 +619,7 @@ func main() {
 func DesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -622,6 +642,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCfbDecrypt">DesCfbDecrypt</span>
 
 <p>使用DES CFB算法模式解决密数据，参数`key`的长度是8。</p>
@@ -632,7 +653,7 @@ func main() {
 func DesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -655,6 +676,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbEncrypt">DesOfbEncrypt</span>
 
 <p>使用DES OFB算法模式加密数据，参数`key`的长度是8。</p>
@@ -665,7 +687,7 @@ func main() {
 func DesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -688,6 +710,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbDecrypt">DesOfbDecrypt</span>
 
 <p>使用DES OFB算法模式解密数据，参数`key`的长度是8。</p>
@@ -698,7 +721,7 @@ func main() {
 func DesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -729,10 +752,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func HmacMd5(data, key string) string
+func HmacMd5(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -743,7 +766,7 @@ import (
 )
 
 func main() {
-      str := "hello"
+    str := "hello"
     key := "12345"
 
     hms := cryptor.HmacMd5(str, key)
@@ -753,17 +776,50 @@ func main() {
     // e834306eab892d872525d4918a7a639a
 }
 ```
-### <span id="HmacSha1">HmacSha1</span>
 
-<p>获取字符串sha1 hmac值。</p>
+### <span id="HmacMd5WithBase64">HmacMd5WithBase64</span>
+
+<p>获取字符串md5 hmac base64字符串值。</p>
 
 <b>函数签名:</b>
 
 ```go
-func HmacSha1(data, key string) string
+func HmacMd5WithBase64(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UY0ng2AefFC)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacMd5WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // 6DQwbquJLYclJdSRinpjmg==
+}
+```
+
+### <span id="HmacSha1">HmacSha1</span>
+
+<p>获取字符串的sha1 hmac值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha1(str, key string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1UI4oQ4WXKM)</span></b>
 
 ```go
 package main
@@ -784,6 +840,39 @@ func main() {
     // 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
 }
 ```
+
+### <span id="HmacSha1WithBase64">HmacSha1WithBase64</span>
+
+<p>获取字符串的sha1 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha1WithBase64(str, key string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/47JmmGrnF7B)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha1WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+```
+
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>获取字符串sha256 hmac值。</p>
@@ -791,10 +880,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func HmacSha256(data, key string) string
+func HmacSha256(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HhpwXxFhhC0)</span></b>
 
 ```go
 package main
@@ -816,6 +905,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha256WithBase64">HmacSha256WithBase64</span>
+
+<p>获取字符串sha256 hmac base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha256WithBase64(str, key string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EKbkUvPTLwO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha256WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+```
+
 ### <span id="HmacSha512">HmacSha512</span>
 
 <p>获取字符串sha512 hmac值。</p>
@@ -823,10 +944,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func HmacSha512(data, key string) string
+func HmacSha512(str, key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/59Od6m4A0Ud)</span></b>
 
 ```go
 package main
@@ -848,6 +969,37 @@ func main() {
 }
 ```
 
+### <span id="HmacSha512WithBase64">HmacSha512WithBase64</span>
+
+<p>获取字符串sha512 hmac base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func HmacSha512WithBase64(str, key string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/c6dSe3E2ydU)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha512WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+```
 
 ### <span id="Md5String">Md5String</span>
 
@@ -856,10 +1008,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Md5String(s string) string
+func Md5String(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1bLcVetbTOI)</span></b>
 
 ```go
 package main
@@ -880,9 +1032,38 @@ func main() {
 }
 ```
 
+### <span id="Md5StringWithBase64">Md5StringWithBase64</span>
+
+<p>获取字符串md5 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Md5StringWithBase64(s string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tcb-Z7LN2ax)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5StringWithBase64("hello")
+    fmt.Println(md5Str)
+
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5Byte">Md5Byte</span>
 
-<p>获取byte slice的md5至。</p>
+<p>获取byte slice的md5值。</p>
 
 <b>函数签名:</b>
 
@@ -890,7 +1071,7 @@ func main() {
 func Md5Byte(data []byte) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/suraalH8lyC)</span></b>
 
 ```go
 package main
@@ -902,10 +1083,39 @@ import (
 
 func main() {
     md5Str := cryptor.Md5Byte([]byte{'a'})
-	fmt.Println(md5Str)
+    fmt.Println(md5Str)
 
-	// Output:
-	// 0cc175b9c0f1b6a831c399e269772661
+    // Output:
+    // 0cc175b9c0f1b6a831c399e269772661
+}
+```
+
+### <span id="Md5ByteWithBase64">Md5ByteWithBase64</span>
+
+<p>获取byte slice的md5 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Md5ByteWithBase64(data []byte) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Lx4gH7Vdr5_y)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
+    fmt.Println(md5Str)
+
+    // Output:
+    // XUFAKrxLKna5cZ2REBfFkg==
 }
 ```
 
@@ -942,10 +1152,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha1(data string) string
+func Sha1(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_m_uoD1deMT)</span></b>
 
 ```go
 package main
@@ -966,6 +1176,35 @@ func main() {
 }
 ```
 
+### <span id="Sha1WithBase64">Sha1WithBase64</span>
+
+<p>获取字符串sha1 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha1WithBase64(str string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fSyx-Gl2l2-)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha1WithBase64("hello")
+    fmt.Println(result)
+
+    // Output:
+    // qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+```
+
 ### <span id="Sha256">Sha256</span>
 
 <p>获取字符串sha256值。</p>
@@ -973,10 +1212,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha256(data string) string
+func Sha256(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tU9tfBMIAr1)</span></b>
 
 ```go
 package main
@@ -997,6 +1236,35 @@ func main() {
 }
 ```
 
+### <span id="Sha256WithBase64">Sha256WithBase64</span>
+
+<p>获取字符串sha256 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha256WithBase64(str string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/85IXJHIal1k)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha256WithBase64("hello")
+    fmt.Println(result)
+
+    // Output:
+    // LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+```
+
 ### <span id="Sha512">Sha512</span>
 
 <p>获取字符串sha512值。</p>
@@ -1004,10 +1272,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func Sha512(data string) string
+func Sha512(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3WsvLYZxsHa)</span></b>
 
 ```go
 package main
@@ -1028,6 +1296,35 @@ func main() {
 }
 ```
 
+### <span id="Sha512WithBase64">Sha512WithBase64</span>
+
+<p>获取字符串sha512 base64值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Sha512WithBase64(str string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q_fY2rA-k5I)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha512WithBase64("hello")
+    fmt.Println(result)
+
+    // Output:
+    // m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}
+```
+
 ### <span id="GenerateRsaKey">GenerateRsaKey</span>
 
 <p>在当前目录下创建rsa私钥文件和公钥文件。</p>
@@ -1038,7 +1335,7 @@ func main() {
 func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zutRHrDqs0X)</span></b>
 
 ```go
 package main
@@ -1066,7 +1363,7 @@ func main() {
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1081,11 +1378,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1093,7 +1390,6 @@ func main() {
 }
 ```
 
-
 ### <span id="RsaDecrypt">RsaDecrypt</span>
 
 <p>用私钥文件rsa解密数据。</p>
@@ -1104,7 +1400,7 @@ func main() {
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1119,14 +1415,125 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
     // hello
 }
-```
+```
+
+### <span id="GenerateRsaKeyPair">GenerateRsaKeyPair</span>
+
+<p>创建rsa公钥私钥和key。</p>
+
+<b>函数签名:</b>
+
+```go
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+}
+```
+
+### <span id="RsaEncryptOAEP">RsaEncryptOAEP</span>
+
+<p>rsa OAEP加密。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```
+
+### <span id="RsaDecryptOAEP">RsaDecryptOAEP</span>
+
+<p>rsa OAEP解密。</p>
+
+<b>函数签名:</b>
+
+```go
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```

docs/api/packages/datastructure/copyonwritelist.md

@@ -0,0 +1,471 @@
+# CopyOnWriteList
+
+CopyOnWriteList 是一个线程安全的 List 实现，底层使用 go 切片。写入时，会复制一份新的切片，写入完成后，再将新的切片赋值给原来的切片。读取时，直接读取原来的切片。
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## 文档
+
+### NewCopyOnWriteList
+
+返回一个具有空切片的 CopyOnWriteList。
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.Locker
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+
+```
+
+### Size
+
+返回 CopyOnWriteList 的长度。
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+返回列表中指定位置的元素
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+将此列表中指定位置的元素替换为指定元素。
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+返回列表中值的索引，如果没有找到返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+返回指定元素在此列表中最后出现的索引，如果此列表不包含该元素，则返回-1。
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3,1})
+	fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+### IsEmpty
+
+如果此列表不包含任何元素，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{})
+	fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+判断 CopyOnWriteList 是否包含某个元素
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+返回列表中索引处的值指针
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+将指定的元素追加到此列表的末尾。
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### 示例
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+将指定集合中的所有元素追加到此列表的末尾
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+将指定元素插入此列表中的指定位置。
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.AddByIndex(2, 6)
+	fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+移除此列表中指定位置的元素。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	list.DeleteAt(2)
+	fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(f func(T) bool) (oldValue *T, ok bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+从此列表中删除第一个出现的指定元素(如果该元素存在)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main()  {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+从该列表中删除索引介于 fromIndex(包含)和 toIndex(不包含)之间的所有元素。
+(左闭右开)。
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+如果指定的对象等于此列表，则返回 true。
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### 示例
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/api/packages/datastructure/hashmap.md

@@ -38,7 +38,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>新建默认容量（1 << 10）的HashMap指针实例</p>
+<p>新建默认容量（1 &lt&lt 10）的HashMap指针实例</p>
 
 <b>函数签名:</b>
 

docs/api/packages/datetime.md

@@ -58,8 +58,12 @@ import (
 -   [IsLeapYear](#IsLeapYear)
 -   [BetweenSeconds](#BetweenSeconds)
 -   [DayOfYear](#DayOfYear)
--   [IsWeekend](#IsWeekend)
-
+-   [IsWeekend<sup>deprecated</sup>](#IsWeekend)
+-   [NowDateOrTime](#NowDateOrTime)
+-   [Timestamp](#Timestamp)
+-   [TimestampMilli](#TimestampMilli)
+-   [TimestampMicro](#TimestampMicro)
+-   [TimestampNano](#TimestampNano)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -67,7 +71,7 @@ import (
 
 ## 注:
 
-1. 方法 FormatTimeToStr 和 FormatStrToTime 中的 format 参数值需要传以下类型之一：
+1. 函数中`format`参数值需要传以下值之一 (忽略大小写):
 
 -   yyyy-mm-dd hh:mm:ss
 -   yyyy-mm-dd hh:mm
@@ -78,14 +82,18 @@ import (
 -   dd-mm-yy hh:mm:ss
 -   yyyy/mm/dd hh:mm:ss
 -   yyyy/mm/dd hh:mm
--   yyyy-mm-dd hh
+-   yyyy/mm/dd hh
 -   yyyy/mm/dd
 -   yyyy/mm
 -   mm/dd
 -   dd/mm/yy hh:mm:ss
+-   yyyymmdd
+-   mmddyy
 -   yyyy
+-   yy
 -   mm
 -   hh:mm:ss
+-   hh:mm
 -   mm:ss
 
 ### <span id="AddDay">AddDay</span>
@@ -98,7 +106,7 @@ import (
 func AddDay(t time.Time, day int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
 
 ```go
 package main
@@ -137,7 +145,7 @@ func main() {
 func AddHour(t time.Time, hour int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
 
 ```go
 package main
@@ -176,7 +184,7 @@ func main() {
 func AddMinute(t time.Time, minute int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nT1heB1KUUK)</span></b>
 
 ```go
 package main
@@ -215,7 +223,7 @@ func main() {
 func AddYear(t time.Time, year int64) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MqW2ujnBx10)</span></b>
 
 ```go
 package main
@@ -254,7 +262,7 @@ func main() {
 func BeginOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ieOLVJ9CiFT)</span></b>
 
 ```go
 package main
@@ -286,7 +294,7 @@ func main() {
 func BeginOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhdGFnDWpYs)</span></b>
 
 ```go
 package main
@@ -318,7 +326,7 @@ func main() {
 func BeginOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/94m_UT6cWs9)</span></b>
 
 ```go
 package main
@@ -350,7 +358,7 @@ func main() {
 func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ynjoJPz7VNV)</span></b>
 
 ```go
 package main
@@ -382,7 +390,7 @@ func main() {
 func BeginOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bWXVFsmmzwL)</span></b>
 
 ```go
 package main
@@ -414,7 +422,7 @@ func main() {
 func BeginOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/i326DSwLnV8)</span></b>
 
 ```go
 package main
@@ -446,7 +454,7 @@ func main() {
 func EndOfMinute(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yrL5wGzPj4z)</span></b>
 
 ```go
 package main
@@ -478,7 +486,7 @@ func main() {
 func EndOfHour(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6ce3j_6cVqN)</span></b>
 
 ```go
 package main
@@ -510,7 +518,7 @@ func main() {
 func EndOfDay(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eMBOvmq5Ih1)</span></b>
 
 ```go
 package main
@@ -542,7 +550,7 @@ func main() {
 func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/i08qKXD9flf)</span></b>
 
 ```go
 package main
@@ -574,7 +582,7 @@ func main() {
 func EndOfMonth(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_GWh10B3Nqi)</span></b>
 
 ```go
 package main
@@ -606,7 +614,7 @@ func main() {
 func EndOfYear(t time.Time) time.Time
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G01cKlMCvNm)</span></b>
 
 ```go
 package main
@@ -638,7 +646,7 @@ func main() {
 func GetNowDate() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PvfkPpcpBBf)</span></b>
 
 ```go
 package main
@@ -667,7 +675,7 @@ func main() {
 func GetNowTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l7BNxCkTmJS)</span></b>
 
 ```go
 package main
@@ -696,7 +704,7 @@ func main() {
 func GetNowDateTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pI4AqngD0al)</span></b>
 
 ```go
 package main
@@ -717,7 +725,7 @@ func main() {
 
 ### <span id="GetTodayStartTime">GetTodayStartTime</span>
 
-<p>返回当天开始时间， 格式: yyyy-mm-dd 00:00:00.</p>
+<p>返回当天开始时间， 格式: yyyy-mm-dd 00:00:00。</p>
 
 <b>函数签名:</b>
 
@@ -725,7 +733,7 @@ func main() {
 func GetTodayStartTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/84siyYF7t99)</span></b>
 
 ```go
 package main
@@ -746,7 +754,7 @@ func main() {
 
 ### <span id="GetTodayEndTime">GetTodayEndTime</span>
 
-<p>返回当天结束时间，格式: yyyy-mm-dd 23:59:59.</p>
+<p>返回当天结束时间，格式: yyyy-mm-dd 23:59:59。</p>
 
 <b>函数签名:</b>
 
@@ -754,7 +762,7 @@ func main() {
 func GetTodayEndTime() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jjrLnfoqgn3)</span></b>
 
 ```go
 package main
@@ -783,7 +791,7 @@ func main() {
 func GetZeroHourTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QmL2oIaGE3q)</span></b>
 
 ```go
 package main
@@ -812,7 +820,7 @@ func main() {
 func GetNightTimestamp() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UolysR3MYP1)</span></b>
 
 ```go
 package main
@@ -838,10 +846,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func FormatTimeToStr(t time.Time, format string) string
+func FormatTimeToStr(t time.Time, format string, timezone ...string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Ia7M8H_OvE)</span></b>
 
 ```go
 package main
@@ -877,10 +885,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func FormatStrToTime(str, format string) (time.Time, error)
+func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1h9FwdU8ql4)</span></b>
 
 ```go
 package main
@@ -919,7 +927,7 @@ type theTime struct {
 func NewUnixNow() *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/U4PPx-9D0oz)</span></b>
 
 ```go
 package main
@@ -951,7 +959,7 @@ type theTime struct {
 func NewUnix(unix int64) *theTime
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/psoSuh_kLRt)</span></b>
 
 ```go
 package main
@@ -983,7 +991,7 @@ type theTime struct {
 func NewFormat(t string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1015,7 +1023,7 @@ type theTime struct {
 func NewISO8601(iso8601 string) (*theTime, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1044,7 +1052,7 @@ func main() {
 func (t *theTime) ToUnix() int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_LUiwAdocjy)</span></b>
 
 ```go
 package main
@@ -1073,7 +1081,7 @@ func main() {
 func (t *theTime) ToFormat() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1102,7 +1110,7 @@ func main() {
 func (t *theTime) ToFormatForTpl(tpl string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nyXxXcQJ8L5)</span></b>
 
 ```go
 package main
@@ -1132,7 +1140,7 @@ func main() {
 func (t *theTime) ToIso8601() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1162,7 +1170,7 @@ func main() {
 func IsLeapYear(year int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xS1eS2ejGew)</span></b>
 
 ```go
 package main
@@ -1195,7 +1203,7 @@ func main() {
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/n3YDRyfyXJu)</span></b>
 
 ```go
 package main
@@ -1232,7 +1240,7 @@ func main() {
 func DayOfYear(t time.Time) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0hjqhTwFNlH)</span></b>
 
 ```go
 package main
@@ -1263,7 +1271,7 @@ func main() {
 }
 ```
 
-### <span id="IsWeekend">IsWeekend</span>
+### <span id="IsWeekend">IsWeekend（已废弃, 使用 '== Weekday'）</span>
 
 <p>判断日期是否是周末。</p>
 
@@ -1273,7 +1281,7 @@ func main() {
 func IsWeekend(t time.Time) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cupRM5aZOIY)</span></b>
 
 ```go
 package main
@@ -1302,3 +1310,158 @@ func main() {
     // false
 }
 ```
+
+### <span id="NowDateOrTime">NowDateOrTime</span>
+
+<p>根据指定的格式和时区返回当前时间字符串。</p>
+
+<b>函数签名:</b>
+
+```go
+func NowDateOrTime(format string, timezone ...string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EZ-begEjtT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    result1 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss")
+
+	result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 2023-07-26 15:01:30
+    // 2023-07-26 02:01:30
+}
+```
+
+### <span id="Timestamp">Timestamp</span>
+
+<p>返回当前秒级时间戳。</p>
+
+<b>函数签名:</b>
+
+```go
+func Timestamp(timezone ...string) int64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iU5b7Vvjx6x)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.Timestamp()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051
+}
+```
+
+
+### <span id="TimestampMilli">TimestampMilli</span>
+
+<p>返回当前毫秒级时间戳。</p>
+
+<b>函数签名:</b>
+
+```go
+func TimestampMilli(timezone ...string) int64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4gvEusOTu1T)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampMilli()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331
+}
+```
+
+### <span id="TimestampMicro">TimestampMicro</span>
+
+<p>返回当前微秒级时间戳。</p>
+
+<b>函数签名:</b>
+
+```go
+func TimestampMicro(timezone ...string) int64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2maANglKHQE)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampMicro()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331784
+}
+```
+
+### <span id="TimestampNano">TimestampNano</span>
+
+<p>返回当前纳秒级时间戳。</p>
+
+<b>函数签名:</b>
+
+```go
+func TimestampNano(timezone ...string) int64
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/A9Oq_COrcCF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampNano()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331788000
+}
+```

docs/api/packages/fileutil.md

@@ -47,6 +47,7 @@ import (
 -   [WriteCsvFile](#WriteCsvFile)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +63,7 @@ import (
 func ClearFile(path string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NRZ0ZT-G94H)</span></b>
 
 ```go
 package main
@@ -90,7 +91,7 @@ func main() {
 func CreateFile(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lDt8PEsTNKI)</span></b>
 
 ```go
 package main
@@ -108,7 +109,7 @@ func main() {
 
 ### <span id="CreateDir">CreateDir</span>
 
-<p>使用绝对路径创建嵌套目录，例如/a/, /a/b/</p>
+<p>使用绝对路径创建嵌套目录，例如/a/, /a/b</p>
 
 <b>函数签名:</b>
 
@@ -116,7 +117,7 @@ func main() {
 func CreateDir(absPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qUuCe1OGQnM)</span></b>
 
 ```go
 package main
@@ -127,7 +128,7 @@ import (
 )
 
 func main() {
-    err := fileutil.CreateDir("/a/")
+    err := fileutil.CreateDir("/a/b") // will create folder /a/b
     fmt.Println(err)
 }
 ```
@@ -142,7 +143,7 @@ func main() {
 func CopyFile(srcPath string, dstPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Jg9AMJMLrJi)</span></b>
 
 ```go
 package main
@@ -170,7 +171,7 @@ func main() {
 func CurrentPath() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s74a9iBGcSw)</span></b>
 
 ```go
 package main
@@ -196,7 +197,7 @@ func main() {
 func FileMode(path string) (fs.FileMode, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2l2hI42fA3p)</span></b>
 
 ```go
 package main
@@ -225,7 +226,7 @@ func main() {
 func MiMeType(file any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bd5sevSUZNu)</span></b>
 
 ```go
 package main
@@ -256,7 +257,7 @@ func main() {
 func IsExist(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nKKXt8ZQbmh)</span></b>
 
 ```go
 package main
@@ -283,7 +284,7 @@ func main() {
 func IsLink(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TL-b-Kzvf44)</span></b>
 
 ```go
 package main
@@ -309,7 +310,7 @@ func main() {
 func IsDir(path string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WkVwEKqtOWk)</span></b>
 
 ```go
 package main
@@ -338,7 +339,7 @@ func main() {
 func ListFileNames(path string) ([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Tjd7Y07rejl)</span></b>
 
 ```go
 package main
@@ -364,7 +365,7 @@ func main() {
 func RemoveFile(path string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P2y0XW8a1SH)</span></b>
 
 ```go
 package main
@@ -392,7 +393,7 @@ func main() {
 func ReadFileToString(path string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cmfwp_5SQTp)</span></b>
 
 ```go
 package main
@@ -425,7 +426,7 @@ func main() {
 func ReadFileByLine(path string)([]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/svJP_7ZrBrD)</span></b>
 
 ```go
 package main
@@ -459,7 +460,7 @@ func main() {
 func Zip(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/j-3sWBp8ik_P)</span></b>
 
 ```go
 package main
@@ -487,7 +488,7 @@ func main() {
 func ZipAppendEntry(fpath string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cxvaT8TRNQp)</span></b>
 
 ```go
 package main
@@ -515,7 +516,7 @@ func main() {
 func UnZip(zipFile string, destPath string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g0w34kS7B8m)</span></b>
 
 ```go
 package main
@@ -543,7 +544,7 @@ func main() {
 func IsZipFile(filepath string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9M0g2j_uF_e)</span></b>
 
 ```go
 package main
@@ -569,7 +570,7 @@ func main() {
 func FileSize(path string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/H9Z05uD-Jjc)</span></b>
 
 ```go
 package main
@@ -601,7 +602,7 @@ func main() {
 func MTime(filepath string) (int64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s_Tl7lZoAaY)</span></b>
 
 ```go
 package main
@@ -633,7 +634,7 @@ func main() {
 func Sha(filepath string, shaType ...int) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VfEEcO2MJYf)</span></b>
 
 ```go
 package main
@@ -671,7 +672,7 @@ func main() {
 func ReadCsvFile(filepath string) ([][]string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
 
 ```go
 package main
@@ -703,7 +704,7 @@ func main() {
 func WriteCsvFile(filepath string, records [][]string, append bool) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
 
 ```go
 package main
@@ -752,7 +753,7 @@ func main() {
 func WriteBytesToFile(filepath string, content []byte) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s7QlDxMj3P8)</span></b>
 
 ```go
 package main
@@ -801,7 +802,7 @@ func main() {
 func WriteStringToFile(filepath string, content string, append bool) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GhLS6d8lH_g)</span></b>
 
 ```go
 package main
@@ -839,3 +840,41 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ReadFile">ReadFile</span>
+
+<p>读取文件或者URL。</p>
+
+<b>函数签名:</b>
+
+```go
+func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    reader, fn, err := fileutil.ReadFile("https://httpbin.org/robots.txt")
+    if err != nil {
+        return
+    }
+    defer fn()
+
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    fmt.Println(string(dat))
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
+}
+```

docs/api/packages/formatter.md

@@ -45,7 +45,7 @@ import (
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -81,7 +81,7 @@ func main() {
 func Pretty(v any) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YsciGj3FH2x)</span></b>
 
 ```go
 package main
@@ -120,7 +120,7 @@ func main() {
 func PrettyToWriter(v any, out io.Writer) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/LPLZ3lDi5ma)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func DecimalBytes(size float64, precision ...int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FPXs1suwRcs)</span></b>
 
 ```go
 package main
@@ -202,7 +202,7 @@ func main() {
 func BinaryBytes(size float64, precision ...int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/G9oHHMCAZxP)</span></b>
 
 ```go
 package main
@@ -241,7 +241,7 @@ func main() {
 func ParseDecimalBytes(size string) (uint64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Am98ybWjvjj)</span></b>
 
 ```go
 package main
@@ -280,7 +280,7 @@ func main() {
 func ParseBinaryBytes(size string) (uint64, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/69v1tTT62x8)</span></b>
 
 ```go
 package main

docs/api/packages/function.md

@@ -47,7 +47,7 @@ import (
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -80,7 +80,7 @@ func main() {
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
 
 ```go
 package main
@@ -88,7 +88,6 @@ package main
 import (
     "fmt"
     "github.com/duke-git/lancet/v2/function"
-    "github.com/duke-git/lancet/v2/internal"
 )
 
 func main() {
@@ -118,7 +117,7 @@ type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/5HopfDwANKX)</span></b>
 
 ```go
 package main
@@ -157,7 +156,7 @@ func main() {
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KKfugD4PKYF)</span></b>
 
 ```go
 package main
@@ -195,7 +194,7 @@ func main() {
 func Debounced(fn func(), duration time.Duration) func()
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/absuEGB_GN7)</span></b>
 
 ```go
 package main
@@ -245,7 +244,7 @@ func main() {
 func Delay(delay time.Duration, fn any, args ...any)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
 
 ```go
 package main
@@ -277,7 +276,7 @@ func main() {
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
 
 ```go
 package main
@@ -316,7 +315,7 @@ func main() {
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
 
 ```go
 package main
@@ -361,13 +360,14 @@ type Watcher struct {
     excuting  bool
 }
 func NewWatcher() *Watcher
-func (w *Watcher) Start() //start the watcher
-func (w *Watcher) Stop() //stop the watcher
-func (w *Watcher) Reset() //reset the watcher
-func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
+func (w *Watcher) Start()
+func (w *Watcher) Stop()
+func (w *Watcher) Reset()
+func (w *Watcher) GetElapsedTime() time.Duration
+
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
 
 ```go
 package main

docs/api/packages/maputil.md

@@ -43,6 +43,15 @@ import (
 -   [Merge](#Merge)
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
+-   [HasKey](#HasKey)
+-   [NewConcurrentMap](#NewConcurrentMap)
+-   [ConcurrentMap_Get](#ConcurrentMap_Get)
+-   [ConcurrentMap_Set](#ConcurrentMap_Set)
+-   [ConcurrentMap_GetOrSet](#ConcurrentMap_GetOrSet)
+-   [ConcurrentMap_Delete](#ConcurrentMap_Delete)
+-   [ConcurrentMap_GetAndDelete](#ConcurrentMap_GetAndDelete)
+-   [ConcurrentMap_Has](#ConcurrentMap_Has)
+-   [ConcurrentMap_Range](#ConcurrentMap_Range)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -58,7 +67,7 @@ import (
 func MapTo(src any, dst any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4K7KBEPgS5M)</span></b>
 
 ```go
 package main
@@ -115,7 +124,7 @@ func main() {
 func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OaThj6iNVXK)</span></b>
 
 ```go
 package main
@@ -156,7 +165,7 @@ func main() {
 func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fSvF3wxuNG7)</span></b>
 
 ```go
 package main
@@ -201,7 +210,7 @@ func main() {
 func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7ov6BJHbVqh)</span></b>
 
 ```go
 package main
@@ -239,7 +248,7 @@ func main() {
 func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P3-9MdcXegR)</span></b>
 
 ```go
 package main
@@ -277,7 +286,7 @@ func main() {
 func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YJM4Hj5hNwm)</span></b>
 
 ```go
 package main
@@ -318,7 +327,7 @@ func main() {
 func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jXGrWDBfSRp)</span></b>
 
 ```go
 package main
@@ -356,7 +365,7 @@ func main() {
 func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XB7Y10uw20_U)</span></b>
 
 ```go
 package main
@@ -394,7 +403,7 @@ func main() {
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Zld0oj3sjcC)</span></b>
 
 ```go
 package main
@@ -449,7 +458,7 @@ func main() {
 func Keys[K comparable, V any](m map[K]V) []K
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xNB5bTb97Wd)</span></b>
 
 ```go
 package main
@@ -488,7 +497,7 @@ func main() {
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/H95LENF1uB-)</span></b>
 
 ```go
 package main
@@ -527,7 +536,7 @@ func main() {
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3u5U9K7YZ9m)</span></b>
 
 ```go
 package main
@@ -569,7 +578,7 @@ func main() {
 func Values[K comparable, V any](m map[K]V) []V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CBKdUc5FTW6)</span></b>
 
 ```go
 package main
@@ -606,7 +615,7 @@ func main() {
 func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hI371iB8Up8)</span></b>
 
 ```go
 package main
@@ -647,7 +656,7 @@ func main() {
 func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sg9-oRidh8f)</span></b>
 
 ```go
 package main
@@ -696,7 +705,7 @@ func main() {
 func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8scDxWeBDKd)</span></b>
 
 ```go
 package main
@@ -735,7 +744,7 @@ func main() {
 func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g92aY3fc7Iw)</span></b>
 
 ```go
 package main
@@ -778,7 +787,7 @@ type Entry[K comparable, V any] struct {
 func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ltb11LNcElY)</span></b>
 
 ```go
 package main
@@ -823,7 +832,7 @@ type Entry[K comparable, V any] struct {
 func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
 
 ```go
 package main
@@ -857,7 +866,7 @@ func main() {
 func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P6ovfToM3zj)</span></b>
 
 ```go
 package main
@@ -896,7 +905,7 @@ func main() {
 func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -932,3 +941,415 @@ func main() {
     // false
 }
 ```
+
+### <span id="HasKey">HasKey</span>
+
+<p>检查map是否包含某个key。用于代替以下样板代码:</p>
+
+```go
+_, haskey := amap["baz"];
+
+if haskey {
+    fmt.Println("map has key baz")
+}
+```
+
+<b>函数签名:</b>
+
+```go
+func HasKey[K comparable, V any](m map[K]V, key K) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/isZZHOsDhFc)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+    }
+
+    result1 := maputil.HasKey(m, "a")
+    result2 := maputil.HasKey(m, "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="NewConcurrentMap">NewConcurrentMap</span>
+
+<p>ConcurrentMap协程安全的map结构。</p>
+
+<b>函数签名:</b>
+
+```go
+// NewConcurrentMap create a ConcurrentMap with specific shard count.
+func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // create a ConcurrentMap whose key type is string, value type is int
+    cm := maputil.NewConcurrentMap[string, int](100)
+}
+```
+
+### <span id="ConcurrentMap_Set">ConcurrentMap_Set</span>
+
+<p>在map中设置key和value。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Set(key K, value V)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+			wg2.Done()
+        }(j)
+    }
+	wg2.Wait()
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_Get">ConcurrentMap_Get</span>
+
+<p>根据key获取value, 如果不存在key,返回零值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok)
+			wg2.Done()
+        }(j)
+    }
+	wg2.Wait()
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_GetOrSet">ConcurrentMap_GetOrSet</span>
+
+<p>返回键的现有值（如果存在），否则，设置key并返回给定值。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aDcDApOK01a)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg sync.WaitGroup
+    wg.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            val, ok := cm.GetOrSet(fmt.Sprintf("%d", n), n)
+            fmt.Println(val, ok)
+            wg.Done()
+        }(i)
+    }
+    wg.Wait()
+
+    // output: (order may change)
+    // 1 false
+    // 3 false
+    // 2 false
+    // 0 false
+    // 4 false
+}
+```
+
+### <span id="ConcurrentMap_Delete">ConcurrentMap_Delete</span>
+
+<p>删除key。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Delete(key K)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uTIJZYhpVMS)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            cm.Delete(fmt.Sprintf("%d", n))
+            wg2.Done()
+        }(i)
+    }
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
+
+<p>获取key，然后删除。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZyxeIXSZUiM)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //n, true
+
+            _, ok = cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //false
+
+            wg2.Done()
+        }(j)
+    }
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
+
+<p>验证是否包含key。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Has(key K) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            ok := cm.Has(fmt.Sprintf("%d", n))
+            fmt.Println(ok) // true
+
+            wg2.Done()
+        }(j)
+    }
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
+
+<p>为map中每个键和值顺序调用迭代器。 如果iterator返回false，则停止迭代。</p>
+
+<b>函数签名:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iqcy7P8P0Pr)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    cm.Range(func(key string, value int) bool {
+        fmt.Println(value)
+        return true
+    })
+}
+```

docs/api/packages/mathutil.md

@@ -50,7 +50,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation
+## 文档
 
 ### <span id="Average">Average</span>
 
@@ -62,7 +62,7 @@ import (
 func Average[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
 
 ```go
 package main
@@ -97,7 +97,7 @@ func main() {
 func Exponent(x, n int64) int64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Vv7LBwER-pz)</span></b>
 
 ```go
 package main
@@ -133,7 +133,7 @@ func main() {
 func Fibonacci(first, second, n int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IscseUNMuUc)</span></b>
 
 ```go
 package main
@@ -169,7 +169,7 @@ func main() {
 func Factorial(x uint) uint
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tt6LdOK67Nx)</span></b>
 
 ```go
 package main
@@ -205,7 +205,7 @@ func main() {
 func Max[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cN8DHI0rTkH)</span></b>
 
 ```go
 package main
@@ -238,7 +238,7 @@ func main() {
 func MaxBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -282,7 +282,7 @@ func main() {
 func Min[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -315,7 +315,7 @@ func main() {
 func MinBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -359,7 +359,7 @@ func main() {
 func Percent(val, total float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/s0NdFCtwuyd)</span></b>
 
 ```go
 package main
@@ -395,7 +395,7 @@ func main() {
 func RoundToFloat(x float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -431,7 +431,7 @@ func main() {
 func RoundToString(x float64, n int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -467,7 +467,7 @@ func main() {
 func TruncRound(x float64, n int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -503,7 +503,7 @@ func main() {
 func Range[T constraints.Integer | constraints.Float](start T, count int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9ke2opxa8ZP)</span></b>
 
 ```go
 package main
@@ -542,7 +542,7 @@ func main() {
 func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/akLWz0EqOSM)</span></b>
 
 ```go
 package main
@@ -581,7 +581,7 @@ func main() {
 func AngleToRadian(angle float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CIvlICqrHql)</span></b>
 
 ```go
 package main
@@ -617,7 +617,7 @@ func main() {
 func RadianToAngle(radian float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dQtmOTUOMgi)</span></b>
 
 ```go
 package main
@@ -653,7 +653,7 @@ func main() {
 func PointDistance(x1, y1, x2, y2 float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RrG4JIaziM8)</span></b>
 
 ```go
 package main
@@ -683,7 +683,7 @@ func main() {
 func IsPrime(n int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rdd8UTHZJ7u)</span></b>
 
 ```go
 package main
@@ -722,7 +722,7 @@ func main() {
 func GCD[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CiEceLSoAKB)</span></b>
 
 ```go
 package main
@@ -764,7 +764,7 @@ func main() {
 func LCM[T constraints.Integer](integers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EjcZxfY7G_g)</span></b>
 
 ```go
 package main
@@ -800,7 +800,7 @@ func main() {
 func Cos(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Sm89LoIfvFq)</span></b>
 
 ```go
 package main
@@ -842,7 +842,7 @@ func main() {
 func Sin(radian float64, precision ...int) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/TWMQlMywDsP)</span></b>
 
 ```go
 package main
@@ -884,7 +884,7 @@ func main() {
 func Log(n, base float64) float64
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_d4bi8oyhat)</span></b>
 
 ```go
 package main
@@ -920,7 +920,7 @@ func main() {
 func Sum[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1To2ImAMJA7)</span></b>
 
 ```go
 package main
@@ -953,7 +953,7 @@ func main() {
 func Abs[T constraints.Integer | constraints.Float](x T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fsyBh1Os-1d)</span></b>
 
 ```go
 package main

docs/api/packages/netutil.md

@@ -63,7 +63,7 @@ import (
 func ConvertMapToQueryString(param map[string]any) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jnNt_qoSnRi)</span></b>
 
 ```go
 package main
@@ -98,7 +98,7 @@ func main() {
 func EncodeUrl(urlStr string) (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bsZ6BRC4uKI)</span></b>
 
 ```go
 package main
@@ -133,7 +133,7 @@ func main() {
 func GetInternalIp() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 package main
@@ -165,7 +165,7 @@ func main() {
 func GetIps() []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NUFfcEmukx1)</span></b>
 
 ```go
 package main
@@ -195,7 +195,7 @@ func main() {
 func GetMacAddrs() []string {
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Rq9UUBS_Xp1)</span></b>
 
 ```go
 package main
@@ -239,7 +239,7 @@ type PublicIpInfo struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YDxIfozsRHR)</span></b>
 
 ```go
 package main
@@ -269,7 +269,7 @@ func main() {
 func GetRequestPublicIp(req *http.Request) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/kxU-YDc_eBo)</span></b>
 
 ```go
 package main
@@ -307,7 +307,7 @@ func main() {
 func IsPublicIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nmktSQpJZnn)</span></b>
 
 ```go
 package main
@@ -344,7 +344,7 @@ func main() {
 func IsInternalIP(IP net.IP) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sYGhXbgO4Cb)</span></b>
 
 ```go
 package main
@@ -388,7 +388,7 @@ type HttpRequest struct {
 }
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -445,7 +445,7 @@ func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -476,7 +476,7 @@ func main() {
 func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -530,7 +530,7 @@ func main() {
 func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -584,7 +584,7 @@ func main() {
 func StructToUrlValues(targetStruct any) url.Values
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pFqMkM40w9z)</span></b>
 
 ```go
 package main
@@ -966,7 +966,7 @@ func main() {
 func IsPingConnected(host string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q8OzTijsA87)</span></b>
 
 ```go
 package main
@@ -999,7 +999,7 @@ func main() {
 func IsTelnetConnected(host string, port string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yiLCGtQv_ZG)</span></b>
 
 ```go
 package main

docs/api/packages/pointer.md

@@ -0,0 +1,227 @@
+# Pointer
+
+pointer 包支持一些指针类型的操作。
+
+<div STYLE="page-break-after: always;"></div>
+
+## 源码:
+
+-   [https://github.com/duke-git/lancet/blob/main/pointer/pointer.go](https://github.com/duke-git/lancet/blob/main/pointer/pointer.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 用法:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/pointer"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [Of](#Of)
+-   [Unwrap](#Unwrap)
+-   [ExtractPointer](#ExtractPointer)
+-   [UnwarpOr](#UnwarpOr)
+-   [UnwarpOrDefault](#UnwarpOrDefault)
+
+<div STYLE="page-break-after: always;"></div>
+
+## 文档
+
+### <span id="Of">Of</span>
+
+<p>返回传入参数的指针值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Of[T any](v T) *T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HFd70x4DrMj)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    result1 := pointer.Of(123)
+    result2 := pointer.Of("abc")
+
+    fmt.Println(*result1)
+    fmt.Println(*result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+### <span id="Unwrap">Unwrap</span>
+
+<p>返回传入指针指向的值。</p>
+
+<b>函数签名:</b>
+
+```go
+func Unwrap[T any](p *T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/cgeu3g7cjWb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 123
+    b := "abc"
+
+    result1 := pointer.Unwrap(&a)
+    result2 := pointer.Unwrap(&b)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+### <span id="ExtractPointer">ExtractPointer</span>
+
+<p>返回传入interface的底层值。</p>
+
+<b>函数签名:</b>
+
+```go
+func ExtractPointer(value any) any
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/D7HFjeWU2ZP)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 1
+    b := &a
+    c := &b
+    d := &c
+
+    result := pointer.ExtractPointer(d)
+
+    fmt.Println(result)
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="UnwarpOr">UnwarpOr</span>
+
+<p>返回指针的值，如果指针为零值，则返回fallback。</p>
+
+<b>函数签名:</b>
+
+```go
+UnwarpOr[T any](p *T, fallback T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/mmNaLC38W8C)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOr(&a, 456)
+	result2 := pointer.UnwarpOr(&b, "abc")
+	result3 := pointer.UnwarpOr(c, 456)
+	result4 := pointer.UnwarpOr(d, "def")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 456
+	// def
+}
+```
+
+### <span id="UnwarpOrDefault">UnwarpOrDefault</span>
+
+<p>返回指针的值，如果指针为零值，则返回相应零值。</p>
+
+<b>函数签名:</b>
+
+```go
+UnwarpOrDefault[T any](p *T) T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZnGIHf8_o4E)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOrDefault(&a)
+	result2 := pointer.UnwarpOrDefault(&b)
+	result3 := pointer.UnwarpOrDefault(c)
+	result4 := pointer.UnwarpOrDefault(d)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 0
+	//
+}
+```

docs/api/packages/random.md

@@ -29,8 +29,11 @@ import (
 -   [RandLower](#RandLower)
 -   [RandNumeral](#RandNumeral)
 -   [RandNumeralOrLetter](#RandNumeralOrLetter)
+-   [RandSymbolChar](#RandSymbolChar)
 -   [UUIdV4](#UUIdV4)
 -   [RandUniqueIntSlice](#RandUniqueIntSlice)
+-   [RandFloat](#RandFloat)
+-   [RandFloats](#RandFloats)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -46,7 +49,7 @@ import (
 func RandBytes(length int) []byte
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/EkiLESeXf8d)</span></b>
 
 ```go
 package main
@@ -72,7 +75,7 @@ func main() {
 func RandInt(min, max int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pXyyAAI5YxD)</span></b>
 
 ```go
 package main
@@ -98,7 +101,7 @@ func main() {
 func RandString(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W2xvRUXA7Mi)</span></b>
 
 ```go
 package main
@@ -124,7 +127,7 @@ func main() {
 func RandUpper(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/29QfOh0DVuh)</span></b>
 
 ```go
 package main
@@ -150,7 +153,7 @@ func main() {
 func RandLower(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XJtZ471cmtI)</span></b>
 
 ```go
 package main
@@ -176,7 +179,7 @@ func main() {
 func RandNumeral(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g4JWVpHsJcf)</span></b>
 
 ```go
 package main
@@ -202,7 +205,7 @@ func main() {
 func RandNumeralOrLetter(length int) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/19CEQvpx2jD)</span></b>
 
 ```go
 package main
@@ -218,6 +221,32 @@ func main() {
 }
 ```
 
+### <span id="RandSymbolChar">RandSymbolChar</span>
+
+<p>生成给定长度的随机符号字符串. 符号字符包括: !@#$%^&*()_+-=[]{}|;':\",./<>?。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandSymbolChar(length int) string
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandSymbolChar(6)
+    fmt.Println(randStr) //@#(_")
+}
+```
+
 ### <span id="UUIdV4">UUIdV4</span>
 
 <p>生成UUID v4字符串</p>
@@ -228,7 +257,7 @@ func main() {
 func UUIdV4() (string, error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_Z9SFmr28ft)</span></b>
 
 ```go
 package main
@@ -257,7 +286,7 @@ func main() {
 func RandUniqueIntSlice(n, min, max int) []int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uBkRSOz73Ec)</span></b>
 
 ```go
 package main
@@ -272,3 +301,55 @@ func main() {
     fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```
+
+### <span id="RandFloat">RandFloat</span>
+
+<p>生成随机float64数字，可以指定范围和精度。</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloat(min, max float64, precision int) float64
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumber := random.RandFloat(1.0, 5.0, 2)
+    fmt.Println(floatNumber) //2.14 (random number)
+}
+```
+
+### <span id="RandFloats">RandFloats</span>
+
+<p>生成随机float64数字切片，指定长度，范围和精度.</p>
+
+<b>函数签名:</b>
+
+```go
+func RandFloats(n int, min, max float64, precision int) []float64
+```
+
+<b>实例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumbers := random.RandFloats(5, 1.0, 5.0, 2)
+    fmt.Println(floatNumber) //[3.42 3.99 1.3 2.38 4.23] (random)
+}
+```

docs/api/packages/retry.md

@@ -30,7 +30,8 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Document 文档
+
+## 文档
 
 ### <span id="Context">Context</span>
 
@@ -42,7 +43,7 @@ import (
 func Context(ctx context.Context)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
 
 ```go
 import (
@@ -89,7 +90,7 @@ func main() {
 type RetryFunc func() error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 func RetryTimes(n uint)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
 
 ```go
 package main
@@ -178,7 +179,7 @@ func main() {
 func RetryDuration(d time.Duration)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -224,7 +225,7 @@ func main() {
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main

docs/api/packages/slice.md

@@ -77,7 +77,7 @@ import (
 -   [IsSortedByKey](#IsSortedByKey)
 -   [Sort](#Sort)
 -   [SortBy](#SortBy)
--   [SortByField<sup>deprecated</sup>](#SortByField)
+-   [SortByField](#SortByField)
 -   [Some](#Some)
 -   [StringSlice<sup>deprecated</sup>](#StringSlice)
 -   [SymmetricDifference](#SymmetricDifference)
@@ -90,9 +90,12 @@ import (
 -   [UpdateAt](#UpdateAt)
 -   [Without](#Without)
 -   [KeyBy](#KeyBy)
+-   [Join](#Join)
+-   [Partition](#Partition)
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="AppendIfAbsent">AppendIfAbsent</span>
@@ -105,7 +108,7 @@ import (
 func AppendIfAbsent[T comparable](slice []T, item T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 import (
@@ -136,7 +139,7 @@ func main() {
 func Contain[T comparable](slice []T, target T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_454yEHcNjf)</span></b>
 
 ```go
 import (
@@ -167,7 +170,7 @@ func main() {
 func ContainBy[T any](slice []T, predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/49tkHfX4GNc)</span></b>
 
 ```go
 import (
@@ -212,7 +215,7 @@ func main() {
 func ContainSubSlice[T comparable](slice, subSlice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bcuQ3UT6Sev)</span></b>
 
 ```go
 import (
@@ -243,7 +246,7 @@ func main() {
 func Chunk[T any](slice []T, size int) [][]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/b4Pou5j2L_C)</span></b>
 
 ```go
 import (
@@ -285,7 +288,7 @@ func main() {
 func Compact[T comparable](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pO5AnxEr3TK)</span></b>
 
 ```go
 import (
@@ -322,7 +325,7 @@ func main() {
 func Concat[T any](slice []T, slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gPt-q7zr5mk)</span></b>
 
 ```go
 import (
@@ -353,7 +356,7 @@ func main() {
 func Count[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Mj4oiEnQvRJ)</span></b>
 
 ```go
 import (
@@ -386,7 +389,7 @@ func main() {
 func CountBy[T any](slice []T, predicate func(index int, item T) bool) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tHOccTMDZCC)</span></b>
 
 ```go
 import (
@@ -420,7 +423,7 @@ func main() {
 func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/VXvadzLzhDa)</span></b>
 
 ```go
 import (
@@ -451,7 +454,7 @@ func main() {
 func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DiivgwM5OnC)</span></b>
 
 ```go
 import (
@@ -486,7 +489,7 @@ func main() {
 func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/v2U2deugKuV)</span></b>
 
 ```go
 import (
@@ -521,7 +524,7 @@ func main() {
 func DeleteAt[T any](slice []T, start int, end ...int)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pJ-d6MUWcvK)</span></b>
 
 ```go
 import (
@@ -556,7 +559,7 @@ func main() {
 func Drop[T any](slice []T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jnPO2yQsT8H)</span></b>
 
 ```go
 import (
@@ -593,7 +596,7 @@ func main() {
 func DropRight[T any](slice []T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8bcXvywZezG)</span></b>
 
 ```go
 import (
@@ -630,7 +633,7 @@ func main() {
 func DropWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4rt252UV_qs)</span></b>
 
 ```go
 import (
@@ -670,7 +673,7 @@ func main() {
 func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6wyK3zMY56e)</span></b>
 
 ```go
 import (
@@ -712,7 +715,7 @@ func main() {
 func Every[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/R8U6Sl-j8cD)</span></b>
 
 ```go
 import (
@@ -746,7 +749,7 @@ func main() {
 func Equal[T comparable](slice1, slice2 []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WcRQJ37ifPa)</span></b>
 
 ```go
 import (
@@ -781,7 +784,7 @@ func main() {
 func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/b9iygtgsHI1)</span></b>
 
 ```go
 import (
@@ -816,7 +819,7 @@ func main() {
 func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/SdPna-7qK4T)</span></b>
 
 ```go
 import (
@@ -850,7 +853,7 @@ func main() {
 func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CBKeBoHVLgq)</span></b>
 
 ```go
 import (
@@ -886,7 +889,7 @@ func main() {
 func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/n1lysBYl-GB)</span></b>
 
 ```go
 import (
@@ -922,7 +925,7 @@ func main() {
 func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FFDPV_j7URd)</span></b>
 
 ```go
 import (
@@ -958,7 +961,7 @@ func main() {
 func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8iqomzyCl_s)</span></b>
 
 ```go
 import (
@@ -994,7 +997,7 @@ func main() {
 func Flatten(slice any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hYa3cBEevtm)</span></b>
 
 ```go
 import (
@@ -1024,7 +1027,7 @@ func main() {
 func FlattenDeep(slice any) any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/yjYNHPyCFaF)</span></b>
 
 ```go
 import (
@@ -1054,7 +1057,7 @@ func main() {
 func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DrPaa4YsHRF)</span></b>
 
 ```go
 import (
@@ -1089,7 +1092,7 @@ func main() {
 func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qScs39f3D9W)</span></b>
 
 ```go
 import (
@@ -1127,7 +1130,7 @@ func main() {
 func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/QVkPxzPR0iA)</span></b>
 
 ```go
 import (
@@ -1163,7 +1166,7 @@ func main() {
 func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ApCvMNTLO8a)</span></b>
 
 ```go
 import (
@@ -1197,7 +1200,7 @@ func main() {
 func IntSlice(slice any) []int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UQDj-on9TGN)</span></b>
 
 ```go
 import (
@@ -1226,7 +1229,7 @@ func main() {
 func InterfaceSlice(slice any) []any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/FdQXF0Vvqs-)</span></b>
 
 ```go
 import (
@@ -1255,7 +1258,7 @@ func main() {
 func Intersection[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/anJXfB5wq_t)</span></b>
 
 ```go
 import (
@@ -1286,7 +1289,7 @@ func main() {
 func InsertAt[T any](slice []T, index int, value any) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hMLNxPEGJVE)</span></b>
 
 ```go
 import (
@@ -1326,7 +1329,7 @@ func main() {
 func IndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MRN1f0FpABb)</span></b>
 
 ```go
 import (
@@ -1359,7 +1362,7 @@ func main() {
 func LastIndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DokM4cf1IKH)</span></b>
 
 ```go
 import (
@@ -1392,7 +1395,7 @@ func main() {
 func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/biaTefqPquw)</span></b>
 
 ```go
 import (
@@ -1426,7 +1429,7 @@ func main() {
 func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/J94SZ_9MiIe)</span></b>
 
 ```go
 import (
@@ -1463,7 +1466,7 @@ func main() {
 func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_QARWlWs1N_F)</span></b>
 
 ```go
 import (
@@ -1496,7 +1499,7 @@ func main() {
 func Merge[T any](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lbjFp784r9N)</span></b>
 
 ```go
 import (
@@ -1527,7 +1530,7 @@ func main() {
 func Reverse[T any](slice []T)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8uI8f1lwNrQ)</span></b>
 
 ```go
 import (
@@ -1557,7 +1560,7 @@ func main() {
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/_RfXJJWIsIm)</span></b>
 
 ```go
 import (
@@ -1591,7 +1594,7 @@ func main() {
 func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YKDpLi7gtee)</span></b>
 
 ```go
 import (
@@ -1627,7 +1630,7 @@ func main() {
 func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qT9dZC03A1K)</span></b>
 
 ```go
 import (
@@ -1657,7 +1660,7 @@ func main() {
 func Replace[T comparable](slice []T, old T, new T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/P5mZp7IhOFo)</span></b>
 
 ```go
 import (
@@ -1699,7 +1702,7 @@ func main() {
 func ReplaceAll[T comparable](slice []T, old T, new T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CzqXMsuYUrx)</span></b>
 
 ```go
 import (
@@ -1727,7 +1730,7 @@ func main() {
 func Repeat[T any](item T, n int) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -1755,7 +1758,7 @@ func main() {
 func Shuffle[T any](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YHvhnWGU3Ge)</span></b>
 
 ```go
 import (
@@ -1784,7 +1787,7 @@ func main() {
 func IsAscending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9CtsFjet4SH)</span></b>
 
 ```go
 import (
@@ -1818,7 +1821,7 @@ func main() {
 func IsDescending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/U_LljFXma14)</span></b>
 
 ```go
 import (
@@ -1852,7 +1855,7 @@ func main() {
 func IsSorted[T constraints.Ordered](slice []T) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/nCE8wPLwSA-)</span></b>
 
 ```go
 import (
@@ -1886,7 +1889,7 @@ func main() {
 func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tUoGB7DOHI4)</span></b>
 
 ```go
 import (
@@ -1926,7 +1929,7 @@ func main() {
 func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/V9AVjzf_4Fk)</span></b>
 
 ```go
 import (
@@ -1963,7 +1966,7 @@ func main() {
 func SortBy[T any](slice []T, less func(a, b T) bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/DAhLQSZEumm)</span></b>
 
 ```go
 import (
@@ -2000,9 +2003,9 @@ func main() {
 }
 ```
 
-### <span id="SortByField">SortByField (已弃用: 请使用 Sort 或 SortBy 代替该方法)</span>
+### <span id="SortByField">SortByField</span>
 
-<p>按字段对结构切片进行排序。slice元素应为struct，字段类型应为int、uint、string或bool。 默认排序类型是升序（asc），如果是降序，设置 sortType 为 desc</p>
+<p>按字段对结构体切片进行排序。slice元素应为struct，排序字段field类型应为int、uint、string或bool。 默认排序类型是升序（asc），如果是降序，设置 sortType 为 desc</p>
 
 <b>函数签名:</b>
 
@@ -2010,7 +2013,7 @@ func main() {
 func SortByField(slice any, field string, sortType ...string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fU1prOBP9p1)</span></b>
 
 ```go
 import (
@@ -2051,7 +2054,7 @@ func main() {
 func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4pO9Xf9NDGS)</span></b>
 
 ```go
 import (
@@ -2085,7 +2088,7 @@ func main() {
 func StringSlice(slice any) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W0TZDWCPFcI)</span></b>
 
 ```go
 import (
@@ -2114,7 +2117,7 @@ func main() {
 func SymmetricDifference[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -2145,7 +2148,7 @@ func main() {
 func ToSlice[T any](items ...T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/YzbzVq5kscN)</span></b>
 
 ```go
 import (
@@ -2173,7 +2176,7 @@ func main() {
 func ToSlicePointer[T any](items ...T) []*T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gx4tr6_VXSF)</span></b>
 
 ```go
 import (
@@ -2208,7 +2211,7 @@ func main() {
 func Unique[T comparable](slice []T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/AXw0R3ZTE6a)</span></b>
 
 ```go
 import (
@@ -2235,7 +2238,7 @@ func main() {
 func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UR323iZLDpv)</span></b>
 
 ```go
 import (
@@ -2266,7 +2269,7 @@ func main() {
 func Union[T comparable](slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/hfXV1iRIZOf)</span></b>
 
 ```go
 import (
@@ -2297,7 +2300,7 @@ func main() {
 func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HGKHfxKQsFi)</span></b>
 
 ```go
 import (
@@ -2322,7 +2325,7 @@ func main() {
 
 ### <span id="UpdateAt">UpdateAt</span>
 
-<p>更新索引处的切片元素。 如果index < 0或 index >= len(slice)，将返回错误</p>
+<p>更新索引处的切片元素。 如果index &lt 0或 index &lt= len(slice)，将返回错误</p>
 
 <b>函数签名:</b>
 
@@ -2330,7 +2333,7 @@ func main() {
 func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/f3mh2KloWVm)</span></b>
 
 ```go
 import (
@@ -2370,7 +2373,7 @@ func main() {
 func Without[T comparable](slice []T, items ...T) []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bwhEXEypThg)</span></b>
 
 ```go
 import (
@@ -2390,7 +2393,7 @@ func main() {
 
 ### <span id="KeyBy">KeyBy</span>
 
-<p>将切片每个元素调用函数后转为map</p>
+<p>将切片每个元素调用函数后转为map。</p>
 
 <b>函数签名:</b>
 
@@ -2398,7 +2401,7 @@ func main() {
 func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/uXod2LWD1Kg)</span></b>
 
 ```go
 import (
@@ -2417,3 +2420,103 @@ func main() {
     // map[1:a 2:ab 3:abc]
 }
 ```
+
+### <span id="Join">Join</span>
+
+<p>用指定的分隔符链接切片元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func Join[T any](s []T, separator string) string
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/huKzqwNDD7V)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    result1 := slice.Join(nums, ",")
+    result2 := slice.Join(nums, "-")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 1,2,3,4,5
+    // 1-2-3-4-5
+}
+```
+
+### <span id="Partition">Partition</span>
+
+<p>根据给定的predicate判断函数分组切片元素。</p>
+
+<b>函数签名:</b>
+
+```go
+func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/lkQ3Ri2NQhV)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	result1 := slice.Partition(nums)
+	result2 := slice.Partition(nums, func(n int) bool { return n%2 == 0 })
+	result3 := slice.Partition(nums, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [[1 2 3 4 5]]
+	// [[2 4] [1 3 5]]
+	// [[1 2] [3 4] [5]]
+}
+```
+
+
+### <span id="Random">Random</span>
+
+<p>随机返回切片中元素以及下标, 当切片长度为0时返回下标-1</p>
+
+<b>函数签名:</b>
+
+```go
+func Random[T any](slice []T) (val T, idx int)
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](TODO)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	val, idx := slice.Random(nums)
+	if idx >= 0 && idx < len(nums) && slice.Contain(nums, val) {
+		fmt.Println("okk")
+	}
+	// Output:
+	// okk
+}
+```

docs/api/packages/stream.md

@@ -63,7 +63,7 @@ import (
 func Of[T any](elems ...T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (
@@ -93,7 +93,7 @@ func main() {
 func FromSlice[T any](source []T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/wywTO0XZtI4)</span></b>
 
 ```go
 import (
@@ -123,7 +123,7 @@ func main() {
 func FromChannel[T any](source <-chan T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9TZYugGMhXZ)</span></b>
 
 ```go
 import (
@@ -161,7 +161,7 @@ func main() {
 func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9Ex1-zcg-B-)</span></b>
 
 ```go
 import (
@@ -190,7 +190,7 @@ func main() {
 func Generate[T any](generator func() func() (item T, ok bool)) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/rkOWL1yA3j9)</span></b>
 
 ```go
 import (
@@ -230,7 +230,7 @@ func main() {
 func Concat[T any](a, b stream[T]) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HM4OlYk_OUC)</span></b>
 
 ```go
 import (
@@ -263,7 +263,7 @@ func main() {
 func (s stream[T]) Distinct() stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/eGkOSrm64cB)</span></b>
 
 ```go
 import (
@@ -297,7 +297,7 @@ func main() {
 func (s stream[T]) Filter(predicate func(item T) bool) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/MFlSANo-buc)</span></b>
 
 ```go
 import (
@@ -331,7 +331,7 @@ func main() {
 func (s stream[T]) Map(mapper func(item T) T) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OtNQUImdYko)</span></b>
 
 ```go
 import (
@@ -365,7 +365,7 @@ func main() {
 func (s stream[T]) Peek(consumer func(item T)) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/u1VNzHs6cb2)</span></b>
 
 ```go
 import (
@@ -402,7 +402,7 @@ func main() {
 func (s stream[T]) Skip(n int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fNdHbqjahum)</span></b>
 
 ```go
 import (
@@ -441,7 +441,7 @@ func main() {
 func (s stream[T]) Limit(maxSize int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qsO4aniDcGf)</span></b>
 
 ```go
 import (
@@ -480,7 +480,7 @@ func main() {
 func (s stream[T]) Reverse() stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/A8_zkJnLHm4)</span></b>
 
 ```go
 import (
@@ -510,7 +510,7 @@ func main() {
 func (s stream[T]) Range(start, end int) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/indZY5V2f4j)</span></b>
 
 ```go
 import (
@@ -549,7 +549,7 @@ func main() {
 func (s stream[T]) Sorted(less func(a, b T) bool) stream[T]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/XXtng5uonFj)</span></b>
 
 ```go
 import (
@@ -581,7 +581,7 @@ func main() {
 func (s stream[T]) ForEach(action func(item T))
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Dsm0fPqcidk)</span></b>
 
 ```go
 import (
@@ -614,7 +614,7 @@ func main() {
 func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6uzZjq_DJLU)</span></b>
 
 ```go
 import (
@@ -646,7 +646,7 @@ func main() {
 func (s stream[T]) FindFirst() (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9xEf0-6C1e3)</span></b>
 
 ```go
 import (
@@ -678,7 +678,7 @@ func main() {
 func (s stream[T]) FindLast() (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/WZD2rDAW-2h)</span></b>
 
 ```go
 import (
@@ -710,7 +710,7 @@ func main() {
 func (s stream[T]) Max(less func(a, b T) bool) (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/fm-1KOPtGzn)</span></b>
 
 ```go
 import (
@@ -734,7 +734,7 @@ func main() {
 
 ### <span id="Min">Min</span>
 
-<p>根据提供的less函数返回stream的最小元素。less函数: a < b</p>
+<p>根据提供的less函数返回stream的最小元素。less函数: a &lt b</p>
 
 <b>函数签名:</b>
 
@@ -742,7 +742,7 @@ func main() {
 func (s stream[T]) Min(less func(a, b T) bool) (T, bool)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vZfIDgGNRe_0)</span></b>
 
 ```go
 import (
@@ -774,7 +774,7 @@ func main() {
 func (s stream[T]) AllMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/V5TBpVRs-Cx)</span></b>
 
 ```go
 import (
@@ -812,7 +812,7 @@ func main() {
 func (s stream[T]) AnyMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/PTCnWn4OxSn)</span></b>
 
 ```go
 import (
@@ -850,7 +850,7 @@ func main() {
 func (s stream[T]) NoneMatch(predicate func(item T) bool) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/iWS64pL1oo3)</span></b>
 
 ```go
 import (
@@ -888,7 +888,7 @@ func main() {
 func (s stream[T]) Count() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/r3koY6y_Xo-)</span></b>
 
 ```go
 import (
@@ -919,7 +919,7 @@ func main() {
 func (s stream[T]) ToSlice() []T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (

docs/api/packages/struct.md

@@ -1,11 +1,13 @@
-# Field
+# Structs
 
-Field 包封装了一个抽象的`Field`结构体，提供了操作`struct`属性的相关函数
+structs 包封装了一个抽象的`Struct`结构体，提供了操作`struct`的相关函数
 
 <div STYLE="page-break-after: always;"></div>
 
 ## 源码:
 
+-   [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go)
+
 -   [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go)
 
 <div STYLE="page-break-after: always;"></div>
@@ -21,6 +23,12 @@ import (
 <div STYLE="page-break-after: always;"></div>
 
 ## 目录:
+
+-   [New](#New)
+-   [ToMap](#ToMap)
+-   [Fields](#Fields)
+-   [Field](#Field)
+-   [IsStruct](#IsStruct)
 -   [Tag](#Tag)
 -   [Name](#Name)
 -   [Value](#Value)
@@ -30,17 +38,190 @@ import (
 -   [IsZero](#IsZero)
 -   [IsSlice](#IsSlice)
 
-> 注意：由于`Field`继承于`Struct`，所以同样拥有`Struct`所有方法，如下：
-
--   [ToMap](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#ToMap)
--   [Fields](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Fields)
--   [Field](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#Field)
--   [IsStruct](https://github.com/duke-git/lancet/blob/main/docs/structs/struct_zh-CN.md#IsStruct)
-
 <div STYLE="page-break-after: always;"></div>
 
 ## API 文档:
 
+### <span id="New">New</span>
+
+<p>`Struct`结构体的构造函数</p>
+
+<b>函数签名:</b>
+
+```go
+func New(value any, tagName ...string) *Struct
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    // to do something
+}
+```
+
+### <span id="ToMap">ToMap</span>
+
+<p>将一个合法的struct对象转换为map[string]any</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) ToMap() (map[string]any, error)
+```
+
+<b>除此之外，提供一个便捷的静态方法 ToMap</b>
+
+```go
+func ToMap(v any) (map[string]any, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s1 := structs.New(p1)
+    m1, _ := s1.ToMap()
+
+    fmt.Println(m1)
+
+    // 如果不需要Struct更多的方法，可以直接使用ToMap
+    m2, _ := structs.ToMap(p1)
+
+    fmt.Println(m2)
+
+    // Output:
+    // map[name:11]
+    // map[name:11]
+}
+```
+
+### <span id="Fields">Fields</span>
+
+<p>获取一个struct对象的属性列表</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Fields() []*Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    fields := s.Fields()
+
+    fmt.Println(len(fields))
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="Field">Field</span>
+
+<p>根据属性名获取一个struct对象的属性</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) Field(name string) *Field
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    f := s.Field("Name")
+
+    fmt.Println(f.Value())
+
+    // Output:
+    // 11
+}
+```
+
+### <span id="IsStruct">IsStruct</span>
+
+<p>判断是否为一个合法的struct对象</p>
+
+<b>函数签名:</b>
+
+```go
+func (s *Struct) IsStruct() bool
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+
+    fmt.Println(s.IsStruct())
+
+    // Output:
+    // true
+}
+```
+
 ### <span id="Tag">Tag</span>
 
 <p>获取`Field`的`Tag`，默认的tag key是json</p>

docs/api/packages/strutil.md

@@ -49,6 +49,7 @@ import (
 -   [StringToBytes](#StringToBytes)
 -   [BytesToString](#BytesToString)
 -   [IsBlank](#IsBlank)
+-   [IsNotBlank](#IsNotBlank)
 -   [HasPrefixAny](#HasPrefixAny)
 -   [HasSuffixAny](#HasSuffixAny)
 -   [IndexOffset](#IndexOffset)
@@ -62,7 +63,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
-## Documentation 文档
+## 文档
 
 ### <span id="After">After</span>
 
@@ -74,7 +75,7 @@ import (
 func After(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/RbCOQqCDA7m)</span></b>
 
 ```go
 import (
@@ -114,7 +115,7 @@ func main() {
 func AfterLast(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/1TegARrb8Yn)</span></b>
 
 ```go
 import (
@@ -154,7 +155,7 @@ func main() {
 func Before(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/JAWTZDS4F5w)</span></b>
 
 ```go
 import (
@@ -191,7 +192,7 @@ func main() {
 func BeforeLast(s, char string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pJfXXAoG_Te)</span></b>
 
 ```go
 import (
@@ -228,7 +229,7 @@ func main() {
 func CamelCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9eXP3tn2tUy)</span></b>
 
 ```go
 import (
@@ -263,7 +264,7 @@ func main() {
 func KebabCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dcZM9Oahw-Y)</span></b>
 
 ```go
 import (
@@ -298,7 +299,7 @@ func main() {
 func UpperKebabCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/zDyKNneyQXk)</span></b>
 
 ```go
 import (
@@ -333,7 +334,7 @@ func main() {
 func Capitalize(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/2OAjgbmAqHZ)</span></b>
 
 ```go
 import (
@@ -368,7 +369,7 @@ func main() {
 func IsString(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/IOgq7oF9ERm)</span></b>
 
 ```go
 import (
@@ -408,7 +409,7 @@ func main() {
 func LowerFirst(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/CbzAyZmtJwL)</span></b>
 
 ```go
 import (
@@ -442,7 +443,7 @@ func main() {
 func UpperFirst(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sBbBxRbs8MM)</span></b>
 
 ```go
 import (
@@ -476,7 +477,7 @@ func main() {
 func Pad(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/NzImQq-VF8q)</span></b>
 
 ```go
 import (
@@ -521,7 +522,7 @@ func main() {
 func PadEnd(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/9xP8rN0vz--)</span></b>
 
 ```go
 import (
@@ -567,7 +568,7 @@ func main() {
 func PadStart(source string, size int, padStr string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/xpTfzArDfvT)</span></b>
 
 ```go
 import (
@@ -613,7 +614,7 @@ func main() {
 func Reverse(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/adfwalJiecD)</span></b>
 
 ```go
 import (
@@ -644,7 +645,7 @@ func main() {
 func SnakeCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/tgzQG11qBuN)</span></b>
 
 ```go
 import (
@@ -676,10 +677,10 @@ func main() {
 <b>函数签名:</b>
 
 ```go
-func SnakeCase(s string) string
+func UpperSnakeCase(s string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/4COPHpnLx38)</span></b>
 
 ```go
 import (
@@ -714,7 +715,7 @@ func main() {
 func SplitEx(s, sep string, removeEmptyString bool) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Us-ySSbWh-3)</span></b>
 
 ```go
 import (
@@ -755,7 +756,7 @@ func main() {
 func Substring(s string, offset int, length uint) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/q3sM6ehnPDp)</span></b>
 
 ```go
 import (
@@ -798,7 +799,7 @@ func main() {
 func Wrap(str string, wrapWith string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KoZOlZDDt9y)</span></b>
 
 ```go
 import (
@@ -825,7 +826,7 @@ func main() {
 }
 ```
 
-### <span id="Wrap">Wrap</span>
+### <span id="Unwrap">Unwrap</span>
 
 <p>用另一个字符串解开包裹一个字符串。</p>
 
@@ -835,7 +836,7 @@ func main() {
 func Unwrap(str string, wrapToken string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Ec2q4BzCpG-)</span></b>
 
 ```go
 import (
@@ -875,7 +876,7 @@ func main() {
 func SplitWords(s string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KLiX4WiysMM)</span></b>
 
 ```go
 import (
@@ -918,7 +919,7 @@ func main() {
 func WordCount(s string) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/bj7_odx3vRf)</span></b>
 
 ```go
 import (
@@ -961,7 +962,7 @@ func main() {
 func RemoveNonPrintable(str string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/og47F5x_jTZ)</span></b>
 
 ```go
 import (
@@ -992,7 +993,7 @@ func main() {
 func StringToBytes(str string) (b []byte)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/7OyFBrf9AxA)</span></b>
 
 ```go
 import (
@@ -1022,7 +1023,7 @@ func main() {
 func BytesToString(bytes []byte) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6c68HRvJecH)</span></b>
 
 ```go
 import (
@@ -1051,7 +1052,7 @@ func main() {
 func IsBlank(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/6zXRH_c0Qd3)</span></b>
 
 ```go
 import (
@@ -1075,6 +1076,45 @@ func main() {
 }
 ```
 
+### <span id="IsNotBlank">IsNotBlank</span>
+
+<p>Checks if a string is not whitespace or not empty.</p>
+
+<b>函数签名:</b>
+
+```go
+func IsNotBlank(str string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/e_oJW0RAquA)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.IsNotBlank("")
+    result2 := strutil.IsNotBlank("	")
+    result3 := strutil.IsNotBlank("\t\v\f\n")
+    result4 := strutil.IsNotBlank(" 中文")
+    result5 := strutil.IsNotBlank(" 	world	")
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    // Output:
+    // false
+    // false
+    // false
+    // true
+    // true
+}
+```
+
 ### <span id="HasPrefixAny">HasPrefixAny</span>
 
 <p>检查字符串是否以指定字符串数组中的任何一个开头。</p>
@@ -1085,7 +1125,7 @@ func main() {
 func HasPrefixAny(str string, prefixes []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/8UUTl2C5slo)</span></b>
 
 ```go
 import (
@@ -1116,7 +1156,7 @@ func main() {
 func HasSuffixAny(str string, suffixes []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/sKWpCQdOVkx)</span></b>
 
 ```go
 import (
@@ -1147,7 +1187,7 @@ func main() {
 func IndexOffset(str string, substr string, idxFrom int) int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/qZo4lV2fomB)</span></b>
 
 ```go
 import (
@@ -1189,7 +1229,7 @@ func main() {
 func ReplaceWithMap(str string, replaces map[string]string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/h3t7CNj2Vvu)</span></b>
 
 ```go
 import (
@@ -1222,7 +1262,7 @@ func main() {
 func Trim(str string, characterMask ...string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/Y0ilP0NRV3j)</span></b>
 
 ```go
 import (
@@ -1259,7 +1299,7 @@ func main() {
 func SplitAndTrim(str, delimiter string, characterMask ...string) []string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ZNL6o4SkYQ7)</span></b>
 
 ```go
 import (
@@ -1292,7 +1332,7 @@ func main() {
 func HideString(origin string, start, end int, replaceChar string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/pzbaIVCTreZ)</span></b>
 
 ```go
 import (
@@ -1331,7 +1371,7 @@ func main() {
 func ContainsAll(str string, substrs []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/KECtK2Os4zq)</span></b>
 
 ```go
 import (
@@ -1364,7 +1404,7 @@ func main() {
 func ContainsAny(str string, substrs []string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/dZGSSMB3LXE)</span></b>
 
 ```go
 import (
@@ -1400,7 +1440,7 @@ func main() {
 func RemoveWhiteSpace(str string, repalceAll bool) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/HzLC9vsTwkf)</span></b>
 
 ```go
 import (

docs/api/packages/system.md

@@ -46,7 +46,7 @@ import (
 func IsWindows() bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 import (
@@ -64,7 +64,7 @@ func main() {
 
 <p>检查当前操作系统是否是linux</p>
 
-<b>函数签名:</b>
+<b>函数签名:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 func IsLinux() bool
@@ -94,7 +94,7 @@ func main() {
 func IsMac() bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Mg4Hjtyq7Zc)</span></b>
 
 ```go
 import (
@@ -118,7 +118,7 @@ func main() {
 func GetOsEnv(key string) string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -148,7 +148,7 @@ func main() {
 func SetOsEnv(key, value string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -178,7 +178,7 @@ func main() {
 func RemoveOsEnv(key string) error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/fqyq4b3xUFQ)</span></b>
 
 ```go
 import (
@@ -216,7 +216,7 @@ func main() {
 func CompareOsEnv(key, comparedEnv string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/BciHrKYOHbp)</span></b>
 
 ```go
 import (
@@ -252,7 +252,7 @@ type (
 func ExecCommand(command string, opts ...Option) (stdout, stderr string, err error)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/n-2fLyZef-4)</span></b>
 
 ```go
 import (
@@ -292,7 +292,7 @@ func main() {
 func GetOsBits() int
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ml-_XH3gJbW)</span></b>
 
 ```go
 import (

docs/api/packages/tuple.md

@@ -61,6 +61,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="Tuple2">Tuple2</span>
@@ -78,7 +79,7 @@ type Tuple2[A any, B any] struct {
 func NewTuple2[A any, B any](a A, b B) Tuple2[A, B]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/3sHVqBQpLYN)</span></b>
 
 ```go
 package main
@@ -106,7 +107,7 @@ func main() {
 func (t Tuple2[A, B]) Unbox() (A, B)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/0fD1qfCVwjm)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 func Zip2[A any, B any](a []A, b []B) []Tuple2[A, B]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/4ncWJJ77Xio)</span></b>
 
 ```go
 package main
@@ -163,7 +164,7 @@ func main() {
 func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/KBecr60feXb)</span></b>
 
 ```go
 package main
@@ -198,7 +199,7 @@ type Tuple3[A any, B any, C any] struct {
 func NewTuple3[A any, B any, C any](a A, b B c C) Tuple3[A, B, C]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FtH2sdCLlCf)</span></b>
 
 ```go
 package main
@@ -226,7 +227,7 @@ func main() {
 func (t Tuple3[A, B, C]) Unbox() (A, B, C)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YojLy-id1BS)</span></b>
 
 ```go
 package main
@@ -239,7 +240,7 @@ import (
 func main() {
     t := tuple.NewTuple2(1, 0.1, "a")
     v1, v2, v3 := t.Unbox()
-    fmt.Printf("%v %v %v", t.FieldA, t.FieldB, t.FieldC)
+    fmt.Printf("%v %v %v", v1, v2, v3)
 
     // Output: 1 0.1 a
 }
@@ -255,7 +256,7 @@ func main() {
 func Zip3[A any, B any, C any](a []A, b []B, c []C) []Tuple3[A, B, C]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/97NgmsTILfu)</span></b>
 
 ```go
 package main
@@ -283,7 +284,7 @@ func main() {
 func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/bba4cpAa7KO)</span></b>
 
 ```go
 package main
@@ -321,7 +322,7 @@ type Tuple4[A any, B any, C any, D any] struct {
 func NewTuple4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/D2EqDz096tk)</span></b>
 
 ```go
 package main
@@ -349,7 +350,7 @@ func main() {
 func (t Tuple4[A, B, C, D]) Unbox() (A, B, C, D)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ACj9YuACGgW)</span></b>
 
 ```go
 package main
@@ -378,7 +379,7 @@ func main() {
 func Zip4[A any, B any, C any, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/PEmTYVK5hL4)</span></b>
 
 ```go
 package main
@@ -406,7 +407,7 @@ func main() {
 func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/rb8z4gyYSRN)</span></b>
 
 ```go
 package main
@@ -445,7 +446,7 @@ type Tuple5[A any, B any, C any, D any, E any] struct {
 func NewTuple5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/2WndmVxPg-r)</span></b>
 
 ```go
 package main
@@ -473,7 +474,7 @@ func main() {
 func (t Tuple5[A, B, C, D, E]) Unbox() (A, B, C, D, E)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GyIyZHjCvoS)</span></b>
 
 ```go
 package main
@@ -502,7 +503,7 @@ func main() {
 func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/fCAAJLMfBIP)</span></b>
 
 ```go
 package main
@@ -530,7 +531,7 @@ func main() {
 func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/gyl6vKfhqPb)</span></b>
 
 ```go
 package main
@@ -570,7 +571,7 @@ type Tuple6[A any, B any, C any, D any, E any, F any] struct {
 func NewTuple6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/VjqcCwEJZbs)</span></b>
 
 ```go
 package main
@@ -598,7 +599,7 @@ func main() {
 func (t Tuple6[A, B, C, D, E, F]) Unbox() (A, B, C, D, E, F)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FjIHV7lpxmW)</span></b>
 
 ```go
 package main
@@ -627,7 +628,7 @@ func main() {
 func Zip6[A any, B any, C any, D any, E any, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/oWPrnUYuFHo)</span></b>
 
 ```go
 package main
@@ -655,7 +656,7 @@ func main() {
 func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/l41XFqCyh5E)</span></b>
 
 ```go
 package main
@@ -696,7 +697,7 @@ type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
 func NewTuple7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/dzAgv_Ezub9)</span></b>
 
 ```go
 package main
@@ -724,7 +725,7 @@ func main() {
 func (t Tuple7[A, B, C, D, E, F, G]) Unbox() (A, B, C, D, E, F, G)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/R9I8qeDk0zs)</span></b>
 
 ```go
 package main
@@ -753,7 +754,7 @@ func main() {
 func Zip7[A any, B any, C any, D any, E any, F any, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/WUJuo897Egf)</span></b>
 
 ```go
 package main
@@ -781,7 +782,7 @@ func main() {
 func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/hws_P1Fr2j3)</span></b>
 
 ```go
 package main
@@ -823,7 +824,7 @@ type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
 func NewTuple8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YA9S0rz3dRz)</span></b>
 
 ```go
 package main
@@ -851,7 +852,7 @@ func main() {
 func (t Tuple8[A, B, C, D, E, F, G, H]) Unbox() (A, B, C, D, E, F, G, H)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/PRxLBBb4SMl)</span></b>
 
 ```go
 package main
@@ -880,7 +881,7 @@ func main() {
 func Zip8[A any, B any, C any, D any, E any, F any, G any, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/8V9jWkuJfaQ)</span></b>
 
 ```go
 package main
@@ -908,7 +909,7 @@ func main() {
 func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/1SndOwGsZB4)</span></b>
 
 ```go
 package main
@@ -953,7 +954,7 @@ func NewTuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/yS2NGGtZpQr)</span></b>
 
 ```go
 package main
@@ -981,7 +982,7 @@ func main() {
 func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unbox() (A, B, C, D, E, F, G, H, I)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/oFJFGTAuOa8)</span></b>
 
 ```go
 package main
@@ -1010,7 +1011,7 @@ func main() {
 func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/cgsL15QYnfz)</span></b>
 
 ```go
 package main
@@ -1038,7 +1039,7 @@ func main() {
 func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/91-BU_KURSA)</span></b>
 
 ```go
 package main
@@ -1084,7 +1085,7 @@ func NewTuple10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J
 
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/799qqZg0hUv)</span></b>
 
 ```go
 package main
@@ -1115,7 +1116,7 @@ func main() {
 func (t Tuple10[A, B, C, D, E, F, G, H, I, J]) Unbox() (A, B, C, D, E, F, G, H, I, J)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/qfyx3x_X0Cu)</span></b>
 
 ```go
 package main
@@ -1134,8 +1135,6 @@ func main() {
     fmt.Printf("%v %v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
 
     // Output: 1 0.1 a true 2 2.2 b c map[a:1] {a}
-
-    // Output: 1 0.1 a true 2 2.2 b c map[a:1]
 }
 ```
 
@@ -1149,7 +1148,7 @@ func main() {
 func Zip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, j []J) []Tuple10[A, B, C, D, E, F, G, H, I, J]
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/YSR-2cXnrY4)</span></b>
 
 ```go
 package main
@@ -1177,7 +1176,7 @@ func main() {
 func Unzip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](tuples []Tuple10[A, B, C, D, E, F, G, H, I, J]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, []J)
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/-taQB6Wfre_z)</span></b>
 
 ```go
 package main

docs/api/packages/validator.md

@@ -55,6 +55,15 @@ import (
 -   [IsZeroValue](#IsZeroValue)
 -   [IsGBK](#IsGBK)
 -   [IsPrintable](#IsPrintable)
+-   [IsBin](#IsBin)
+-   [IsHex](#IsHex)
+-   [IsBase64URL](#IsBase64URL)
+-   [IsJWT](#IsJWT)
+-   [IsVisa](#IsVisa)
+-   [IsMasterCard](#IsMasterCard)
+-   [IsAmericanExpress](#IsAmericanExpress)
+-   [IsUnionPay](#IsUnionPay)
+-   [IsChinaUnionPay](#IsChinaUnionPay)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +71,7 @@ import (
 
 ### <span id="ContainChinese">ContainChinese</span>
 
-<p>验证字符串是否包含中文字符</p>
+<p>验证字符串是否包含中文字符。</p>
 
 <b>函数签名:</b>
 
@@ -70,7 +79,7 @@ import (
 func ContainChinese(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/7DpU0uElYeM)</span></b>
 
 ```go
 import (
@@ -96,7 +105,7 @@ func main() {
 
 ### <span id="ContainLetter">ContainLetter</span>
 
-<p>验证字符串是否包含至少一个英文字母</p>
+<p>验证字符串是否包含至少一个英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -104,7 +113,7 @@ func main() {
 func ContainLetter(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/lqFD04Yyewp)</span></b>
 
 ```go
 import (
@@ -130,7 +139,7 @@ func main() {
 
 ### <span id="ContainLower">ContainLower</span>
 
-<p>验证字符串是否包含至少一个英文小写字母</p>
+<p>验证字符串是否包含至少一个英文小写字母。</p>
 
 <b>函数签名:</b>
 
@@ -138,7 +147,7 @@ func main() {
 func ContainLower(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Srqi1ItvnAA)</span></b>
 
 ```go
 import (
@@ -164,7 +173,7 @@ func main() {
 
 ### <span id="ContainUpper">ContainUpper</span>
 
-<p>验证字符串是否包含至少一个英文大写字母.</p>
+<p>验证字符串是否包含至少一个英文大写字母。</p>
 
 <b>函数签名:</b>
 
@@ -172,7 +181,7 @@ func main() {
 func ContainUpper(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CmWeBEk27-z)</span></b>
 
 ```go
 import (
@@ -198,7 +207,7 @@ func main() {
 
 ### <span id="IsAlpha">IsAlpha</span>
 
-<p>验证字符串是否只包含英文字母</p>
+<p>验证字符串是否只包含英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -206,7 +215,7 @@ func main() {
 func IsAlpha(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/7Q5sGOz2izQ)</span></b>
 
 ```go
 import (
@@ -232,7 +241,7 @@ func main() {
 
 ### <span id="IsAllUpper">IsAllUpper</span>
 
-<p>验证字符串是否全是大写英文字母</p>
+<p>验证字符串是否全是大写英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -240,7 +249,7 @@ func main() {
 func IsAllUpper(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ZHctgeK1n4Z)</span></b>
 
 ```go
 import (
@@ -266,7 +275,7 @@ func main() {
 
 ### <span id="IsAllLower">IsAllLower</span>
 
-<p>验证字符串是否全是小写英文字母</p>
+<p>验证字符串是否全是小写英文字母。</p>
 
 <b>函数签名:</b>
 
@@ -274,7 +283,7 @@ func main() {
 func IsAllLower(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GjqCnOfV6cM)</span></b>
 
 ```go
 import (
@@ -308,7 +317,7 @@ func main() {
 func IsASCII(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/hfQNPLX0jNa)</span></b>
 
 ```go
 import (
@@ -340,7 +349,7 @@ func main() {
 
 ### <span id="IsBase64">IsBase64</span>
 
-<p>验证字符串是否是base64编码</p>
+<p>验证字符串是否是base64编码。</p>
 
 <b>函数签名:</b>
 
@@ -348,7 +357,7 @@ func main() {
 func IsBase64(base64 string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/sWHEySAt6hl)</span></b>
 
 ```go
 import (
@@ -371,7 +380,7 @@ func main() {
 
 ### <span id="IsChineseMobile">IsChineseMobile</span>
 
-<p>验证字符串是否是中国手机号码</p>
+<p>验证字符串是否是中国手机号码。</p>
 
 <b>函数签名:</b>
 
@@ -379,7 +388,7 @@ func main() {
 func IsChineseMobile(mobileNum string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/GPYUlGTOqe3)</span></b>
 
 ```go
 import (
@@ -402,7 +411,7 @@ func main() {
 
 ### <span id="IsChineseIdNum">IsChineseIdNum</span>
 
-<p>验证字符串是否是中国身份证号码</p>
+<p>验证字符串是否是中国身份证号码。</p>
 
 <b>函数签名:</b>
 
@@ -410,7 +419,7 @@ func main() {
 func IsChineseIdNum(id string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/d8EWhl2UGDF)</span></b>
 
 ```go
 import (
@@ -433,7 +442,7 @@ func main() {
 
 ### <span id="IsChinesePhone">IsChinesePhone</span>
 
-<p>验证字符串是否是中国电话座机号码</p>
+<p>验证字符串是否是中国电话座机号码。</p>
 
 <b>函数签名:</b>
 
@@ -441,7 +450,7 @@ func main() {
 func IsChinesePhone(phone string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/RUD_-7YZJ3I)</span></b>
 
 ```go
 import (
@@ -464,7 +473,7 @@ func main() {
 
 ### <span id="IsCreditCard">IsCreditCard</span>
 
-<p>验证字符串是否是信用卡号码</p>
+<p>验证字符串是否是信用卡号码。</p>
 
 <b>函数签名:</b>
 
@@ -472,7 +481,7 @@ func main() {
 func IsCreditCard(creditCart string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/sNwwL6B0-v4)</span></b>
 
 ```go
 import (
@@ -495,7 +504,7 @@ func main() {
 
 ### <span id="IsDns">IsDns</span>
 
-<p>验证字符串是否是有效dns</p>
+<p>验证字符串是否是有效dns。</p>
 
 <b>函数签名:</b>
 
@@ -503,7 +512,7 @@ func main() {
 func IsDns(dns string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/jlYApVLLGTZ)</span></b>
 
 ```go
 import (
@@ -529,7 +538,7 @@ func main() {
 
 ### <span id="IsEmail">IsEmail</span>
 
-<p>验证字符串是否是有效电子邮件地址</p>
+<p>验证字符串是否是有效电子邮件地址。</p>
 
 <b>函数签名:</b>
 
@@ -537,7 +546,7 @@ func main() {
 func IsEmail(email string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Os9VaFlT33G)</span></b>
 
 ```go
 import (
@@ -560,7 +569,7 @@ func main() {
 
 ### <span id="IsEmptyString">IsEmptyString</span>
 
-<p>验证字符串是否是空字符串</p>
+<p>验证字符串是否是空字符串。</p>
 
 <b>函数签名:</b>
 
@@ -568,7 +577,7 @@ func main() {
 func IsEmptyString(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/dpzgUjFnBCX)</span></b>
 
 ```go
 import (
@@ -602,7 +611,7 @@ func main() {
 func IsInt(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/eFoIHbgzl-z)</span></b>
 
 ```go
 import (
@@ -631,7 +640,7 @@ func main() {
 
 ### <span id="IsFloat">IsFloat</span>
 
-<p>验证参数是否是浮点数((float32, float34)。</p>
+<p>验证参数是否是浮点数(float32, float34)。</p>
 
 <b>函数签名:</b>
 
@@ -639,7 +648,7 @@ func main() {
 func IsFloat(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/vsyG-sxr99_Z)</span></b>
 
 ```go
 import (
@@ -668,7 +677,7 @@ func main() {
 
 ### <span id="IsNumber">IsNumber</span>
 
-<p>验证参数是否是数字(integer or float)</p>
+<p>验证参数是否是数字(integer or float)。</p>
 
 <b>函数签名:</b>
 
@@ -676,7 +685,7 @@ func main() {
 func IsNumber(v any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/mdJHOAvtsvF)</span></b>
 
 ```go
 import (
@@ -703,10 +712,9 @@ func main() {
 }
 ```
 
-
 ### <span id="IsIntStr">IsIntStr</span>
 
-<p>验证字符串是否是可以转换为整数</p>
+<p>验证字符串是否是可以转换为整数。</p>
 
 <b>函数签名:</b>
 
@@ -714,7 +722,7 @@ func main() {
 func IsIntStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/jQRtFv-a0Rk)</span></b>
 
 ```go
 import (
@@ -743,7 +751,7 @@ func main() {
 
 ### <span id="IsFloatStr">IsFloatStr</span>
 
-<p>验证字符串是否是可以转换为浮点数</p>
+<p>验证字符串是否是可以转换为浮点数。</p>
 
 <b>函数签名:</b>
 
@@ -751,7 +759,7 @@ func main() {
 func IsFloatStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LOYwS_Oyl7U)</span></b>
 
 ```go
 import (
@@ -780,7 +788,7 @@ func main() {
 
 ### <span id="IsNumberStr">IsNumberStr</span>
 
-<p>验证字符串是否是可以转换为数字</p>
+<p>验证字符串是否是可以转换为数字。</p>
 
 <b>函数签名:</b>
 
@@ -788,7 +796,7 @@ func main() {
 func IsNumberStr(s string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LzaKocSV79u)</span></b>
 
 ```go
 import (
@@ -817,7 +825,7 @@ func main() {
 
 ### <span id="IsJSON">IsJSON</span>
 
-<p>验证字符串是否是有效json</p>
+<p>验证字符串是否是有效json。</p>
 
 <b>函数签名:</b>
 
@@ -825,7 +833,7 @@ func main() {
 func IsJSON(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/8Kip1Itjiil)</span></b>
 
 ```go
 import (
@@ -854,7 +862,7 @@ func main() {
 
 ### <span id="IsRegexMatch">IsRegexMatch</span>
 
-<p>验证字符串是否可以匹配正则表达式</p>
+<p>验证字符串是否可以匹配正则表达式。</p>
 
 <b>函数签名:</b>
 
@@ -862,7 +870,7 @@ func main() {
 func IsRegexMatch(s, regex string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/z_XeZo_litG)</span></b>
 
 ```go
 import (
@@ -883,11 +891,9 @@ func main() {
 }
 ```
 
-
-
 ### <span id="IsIp">IsIp</span>
 
-<p>验证字符串是否是ip地址</p>
+<p>验证字符串是否是ip地址。</p>
 
 <b>函数签名:</b>
 
@@ -895,7 +901,7 @@ func main() {
 func IsIp(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/FgcplDvmxoD)</span></b>
 
 ```go
 import (
@@ -924,7 +930,7 @@ func main() {
 
 ### <span id="IsIpV4">IsIpV4</span>
 
-<p>验证字符串是否是ipv4地址</p>
+<p>验证字符串是否是ipv4地址。</p>
 
 <b>函数签名:</b>
 
@@ -932,7 +938,7 @@ func main() {
 func IsIpV4(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/zBGT99EjaIu)</span></b>
 
 ```go
 import (
@@ -955,7 +961,7 @@ func main() {
 
 ### <span id="IsIpV6">IsIpV6</span>
 
-<p>验证字符串是否是ipv6地址</p>
+<p>验证字符串是否是ipv6地址。</p>
 
 <b>函数签名:</b>
 
@@ -963,7 +969,7 @@ func main() {
 func IsIpV6(ipstr string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/AHA0r0AzIdC)</span></b>
 
 ```go
 import (
@@ -986,7 +992,7 @@ func main() {
 
 ### <span id="IsStrongPassword">IsStrongPassword</span>
 
-<p>验证字符串是否是强密码：(alpha(lower+upper) + number + special chars(!@#$%^&*()?><))</p>
+<p>验证字符串是否是强密码：(alpha(lower+upper) + number + special chars(!@#$%^&*()?&gt&lt))。</p>
 
 <b>函数签名:</b>
 
@@ -994,7 +1000,7 @@ func main() {
 func IsStrongPassword(password string, length int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/QHdVcSQ3uDg)</span></b>
 
 ```go
 import (
@@ -1017,7 +1023,7 @@ func main() {
 
 ### <span id="IsUrl">IsUrl</span>
 
-<p>验证字符串是否是url</p>
+<p>验证字符串是否是url。</p>
 
 <b>函数签名:</b>
 
@@ -1025,7 +1031,7 @@ func main() {
 func IsUrl(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/pbJGa7F98Ka)</span></b>
 
 ```go
 import (
@@ -1052,7 +1058,7 @@ func main() {
 ### <span id="IsWeakPassword">IsWeakPassword</span>
 
 <p>验证字符串是否是弱密码：（only letter or only number or letter + number）
-.</p>
+。</p>
 
 <b>函数签名:</b>
 
@@ -1060,7 +1066,7 @@ func main() {
 func IsWeakPassword(password string, length int) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/wqakscZH5gH)</span></b>
 
 ```go
 import (
@@ -1083,7 +1089,7 @@ func main() {
 
 ### <span id="IsZeroValue">IsZeroValue</span>
 
-<p>判断传入的参数值是否为零值</p>
+<p>判断传入的参数值是否为零值。</p>
 
 <b>函数签名:</b>
 
@@ -1091,7 +1097,7 @@ func main() {
 func IsZeroValue(value any) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/UMrwaDCi_t4)</span></b>
 
 ```go
 import (
@@ -1128,7 +1134,7 @@ func main() {
 func IsGBK(data []byte) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/E2nt3unlmzP)</span></b>
 
 ```go
 import (
@@ -1150,7 +1156,6 @@ func main() {
 }
 ```
 
-
 ### <span id="IsPrintable">IsPrintable</span>
 
 <p>检查字符串是否全部为可打印字符。</p>
@@ -1161,7 +1166,7 @@ func main() {
 func IsPrintable(str string) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/Pe1FE2gdtTP)</span></b>
 
 ```go
 import (
@@ -1189,4 +1194,301 @@ func main() {
     // true
     // false
 }
-```
+```
+
+### <span id="IsBin">IsBin</span>
+
+<p>检查字符串是否是有效的二进制数。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsBin(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ogPeg2XJH4P)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBin("0101")
+    result2 := validator.IsBin("0b1101")
+    result3 := validator.IsBin("b1101")
+    result4 := validator.IsBin("1201")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsHex">IsHex</span>
+
+<p>检查字符串是否是有效的十六进制数。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsHex(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/M2qpHbEwmm7)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsHex("0xabcde")
+    result2 := validator.IsHex("0XABCDE")
+    result3 := validator.IsHex("cdfeg")
+    result4 := validator.IsHex("0xcdfeg")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsBase64URL">IsBase64URL</span>
+
+<p>检查字符串是否是有效的base64 url。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsBase64URL(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/vhl4mr8GZ6S)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ")
+    result2 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ==")
+    result3 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ=")
+    result4 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ===")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsJWT">IsJWT</span>
+
+<p>检查字符串是否是有效的JSON Web Token (JWT)。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsJWT(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/R6Op7heJbKI)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibWVzc2FnZSI6IlB1dGluIGlzIGFic29sdXRlIHNoaXQiLCJpYXQiOjE1MTYyMzkwMjJ9.wkLWA5GtCpWdxNOrRse8yHZgORDgf8TpJp73WUQb910")
+    result2 := validator.IsJWT("abc")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsVisa">IsVisa</span>
+
+<p>检查字符串是否是有效的visa卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsVisa(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/SdS2keOyJsl)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsVisa("4111111111111111")
+    result2 := validator.IsVisa("123")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsMasterCard">IsMasterCard</span>
+
+<p>检查字符串是否是有效的MasterCard卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsMasterCard(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CwWBFRrG27b)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsMasterCard("5425233430109903")
+    result2 := validator.IsMasterCard("4111111111111111")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsAmericanExpress">IsAmericanExpress</span>
+
+<p>检查字符串是否是有效的American Express卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsAmericanExpress(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/HIDFpcOdpkd)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsAmericanExpress("342883359122187")
+    result2 := validator.IsAmericanExpress("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsUnionPay">IsUnionPay</span>
+
+<p>检查字符串是否是有效的美国银联卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsUnionPay(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/CUHPEwEITDf)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsUnionPay("6221263430109903")
+    result2 := validator.IsUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsChinaUnionPay">IsChinaUnionPay</span>
+
+<p>检查字符串是否是有效的中国银联卡号。</p>
+
+<b>函数签名:</b>
+
+```go
+func IsChinaUnionPay(v string) bool
+```
+
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/yafpdxLiymu)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsChinaUnionPay("6250941006528599")
+    result2 := validator.IsChinaUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```

docs/api/packages/xerror.md

@@ -38,6 +38,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## 文档
 
 ### <span id="New">New</span>
@@ -58,7 +59,7 @@ type XError struct {
 func New(format string, args ...any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -87,7 +88,7 @@ func main() {
 func Wrap(cause error, message ...any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/5385qT2dCi4)</span></b>
 
 ```go
 package main
@@ -118,7 +119,7 @@ func main() {
 func Unwrap(err error) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/LKMLep723tu)</span></b>
 
 ```go
 package main
@@ -153,24 +154,25 @@ func main() {
 func (e *XError) Wrap(cause error) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/RpjJ5u5sc97)</span></b>
 
 ```go
 package main
 
 import (
     "fmt"
+    "errors"
     "github.com/duke-git/lancet/v2/xerror"
 )
 
 func main() {
-    err := xerror.New("wrong password")
-    wrapErr := xerror.Wrap(err, "error")
+    err1 := xerror.New("error").With("level", "high")
+	err2 := err1.Wrap(errors.New("invalid username"))
 
-    fmt.Println(wrapErr.Error())
+	fmt.Println(err2.Error())
 
-    // Output:
-    // error: wrong password
+	// Output:
+	// error: invalid username
 }
 ```
 
@@ -184,7 +186,7 @@ func main() {
 func (e *XError) Unwrap() error
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/VUXJ8BST4c6)</span></b>
 
 ```go
 package main
@@ -217,7 +219,7 @@ func main() {
 func (e *XError) With(key string, value any) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -249,7 +251,7 @@ func main() {
 func (e *XError) Id(id string) *XError
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -286,7 +288,7 @@ func main() {
 func (e *XError) Is(target error) bool
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -323,7 +325,7 @@ func main() {
 func (e *XError) Values() map[string]any
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -356,7 +358,7 @@ func main() {
 func (e *XError) StackTrace() StackTrace
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/6FAvSQpa7pc)</span></b>
 
 ```go
 package main
@@ -390,7 +392,7 @@ func main() {
 func (e *XError) Info() *errInfo
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/1ZX0ME1F-Jb)</span></b>
 
 ```go
 package main
@@ -430,7 +432,7 @@ func main() {
 func (e *XError) Error() string
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -459,7 +461,7 @@ func main() {
 func TryUnwrap[T any](val T, err error) T
 ```
 
-<b>示例:</b>
+<b>示例:<span style="float:right;display:inline-block">[运行](https://go.dev/play/p/acyZVkNZEeW)</span></b>
 
 ```go
 package main

docs/en/api/overview.md

@@ -0,0 +1,70 @@
+---
+outline: deep
+---
+
+# API Overview
+
+<b>Lancet (Lancet) is a powerful, comprehensive, efficient and reusable go language tool function library. Contains 25 packages, more than 600 utility functions. Functions cover string processing, slice processing, network, concurrency, encryption and decryption, file processing, time/date, stream processing, iterators, and more.</b>
+
+
+<style>
+.package-title {
+    color: black;
+    font-size: 18px;
+    text-align: center;
+    font-weight: bold;
+}
+.package-container {
+    font-size: 16px;
+    border: 1px dashed;
+    padding: 10px;
+    text-align: center;
+}
+
+.package-cell {
+    height: 40px;
+    width: 140px;
+    display: inline-block;
+    vertical-align: middle;
+    line-height: 40px;
+    background: #059669;
+    border: 1px solid;
+    margin-right: 10px;
+    margin-bottom: 10px;
+    border-radius: 6px;
+    font-weight: bold;
+}
+</style>
+
+<div>
+    <p class="package-title">Lancet function module</p>
+    <div class="package-container">
+        <div class="package-cell">algorithm</div>
+        <div class="package-cell">compare</div>
+        <div class="package-cell">concurrency</div>
+        <div class="package-cell">condition</div>
+        <div class="package-cell">convertor</div>
+        <div class="package-cell">cryptor</div>
+        <div class="package-cell">datastructure</div>
+        <div class="package-cell">datetime</div>
+        <div class="package-cell">fileutil</div>
+        <div class="package-cell">formatter</div>
+        <div class="package-cell">function</div>
+        <div class="package-cell">iterator</div>
+        <div class="package-cell">maputil</div>
+        <div class="package-cell">mathutil</div>
+        <div class="package-cell">netutil</div>
+        <div class="package-cell">pointer</div>
+        <div class="package-cell">random</div>
+        <div class="package-cell">retry</div>
+        <div class="package-cell">slice</div>
+        <div class="package-cell">stream</div>
+        <div class="package-cell">structs</div>
+        <div class="package-cell">strutil</div>
+        <div class="package-cell">system</div>
+        <div class="package-cell">tuple</div>
+        <div class="package-cell">validator</div>
+        <div class="package-cell">xerror</div>
+    </div>
+</div>
+

docs/en/api/packages/algorithm.md

@@ -51,7 +51,7 @@ import (
 func BubbleSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 package main
@@ -99,7 +99,7 @@ func main() {
 func InsertionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G5LJiWgJJW6)</span></b>
 
 ```go
 package main
@@ -162,7 +162,7 @@ func main() {
 func SelectionSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/oXovbkekayS)</span></b>
 
 ```go
 package main
@@ -210,7 +210,7 @@ func main() {
 func ShellSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3ibkszpJEu3)</span></b>
 
 ```go
 package main
@@ -258,7 +258,7 @@ func main() {
 func QuickSort[T any](slice []T comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7Y7c1Elk3ax)</span></b>
 
 ```go
 package main
@@ -306,7 +306,7 @@ func main() {
 func HeapSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/u6Iwa1VZS_f)</span></b>
 
 ```go
 package main
@@ -354,7 +354,7 @@ func main() {
 func MergeSort[T any](slice []T, comparator lancetconstraints.Comparator)
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ydinn9YzUJn)</span></b>
 
 ```go
 package main
@@ -402,7 +402,7 @@ func main() {
 func CountSort[T any](slice []T, comparator lancetconstraints.Comparator) []T
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tB-Umgm0DrP)</span></b>
 
 ```go
 package main
@@ -451,7 +451,7 @@ func main() {
 func BinarySearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/t6MeGiUSN47)</span></b>
 
 ```go
 package main
@@ -502,7 +502,7 @@ func main() {
 func BinaryIterativeSearch[T any](sortedSlice []T, target T, lowIndex, highIndex int, comparator lancetconstraints.Comparator) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Anozfr8ZLH3)</span></b>
 
 ```go
 package main
@@ -553,7 +553,7 @@ func main() {
 func LinearSearch[T any](slice []T, target T, equal func(a, b T) bool) int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main
@@ -596,7 +596,7 @@ func (l *LRUCache[K, V]) Delete(key K) bool
 func (l *LRUCache[K, V]) Len() int
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IsS7rgn5s3x)</span></b>
 
 ```go
 package main

docs/en/api/packages/compare.md

@@ -30,6 +30,7 @@ import (
 -   [GreaterThan](#GreaterThan)
 -   [LessOrEqual](#LessOrEqual)
 -   [GreaterOrEqual](#GreaterOrEqual)
+-   [InDelta](#InDelta)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -39,7 +40,7 @@ import (
 
 <p>Checks if two values are equal or not. (check both type and value)</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wmVxR-to4lz)</span></b>
 
 ```go
 func Equal(left, right any) bool
@@ -88,7 +89,7 @@ func main() {
 
 <p>Checks if two values are equal or not. (check value only)</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fxnna_LLD9u)</span></b>
 
 ```go
 func EqualValue(left, right any) bool
@@ -127,7 +128,7 @@ func main() {
 
 <p>Checks if value `left` less than value `right`.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cYh7FQQj0ne)</span></b>
 
 ```go
 func LessThan(left, right any) bool
@@ -182,7 +183,7 @@ func main() {
 func GreaterThan(left, right any) bool
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9-NYDFZmIMp)</span></b>
 
 ```go
 package main
@@ -234,7 +235,7 @@ func main() {
 func LessOrEqual(left, right any) bool
 ```
 
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/e4T_scwoQzp)</span></b>
 
 ```go
 package main
@@ -277,7 +278,7 @@ func main() {
 
 <p>Checks if value `left` less greater or equal than value `right`.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/vx8mP0U8DFk)</span></b>
 
 ```go
 func GreaterOrEqual(left, right any) bool
@@ -324,3 +325,50 @@ func main() {
     // false
 }
 ```
+
+### <span id="InDelta">InDelta</span>
+
+<p>Checks if two values are equal or not within a delta.</p>
+
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TuDdcNtMkjo)</span></b>
+
+```go
+func InDelta[T constraints.Integer | constraints.Float](left, right T, delta float64) bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/compare"
+)
+
+func main() {
+    result1 := InDelta(1, 1, 0)
+    result2 := InDelta(1, 2, 0)
+
+    result3 := InDelta(2.0/3.0, 0.66667, 0.001)
+    result4 := InDelta(2.0/3.0, 0.0, 0.001)
+
+    result5 := InDelta(float64(74.96)-float64(20.48), 54.48, 0)
+    result6 := InDelta(float64(74.96)-float64(20.48), 54.48, 1e-14)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    fmt.Println(result6)
+
+    // Output:
+    // true
+    // false
+    // true
+    // false
+    // false
+    // true
+}
+```

docs/en/api/packages/concurrency.md

@@ -35,7 +35,6 @@ import (
 
 ## Documentation
 
-
 ## Channel
 ### <span id="NewChannel">NewChannel</span>
 <p>Create a Channel pointer instance.</p>
@@ -46,7 +45,7 @@ import (
 type Channel[T any] struct
 func NewChannel[T any]() *Channel[T]
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -70,7 +69,7 @@ func main() {
 ```go
 func (c *Channel[T]) Bridge(ctx context.Context, chanStream <-chan <-chan T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qmWSy1NVF-Y)</span></b>
 
 ```go
 package main
@@ -122,7 +121,7 @@ func main() {
 ```go
 func (c *Channel[T]) FanIn(ctx context.Context, channels ...<-chan T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2VYFMexEvTm)</span></b>
 
 ```go
 package main
@@ -156,7 +155,7 @@ func main() {
 
 <p>Create channel, put values into the channel repeatly until cancel the context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/k5N_ALVmYjE)</span></b>
 
 ```go
 func (c *Channel[T]) Repeat(ctx context.Context, values ...T) <-chan T
@@ -200,7 +199,7 @@ func main() {
 ```go
 func (c *Channel[T]) Generate(ctx context.Context, values ...T) <-chan T
 ```
-<b>Example:</b>
+<b>Example: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7aB4KyMMp9A)</span></b>
 
 ```go
 package main
@@ -233,7 +232,7 @@ func main() {
 
 <p>Create a channel, excutes fn repeatly, and put the result into the channel, until close context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4J1zAWttP85)</span></b>
 
 ```go
 func (c *Channel[T]) RepeatFn(ctx context.Context, fn func() T) <-chan T
@@ -275,7 +274,7 @@ func main() {
 
 <p>Read one or more channels into one channel, will close when any readin channel is closed.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Wqz9rwioPww)</span></b>
 
 ```go
 func (c *Channel[T]) Or(channels ...<-chan T) <-chan T
@@ -318,7 +317,7 @@ func main() {
 
 <p>Read a channel into another channel, will close until cancel context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lm_GoS6aDjo)</span></b>
 
 ```go
 func (c *Channel[T]) OrDone(ctx context.Context, channel <-chan T) <-chan T
@@ -356,7 +355,7 @@ func main() {
 
 <p>Create a channel whose values are taken from another channel with limit number.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9Utt-1pDr2J)</span></b>
 
 ```go
 func (c *Channel[T]) Take(ctx context.Context, valueStream <-chan T, number int) <-chan T
@@ -402,7 +401,7 @@ func main() {
 
 <p>Split one chanel into two channels, until cancel the context.</p>
 
-<b>Signature:</b>
+<b>Signature: <span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3TQPKnCirrP)</span></b>
 
 ```go
 func (c *Channel[T]) Tee(ctx context.Context, in <-chan T) (<-chan T, <-chan T)

docs/en/api/packages/condition.md

@@ -46,7 +46,7 @@ All other types are truthy if they are not their zero value.</p>
 ```go
 func Bool[T any](value T) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ETzeDJRSvhm)</span></b>
 
 ```go
 package main
@@ -111,7 +111,7 @@ func main() {
 ```go
 func And[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/W1SSUmt6pvr)</span></b>
 
 ```go
 package main
@@ -139,7 +139,7 @@ func main() {
 ```go
 func Or[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/UlQTxHaeEkq)</span></b>
 
 ```go
 package main
@@ -167,7 +167,7 @@ func main() {
 ```go
 func Xor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/gObZrW7ZbG8)</span></b>
 
 ```go
 package main
@@ -195,7 +195,7 @@ func main() {
 ```go
 func Nor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/g2j08F_zZky)</span></b>
 
 ```go
 package main
@@ -222,7 +222,7 @@ func main() {
 ```go
 func Xnor[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/OuDB9g51643)</span></b>
 
 ```go
 package main
@@ -249,7 +249,7 @@ func main() {
 ```go
 func Nand[T, U any](a T, b U) bool
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/vSRMLxLIbq8)</span></b>
 
 ```go
 package main
@@ -277,7 +277,7 @@ func main() {
 ```go
 func TernaryOperator[T, U any](isTrue T, ifValue U, elseValue U) U
 ```
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[运行](https://go.dev/play/p/ElllPZY0guT)</span></b>
 
 ```go
 package main

docs/en/api/packages/convertor.md

@@ -58,7 +58,7 @@ import (
 func ColorHexToRGB(colorHex string) (red, green, blue int)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/o7_ft-JCJBV)</span></b>
 
 ```go
 package main
@@ -89,7 +89,7 @@ func main() {
 func ColorRGBToHex(red, green, blue int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nzKS2Ro87J1)</span></b>
 
 ```go
 package main
@@ -122,7 +122,7 @@ func main() {
 func ToBool(s string) (bool, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ARht2WnGdIN)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func ToBytes(data any) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fAMXYFDvOvr)</span></b>
 
 ```go
 package main
@@ -196,7 +196,7 @@ func main() {
 func ToChar(s string) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/JJ1SvbFkVdM)</span></b>
 
 ```go
 package main
@@ -232,7 +232,7 @@ func main() {
 func ToChannel[T any](array []T) <-chan T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hOx_oYZbAnL)</span></b>
 
 ```go
 package main
@@ -269,7 +269,7 @@ func main() {
 func ToFloat(value any) (float64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4YTmPCibqHJ)</span></b>
 
 ```go
 package main
@@ -314,7 +314,7 @@ func main() {
 func ToInt(value any) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9_h9vIt-QZ_b)</span></b>
 
 ```go
 package main
@@ -356,7 +356,7 @@ func main() {
 func ToJson(value any) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2rLIkMmXWvR)</span></b>
 
 ```go
 package main
@@ -391,7 +391,7 @@ func main() {
 func ToMap[T any, K comparable, V any](array []T, iteratee func(T) (K, V)) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tVFy7E-t24l)</span></b>
 
 ```go
 package main
@@ -432,7 +432,7 @@ func main() {
 func ToPointer[T any](value T) *T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ASf_etHNlw1)</span></b>
 
 ```go
 package main
@@ -461,7 +461,7 @@ func main() {
 func ToString(value any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nF1zOOslpQq)</span></b>
 
 ```go
 package main
@@ -509,7 +509,7 @@ func main() {
 func StructToMap(value any) (map[string]any, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KYGYJqNUBOI)</span></b>
 
 ```go
 package main
@@ -547,7 +547,7 @@ func main() {
 func MapToSlice[T any, K comparable, V any](aMap map[K]V, iteratee func(K, V) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dmX4Ix5V6Wl)</span></b>
 
 ```go
 package main
@@ -577,7 +577,7 @@ func main() {
 func EncodeByte(data any) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DVmM1G5JfuP)</span></b>
 
 ```go
 package main
@@ -606,7 +606,7 @@ func main() {
 func DecodeByte(data []byte, target any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -642,7 +642,7 @@ func main() {
 func DeepClone[T any](src T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/j4DP5dquxnk)</span></b>
 
 ```go
 package main
@@ -706,7 +706,7 @@ func main() {
 func CopyProperties[T, U any](dst T, src U) (err error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/oZujoB5Sgg5)</span></b>
 
 ```go
 package main
@@ -785,7 +785,7 @@ func main() {
 func ToInterface(v reflect.Value) (value interface{}, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/syqw0-WG7Xd)</span></b>
 
 ```go
 package main
@@ -820,7 +820,7 @@ func main() {
 func Utf8ToGbk(bs []byte) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9FlIaFLArIL)</span></b>
 
 ```go
 package main
@@ -854,7 +854,7 @@ func main() {
 func GbkToUtf8(bs []byte) ([]byte, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OphmHCN_9u8)</span></b>
 
 ```go
 package main

docs/en/api/packages/cryptor.md

@@ -1,18 +1,18 @@
 # Cryptor
+
 Package cryptor contains some functions for data encryption and decryption. Support base64, md5, hmac, aes, des, rsa.
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
-- [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
-- [https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go](https://github.com/duke-git/lancet/blob/main/cryptor/encrypt.go)
-
-
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/basic.go](https://github.com/duke-git/lancet/blob/main/cryptor/basic.go)
+-   [https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go](https://github.com/duke-git/lancet/blob/main/cryptor/crypto.go)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Usage:
+
 ```go
 import (
     "github.com/duke-git/lancet/v2/cryptor"
@@ -23,40 +23,51 @@ import (
 
 ## Index
 
-- [AesEcbEncrypt](#AesEcbEncrypt)
-- [AesEcbDecrypt](#AesEcbDecrypt)
-- [AesCbcEncrypt](#AesCbcEncrypt)
-- [AesCbcDecrypt](#AesCbcDecrypt)
-- [AesCtrCrypt](#AesCtrCrypt)
-- [AesCfbEncrypt](#AesCfbEncrypt)
-- [AesCfbDecrypt](#AesCfbDecrypt)
-- [AesOfbEncrypt](#AesOfbEncrypt)
-- [AesOfbDecrypt](#AesOfbDecrypt)
-- [Base64StdEncode](#Base64StdEncode)
-- [Base64StdDecode](#Base64StdDecode)
-- [DesEcbEncrypt](#DesEcbEncrypt)
-- [DesEcbDecrypt](#DesEcbDecrypt)
-- [DesCbcEncrypt](#DesCbcEncrypt)
-- [DesCbcDecrypt](#DesCbcDecrypt)
-- [DesCtrCrypt](#DesCtrCrypt)
-- [DesCfbEncrypt](#DesCfbEncrypt)
-- [DesCfbDecrypt](#DesCfbDecrypt)
-- [DesOfbEncrypt](#DesOfbEncrypt)
-- [DesOfbDecrypt](#DesOfbDecrypt)
-- [HmacMd5](#HmacMd5)
-- [HmacSha1](#HmacSha1)
-- [HmacSha256](#HmacSha256)
-- [HmacSha512](#HmacSha512)
-- [Md5String](#Md5String)
-- [Md5Byte](#Md5Byte)
-- [Md5File](#Md5File)
-- [Sha1](#Sha1)
-- [Sha256](#Sha256)
-- [Sha512](#Sha512)
-- [GenerateRsaKey](#GenerateRsaKey)
-- [RsaEncrypt](#RsaEncrypt)
-- [RsaDecrypt](#RsaDecrypt)
-
+-   [AesEcbEncrypt](#AesEcbEncrypt)
+-   [AesEcbDecrypt](#AesEcbDecrypt)
+-   [AesCbcEncrypt](#AesCbcEncrypt)
+-   [AesCbcDecrypt](#AesCbcDecrypt)
+-   [AesCtrCrypt](#AesCtrCrypt)
+-   [AesCfbEncrypt](#AesCfbEncrypt)
+-   [AesCfbDecrypt](#AesCfbDecrypt)
+-   [AesOfbEncrypt](#AesOfbEncrypt)
+-   [AesOfbDecrypt](#AesOfbDecrypt)
+-   [Base64StdEncode](#Base64StdEncode)
+-   [Base64StdDecode](#Base64StdDecode)
+-   [DesEcbEncrypt](#DesEcbEncrypt)
+-   [DesEcbDecrypt](#DesEcbDecrypt)
+-   [DesCbcEncrypt](#DesCbcEncrypt)
+-   [DesCbcDecrypt](#DesCbcDecrypt)
+-   [DesCtrCrypt](#DesCtrCrypt)
+-   [DesCfbEncrypt](#DesCfbEncrypt)
+-   [DesCfbDecrypt](#DesCfbDecrypt)
+-   [DesOfbEncrypt](#DesOfbEncrypt)
+-   [DesOfbDecrypt](#DesOfbDecrypt)
+-   [HmacMd5](#HmacMd5)
+-   [HmacMd5WithBase64](#HmacMd5WithBase64)
+-   [HmacSha1](#HmacSha1)
+-   [HmacSha1WithBase64](#HmacSha1WithBase64)
+-   [HmacSha256](#HmacSha256)
+-   [HmacSha256WithBase64](#HmacSha256WithBase64)
+-   [HmacSha512](#HmacSha512)
+-   [HmacSha512WithBase64](#HmacSha512WithBase64)
+-   [Md5String](#Md5String)
+-   [Md5StringWithBase64](#Md5StringWithBase64)
+-   [Md5Byte](#Md5Byte)
+-   [Md5ByteWithBase64](#Md5ByteWithBase64)
+-   [Md5File](#Md5File)
+-   [Sha1](#Sha1)
+-   [Sha1WithBase64](#Sha1WithBase64)
+-   [Sha256](#Sha256)
+-   [Sha256WithBase64](#Sha256WithBase64)
+-   [Sha512](#Sha512)
+-   [Sha512WithBase64](#Sha512WithBase64)
+-   [GenerateRsaKey](#GenerateRsaKey)
+-   [RsaEncrypt](#RsaEncrypt)
+-   [RsaDecrypt](#RsaDecrypt)
+-   [GenerateRsaKeyPair](#GenerateRsaKeyPair)
+-   [RsaEncryptOAEP](#RsaEncryptOAEP)
+-   [RsaDecryptOAEP](#RsaDecryptOAEP)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -71,7 +82,8 @@ import (
 ```go
 func AesEcbEncrypt(data, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -104,7 +116,8 @@ func main() {
 ```go
 func AesEcbDecrypt(encrypted, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zI6xsmuQRbn)</span></b>
 
 ```go
 package main
@@ -137,7 +150,8 @@ func main() {
 ```go
 func AesCbcEncrypt(data, key []byte) []byte
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -171,7 +185,7 @@ func main() {
 func AesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IOq_g8_lKZD)</span></b>
 
 ```go
 package main
@@ -205,7 +219,7 @@ func main() {
 func AesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/SpaZO0-5Nsp)</span></b>
 
 ```go
 package main
@@ -239,7 +253,7 @@ func main() {
 func AesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -273,7 +287,7 @@ func main() {
 func AesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tfkF10B13kH)</span></b>
 
 ```go
 package main
@@ -307,7 +321,7 @@ func main() {
 func AesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -330,6 +344,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="AesCfbDecrypt">AesOfbDecrypt</span>
 
 <p>Decrypt data with key use AES OFB algorithm. Length of `key` param should be 16, 24 or 32.</p>
@@ -340,7 +355,7 @@ func main() {
 func AesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VtHxtkUj-3F)</span></b>
 
 ```go
 package main
@@ -373,7 +388,8 @@ func main() {
 ```go
 func Base64StdEncode(s string) string
 ```
-<b>Example:</b>
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VOaUyQUreoK)</span></b>
 
 ```go
 package main
@@ -391,6 +407,7 @@ func main() {
     // aGVsbG8=
 }
 ```
+
 ### <span id="Base64StdDecode">Base64StdDecode</span>
 
 <p>Decode a base64 encoded string.</p>
@@ -401,7 +418,7 @@ func main() {
 func Base64StdDecode(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RWQylnJVgIe)</span></b>
 
 ```go
 package main
@@ -430,7 +447,7 @@ func main() {
 func DesEcbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -454,6 +471,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesEcbDecrypt">DesEcbDecrypt</span>
 
 <p>Decrypt data with key use DES ECB algorithm. Length of `key` param should be 8.</p>
@@ -464,7 +482,7 @@ func main() {
 func DesEcbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8qivmPeZy4P)</span></b>
 
 ```go
 package main
@@ -499,7 +517,7 @@ func main() {
 func DesCbcEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -533,7 +551,7 @@ func main() {
 func DesCbcDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4cC4QvWfe3_1)</span></b>
 
 ```go
 package main
@@ -556,6 +574,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCtrCrypt">DesCtrCrypt</span>
 
 <p>Encrypt or decrypt data with key use DES CTR algorithm. Length of `key` param should be 8.</p>
@@ -566,7 +585,7 @@ func main() {
 func DesCtrCrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9-T6OjKpcdw)</span></b>
 
 ```go
 package main
@@ -600,7 +619,7 @@ func main() {
 func DesCfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -623,6 +642,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesCfbDecrypt">DesCfbDecrypt</span>
 
 <p>Decrypt data with key use DES CBC algorithm. Length of `key` param should be 8.</p>
@@ -633,7 +653,7 @@ func main() {
 func DesCfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/y-eNxcFBlxL)</span></b>
 
 ```go
 package main
@@ -656,6 +676,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbEncrypt">DesOfbEncrypt</span>
 
 <p>Enecrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -666,7 +687,7 @@ func main() {
 func DesOfbEncrypt(data, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -689,6 +710,7 @@ func main() {
     // hello
 }
 ```
+
 ### <span id="DesOfbDecrypt">DesOfbDecrypt</span>
 
 <p>Decrypt data with key use DES OFB algorithm. Length of `key` param should be 8.</p>
@@ -699,7 +721,7 @@ func main() {
 func DesOfbDecrypt(encrypted, key []byte) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/74KmNadjN1J)</span></b>
 
 ```go
 package main
@@ -730,10 +752,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacMd5(data, key string) string
+func HmacMd5(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -744,7 +766,7 @@ import (
 )
 
 func main() {
-      str := "hello"
+    str := "hello"
     key := "12345"
 
     hms := cryptor.HmacMd5(str, key)
@@ -754,6 +776,39 @@ func main() {
     // e834306eab892d872525d4918a7a639a
 }
 ```
+
+### <span id="HmacMd5WithBase64">HmacMd5WithBase64</span>
+
+<p>Get the md5 hmac hash of base64 string.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacMd5WithBase64(str, key string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UY0ng2AefFC)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacMd5WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // 6DQwbquJLYclJdSRinpjmg==
+}
+```
+
 ### <span id="HmacSha1">HmacSha1</span>
 
 <p>Get the sha1 hmac hash of string.</p>
@@ -761,10 +816,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha1(data, key string) string
+func HmacSha1(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1UI4oQ4WXKM)</span></b>
 
 ```go
 package main
@@ -785,6 +840,39 @@ func main() {
     // 5c6a9db0cccb92e36ed0323fd09b7f936de9ace0
 }
 ```
+
+### <span id="HmacSha1WithBase64">HmacSha1WithBase64</span>
+
+<p>Return the hmac hash of string use sha1 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha1WithBase64(str, key string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/47JmmGrnF7B)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha1WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // XGqdsMzLkuNu0DI/0Jt/k23prOA=
+}
+```
+
 ### <span id="HmacSha256">HmacSha256</span>
 
 <p>Get the sha256 hmac hash of string</p>
@@ -792,10 +880,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha256(data, key string) string
+func HmacSha256(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HhpwXxFhhC0)</span></b>
 
 ```go
 package main
@@ -817,6 +905,38 @@ func main() {
 }
 ```
 
+### <span id="HmacSha256WithBase64">HmacSha256WithBase64</span>
+
+<p>Return the hmac hash of string use sha256 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha256WithBase64(str, key string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EKbkUvPTLwO)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+    key := "12345"
+
+    hms := cryptor.HmacSha256WithBase64(str, key)
+    fmt.Println(hms)
+
+    // Output:
+    // MVu5PE6YmGK6Ccti4F1zpfN2yzbw14btqwwyDQWf3nU=
+}
+```
+
 ### <span id="HmacSha512">HmacSha512</span>
 
 <p>Get the sha512 hmac hash of string.</p>
@@ -824,10 +944,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func HmacSha512(data, key string) string
+func HmacSha512(str, key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/59Od6m4A0Ud)</span></b>
 
 ```go
 package main
@@ -849,6 +969,37 @@ func main() {
 }
 ```
 
+### <span id="HmacSha512WithBase64">HmacSha512WithBase64</span>
+
+<p>Return the hmac hash of string use sha512 with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func HmacSha512WithBase64(str, key string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/c6dSe3E2ydU)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    str := "hello"
+	key := "12345"
+
+	hms := cryptor.HmacSha512WithBase64(str, key)
+	fmt.Println(hms)
+
+	// Output:
+	// 3Y8SkKndI9NU4lJtmi6c6M///dN8syCADRxsE9Lvw2Mog3ahlsVFja9T+OGqa0Wm2FYwPVwKIGS/+XhYYdSM/A==
+}
+```
 
 ### <span id="Md5String">Md5String</span>
 
@@ -860,7 +1011,7 @@ func main() {
 func Md5String(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1bLcVetbTOI)</span></b>
 
 ```go
 package main
@@ -881,6 +1032,35 @@ func main() {
 }
 ```
 
+### <span id="Md5StringWithBase64">Md5StringWithBase64</span>
+
+<p>Return the md5 value of string with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Md5StringWithBase64(s string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Tcb-Z7LN2ax)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5StringWithBase64("hello")
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5Byte">Md5Byte</span>
 
 <p>Return the md5 string of byte slice.</p>
@@ -891,7 +1071,7 @@ func main() {
 func Md5Byte(data []byte) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/suraalH8lyC)</span></b>
 
 ```go
 package main
@@ -910,6 +1090,35 @@ func main() {
 }
 ```
 
+### <span id="Md5ByteWithBase64">Md5ByteWithBase64</span>
+
+<p>Return the md5 string of byte slice with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Md5ByteWithBase64(data []byte) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Lx4gH7Vdr5_y)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    md5Str := cryptor.Md5ByteWithBase64([]byte("hello"))
+	fmt.Println(md5Str)
+
+	// Output:
+	// XUFAKrxLKna5cZ2REBfFkg==
+}
+```
+
 ### <span id="Md5File">Md5File</span>
 
 <p>Get the md5 value of file.</p>
@@ -943,10 +1152,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha1(data string) string
+func Sha1(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_m_uoD1deMT)</span></b>
 
 ```go
 package main
@@ -967,6 +1176,35 @@ func main() {
 }
 ```
 
+### <span id="Sha1WithBase64">Sha1WithBase64</span>
+
+<p>Return the sha1 value (SHA-1 hash algorithm) of base64 string.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha1WithBase64(str string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fSyx-Gl2l2-)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha1WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// qvTGHdzF6KLavt4PO0gs2a6pQ00=
+}
+```
+
 ### <span id="Sha256">Sha256</span>
 
 <p>Get the sha256 value of string.</p>
@@ -974,10 +1212,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha256(data string) string
+func Sha256(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tU9tfBMIAr1)</span></b>
 
 ```go
 package main
@@ -998,6 +1236,35 @@ func main() {
 }
 ```
 
+### <span id="Sha256WithBase64">Sha256WithBase64</span>
+
+<p>Return the sha256 value (SHA256 hash algorithm) of base64 string.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha256WithBase64(str string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/85IXJHIal1k)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha256WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// LPJNul+wow4m6DsqxbninhsWHlwfp0JecwQzYpOLmCQ=
+}
+```
+
 ### <span id="Sha512">Sha512</span>
 
 <p>Get the sha512 value of string.</p>
@@ -1005,10 +1272,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func Sha512(data string) string
+func Sha512(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3WsvLYZxsHa)</span></b>
 
 ```go
 package main
@@ -1029,6 +1296,35 @@ func main() {
 }
 ```
 
+### <span id="Sha512WithBase64">Sha512WithBase64</span>
+
+<p>Get the sha512 value of string with base64.</p>
+
+<b>Signature:</b>
+
+```go
+func Sha512WithBase64(str string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/q_fY2rA-k5I)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    result := cryptor.Sha512WithBase64("hello")
+	fmt.Println(result)
+
+	// Output:
+	// m3HSJL1i83hdltRq0+o9czGb+8KJDKra4t/3JRlnPKcjI8PZm6XBHXx6zG4UuMXaDEZjR1wuXDre9G9zvN7AQw==
+}
+```
+
 ### <span id="GenerateRsaKey">GenerateRsaKey</span>
 
 <p>Create the rsa public and private key file in current directory.</p>
@@ -1039,7 +1335,7 @@ func main() {
 func GenerateRsaKey(keySize int, priKeyFile, pubKeyFile string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zutRHrDqs0X)</span></b>
 
 ```go
 package main
@@ -1067,7 +1363,7 @@ func main() {
 func RsaEncrypt(data []byte, pubKeyFileName string) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1082,11 +1378,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1094,7 +1390,6 @@ func main() {
 }
 ```
 
-
 ### <span id="RsaDecrypt">RsaDecrypt</span>
 
 <p>Decrypt data with private key file useing ras algorithm.</p>
@@ -1105,7 +1400,7 @@ func main() {
 func RsaDecrypt(data []byte, privateKeyFileName string) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uef0q1fz53I)</span></b>
 
 ```go
 package main
@@ -1120,11 +1415,11 @@ func main() {
     if err != nil {
         return
     }
-      
+
     data := []byte("hello")
     encrypted := cryptor.RsaEncrypt(data, "rsa_public.pem")
     decrypted := cryptor.RsaDecrypt(encrypted, "rsa_private.pem")
-      
+
     fmt.Println(string(decrypted))
 
     // Output:
@@ -1132,5 +1427,113 @@ func main() {
 }
 ```
 
+### <span id="GenerateRsaKeyPair">GenerateRsaKeyPair</span>
 
+<p>Creates rsa private and public key.</p>
 
+<b>Signature:</b>
+
+```go
+func GenerateRsaKeyPair(keySize int) (*rsa.PrivateKey, *rsa.PublicKey)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+}
+```
+
+### <span id="RsaEncryptOAEP">RsaEncryptOAEP</span>
+
+<p>Encrypts the given data with RSA-OAEP.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaEncryptOAEP(data []byte, label []byte, key rsa.PublicKey) ([]byte, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```
+
+### <span id="RsaDecryptOAEP">RsaDecryptOAEP</span>
+
+<p>Decrypts the data with RSA-OAEP.</p>
+
+<b>Signature:</b>
+
+```go
+func RsaDecryptOAEP(ciphertext []byte, label []byte, key rsa.PrivateKey) ([]byte, error)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sSVmkfENKMz)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/cryptor"
+)
+
+func main() {
+    pri, pub := cryptor.GenerateRsaKeyPair(1024)
+
+    data := []byte("hello world")
+    label := []byte("123456")
+
+    encrypted, err := cryptor.RsaEncryptOAEP(data, label, *pub)
+    if err != nil {
+        return
+    }
+
+    decrypted, err := cryptor.RsaDecryptOAEP([]byte(encrypted), label, *pri)
+    if err != nil {
+        return
+    }
+
+    fmt.Println(string(decrypted))
+
+    // Output:
+    // hello world
+}
+```

docs/en/api/packages/datastructure/copyonwritelist.md

@@ -0,0 +1,470 @@
+# CopyOnWriteList
+
+CopyOnWriteList is a thread-safe list implementation that uses go slicing as its base. When writing, a new slice is copied and assigned to the original slice when writing is complete. When reading, the original slice is read directly.
+
+## 源码
+
+-   [https://github.com/duke-git/lancet/blob/main/datastructure/list/copyonwritelist.go](https://github.com/duke-git/lancet/blob/main /datastructure/list/copyonwritelist.go)
+
+## 用法
+
+```go
+import (
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## 目录
+
+-   [NewCopyOnWriteList](#NewCopyOnWriteList)
+-   [Size](#Size)
+-   [Get](#Get)
+-   [Set](#Set)
+-   [Remove](#Remove)
+-   [IndexOf](#IndexOf)
+-   [LastIndexOf](#LastIndexOf)
+-   [IsEmpty](#IsEmpty)
+-   [Contain](#Contain)
+-   [ValueOf](#ValueOf)
+-   [Add](#Add)
+-   [AddAll](#AddAll)
+-   [AddByIndex](#AddByIndex)
+-   [DeleteAt](#DeleteAt)
+-   [DeleteIf](#DeleteIf)
+-   [DeleteBy](#DeleteBy)
+-   [DeleteRange](#DeleteRange)
+-   [Equal](#Equal)
+
+## Documentation
+
+### NewCopyOnWriteList
+
+Returns a CopyOnWriteList with empty slices.
+
+```go
+type CopyOnWriteList[T any] struct {
+    data []T
+    lock sync.
+}
+
+func NewCopyOnWriteList() *CopyOnWriteList
+
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l)
+}
+```
+
+### Size
+
+Returns the length of the CopyOnWriteList.
+
+```go
+func (l *CopyOnWriteList[T]) Size() int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Size())
+}
+
+```
+
+### Get
+
+Returns the element at the specified position in the list
+
+```go
+func (c *CopyOnWriteList[T]) Get(index int) *T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Get(2))
+}
+
+```
+
+### Set
+
+Replaces the element at the specified position in this list with the specified element.
+
+```go
+func (c *CopyOnWriteList[T]) Set(index int, e T) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.Set(2, 4))
+}
+
+```
+
+### Remove
+
+### IndexOf
+
+Returns the index of the value in the list, or -1 if not found.
+
+```go
+func (c *CopyOnWriteList[T]) IndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.IndexOf(1))
+}
+
+```
+
+### LastIndexOf
+
+Returns the index of the last occurrence of the specified element in this list, or -1 if this list does not contain that element.
+
+```go
+func (c *CopyOnWriteList[T]) LastIndexOf(e T) int
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,1})
+    fmt.Println(l.LastIndexOf(1))
+}
+
+```
+
+### IsEmpty
+
+Returns true if this list does not contain any elements.
+
+```go
+func (c *CopyOnWriteList[T]) IsEmpty() bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{})
+    fmt.Println(l.IsEmpty())
+}
+```
+
+### Contain
+
+Determines if a CopyOnWriteList contains an element.
+
+```go
+func (c *CopyOnWriteList[T]) Contain(e T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+l := list.NewCopyOnWriteList([]int{1,2,3})
+fmt.Println(l.Contain(1))
+}
+```
+
+### ValueOf
+
+Returns a pointer to the value at the index in the list
+
+```go
+func (c *CopyOnWriteList[T]) ValueOf(index int) []T
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    fmt.Println(l.ValueOf(2))
+}
+
+```
+
+### Add
+
+Appends the specified element to the end of the list.
+
+```go
+func (c *CopyOnWriteList[T]) Add(e T) bool
+```
+
+#### Example
+
+```go
+
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+	l.Add(4)
+	fmt.Println(l.getList())
+}
+
+```
+
+### AddAll
+
+Appends all the elements of the specified collection to the end of this list
+
+```go
+func (c *CopyOnWriteList[T]) AddAll(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    l.AddAll([]int{4,5,6})
+    fmt.Println(l.getList())
+}
+
+```
+
+### AddByIndex
+
+Inserts the specified element into the list at the specified position.
+
+```go
+func (c *CopyOnWriteList[T]) AddByIndex(index int, e T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.AddByIndex(2, 6)
+    fmt.Println(l.getList())
+}
+
+```
+
+### DeleteAt
+
+Removes the element at the specified position in this list.
+
+```go
+func (c *CopyOnWriteList[T]) DeleteAt(index int) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+    "fmt"
+    "github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteAt(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteIf
+
+Removes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteIf(func(T) bool) (oldValue *T, ok bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteIf(func(i int) bool {
+        return i == 2
+    })
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteBy
+
+Deletes the first occurrence of the specified element from this list (if it exists).
+
+```go
+func (c *CopyOnWriteList[T]) DeleteBy(e T) (*T bool)
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+	l := list.NewCopyOnWriteList([]int{1,2,3})
+    list.DeleteBy(2)
+    fmt.Println(l.getList())
+}
+```
+
+### DeleteRange
+
+Deletes all elements from this list with indexes between fromIndex (included) and toIndex (not included).
+(leftCloseRightOpen)
+
+```go
+func (c *CopyOnWriteList[T]) DeleteRange(start int, end int)
+```
+
+#### Example
+
+```go
+package main
+import (
+"fmt"
+"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    list.DeleteRange(2, 5)
+    fmt.Println(l.getList())
+}
+```
+
+### Equal
+
+Returns true if the specified object is equal to this list
+
+```go
+func (c *CopyOnWriteList[T]) Equal(e []T) bool
+```
+
+#### Example
+
+```go
+package main
+import (
+	"fmt"
+	"github.com/duke-git/lancet/datastructure/list"
+)
+
+func main() {
+    l := list.NewCopyOnWriteList([]int{1,2,3,4,5,6,7,8,9})
+    fmt.Println(l.Equal([]int{1,2,3,4,5,6,7,8,9}))
+}
+```

docs/en/api/packages/datastructure/hashmap.md

@@ -39,7 +39,7 @@ import (
 
 ### <span id="NewHashMap">NewHashMap</span>
 
-<p>Make a HashMap instance with default capacity is 1 << 10.</p>
+<p>Make a HashMap instance with default capacity is 1 &lt&lt 10.</p>
 
 <b>Signature:</b>
 

docs/en/api/packages/datetime.md

@@ -59,7 +59,12 @@ import (
 -   [IsLeapYear](#IsLeapYear)
 -   [BetweenSeconds](#BetweenSeconds)
 -   [DayOfYear](#DayOfYear)
--   [IsWeekend](#IsWeekend)
+-   [IsWeekend<sup>deprecated</sup>](#IsWeekend)
+-   [NowDateOrTime](#NowDateOrTime)
+-   [Timestamp](#Timestamp)
+-   [TimestampMilli](#TimestampMilli)
+-   [TimestampMicro](#TimestampMicro)
+-   [TimestampNano](#TimestampNano)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -67,7 +72,7 @@ import (
 
 ## Note:
 
-1. 'format' string param in func FormatTimeToStr and FormatStrToTime function should be one of flows:
+1. In below functions, the `format` string param should be one of flows value (case no sensitive):
 
 -   yyyy-mm-dd hh:mm:ss
 -   yyyy-mm-dd hh:mm
@@ -78,14 +83,18 @@ import (
 -   dd-mm-yy hh:mm:ss
 -   yyyy/mm/dd hh:mm:ss
 -   yyyy/mm/dd hh:mm
--   yyyy-mm-dd hh
+-   yyyy/mm/dd hh
 -   yyyy/mm/dd
 -   yyyy/mm
 -   mm/dd
 -   dd/mm/yy hh:mm:ss
+-   yyyymmdd
+-   mmddyy
 -   yyyy
+-   yy
 -   mm
 -   hh:mm:ss
+-   hh:mm
 -   mm:ss
 
 ### <span id="AddDay">AddDay</span>
@@ -98,7 +107,7 @@ import (
 func AddDay(t time.Time, day int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dIGbs_uTdFa)</span></b>
 
 ```go
 package main
@@ -137,7 +146,7 @@ func main() {
 func AddHour(t time.Time, hour int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/rcMjd7OCsi5)</span></b>
 
 ```go
 package main
@@ -176,7 +185,7 @@ func main() {
 func AddMinute(t time.Time, minute int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nT1heB1KUUK)</span></b>
 
 ```go
 package main
@@ -215,7 +224,7 @@ func main() {
 func AddYear(t time.Time, year int64) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MqW2ujnBx10)</span></b>
 
 ```go
 package main
@@ -254,7 +263,7 @@ func main() {
 func BeginOfMinute(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ieOLVJ9CiFT)</span></b>
 
 ```go
 package main
@@ -286,7 +295,7 @@ func main() {
 func BeginOfHour(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GhdGFnDWpYs)</span></b>
 
 ```go
 package main
@@ -318,7 +327,7 @@ func main() {
 func BeginOfDay(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/94m_UT6cWs9)</span></b>
 
 ```go
 package main
@@ -350,7 +359,7 @@ func main() {
 func BeginOfWeek(t time.Time, beginFrom ...time.Weekday) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ynjoJPz7VNV)</span></b>
 
 ```go
 package main
@@ -382,7 +391,7 @@ func main() {
 func BeginOfMonth(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bWXVFsmmzwL)</span></b>
 
 ```go
 package main
@@ -414,7 +423,7 @@ func main() {
 func BeginOfYear(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/i326DSwLnV8)</span></b>
 
 ```go
 package main
@@ -446,7 +455,7 @@ func main() {
 func EndOfMinute(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yrL5wGzPj4z)</span></b>
 
 ```go
 package main
@@ -478,7 +487,7 @@ func main() {
 func EndOfHour(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6ce3j_6cVqN)</span></b>
 
 ```go
 package main
@@ -510,7 +519,7 @@ func main() {
 func EndOfDay(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eMBOvmq5Ih1)</span></b>
 
 ```go
 package main
@@ -542,7 +551,7 @@ func main() {
 func EndOfWeek(t time.Time, endWith ...time.Weekday) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/i08qKXD9flf)</span></b>
 
 ```go
 package main
@@ -574,7 +583,7 @@ func main() {
 func EndOfMonth(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_GWh10B3Nqi)</span></b>
 
 ```go
 package main
@@ -606,7 +615,7 @@ func main() {
 func EndOfYear(t time.Time) time.Time
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G01cKlMCvNm)</span></b>
 
 ```go
 package main
@@ -638,7 +647,7 @@ func main() {
 func GetNowDate() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/PvfkPpcpBBf)</span></b>
 
 ```go
 package main
@@ -667,7 +676,7 @@ func main() {
 func GetNowTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/l7BNxCkTmJS)</span></b>
 
 ```go
 package main
@@ -696,7 +705,7 @@ func main() {
 func GetNowDateTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pI4AqngD0al)</span></b>
 
 ```go
 package main
@@ -725,7 +734,7 @@ func main() {
 func GetTodayStartTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/84siyYF7t99)</span></b>
 
 ```go
 package main
@@ -754,7 +763,7 @@ func main() {
 func GetTodayEndTime() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jjrLnfoqgn3)</span></b>
 
 ```go
 package main
@@ -783,7 +792,7 @@ func main() {
 func GetZeroHourTimestamp() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/QmL2oIaGE3q)</span></b>
 
 ```go
 package main
@@ -812,7 +821,7 @@ func main() {
 func GetNightTimestamp() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UolysR3MYP1)</span></b>
 
 ```go
 package main
@@ -838,10 +847,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func FormatTimeToStr(t time.Time, format string) string
+func FormatTimeToStr(t time.Time, format string, timezone ...string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_Ia7M8H_OvE)</span></b>
 
 ```go
 package main
@@ -877,10 +886,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func FormatStrToTime(str, format string) (time.Time, error)
+func FormatStrToTime(str, format string, timezone ...string) (time.Time, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1h9FwdU8ql4)</span></b>
 
 ```go
 package main
@@ -919,7 +928,7 @@ type theTime struct {
 func NewUnixNow() *theTime
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/U4PPx-9D0oz)</span></b>
 
 ```go
 package main
@@ -951,7 +960,7 @@ type theTime struct {
 func NewUnix(unix int64) *theTime
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/psoSuh_kLRt)</span></b>
 
 ```go
 package main
@@ -983,7 +992,7 @@ type theTime struct {
 func NewFormat(t string) (*theTime, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1015,7 +1024,7 @@ type theTime struct {
 func NewISO8601(iso8601 string) (*theTime, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1044,7 +1053,7 @@ func main() {
 func (t *theTime) ToUnix() int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_LUiwAdocjy)</span></b>
 
 ```go
 package main
@@ -1073,7 +1082,7 @@ func main() {
 func (t *theTime) ToFormat() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VkW08ZOaXPZ)</span></b>
 
 ```go
 package main
@@ -1102,7 +1111,7 @@ func main() {
 func (t *theTime) ToFormatForTpl(tpl string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nyXxXcQJ8L5)</span></b>
 
 ```go
 package main
@@ -1132,7 +1141,7 @@ func main() {
 func (t *theTime) ToIso8601() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mkhOHQkdeA2)</span></b>
 
 ```go
 package main
@@ -1162,7 +1171,7 @@ func main() {
 func IsLeapYear(year int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xS1eS2ejGew)</span></b>
 
 ```go
 package main
@@ -1185,7 +1194,6 @@ func main() {
 }
 ```
 
-
 ### <span id="BetweenSeconds">BetweenSeconds</span>
 
 <p>Return the number of seconds between two times.</p>
@@ -1196,7 +1204,7 @@ func main() {
 func BetweenSeconds(t1 time.Time, t2 time.Time) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/n3YDRyfyXJu)</span></b>
 
 ```go
 package main
@@ -1223,7 +1231,6 @@ func main() {
 }
 ```
 
-
 ### <span id="DayOfYear">DayOfYear</span>
 
 <p>Returns which day of the year the parameter date `t` is.</p>
@@ -1234,7 +1241,7 @@ func main() {
 func DayOfYear(t time.Time) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/0hjqhTwFNlH)</span></b>
 
 ```go
 package main
@@ -1265,8 +1272,7 @@ func main() {
 }
 ```
 
-
-### <span id="IsWeekend">IsWeekend</span>
+### <span id="IsWeekend">IsWeekend(Deprecated, Use '== Weekday' instead)</span>
 
 <p>Checks if passed time is weekend or not.</p>
 
@@ -1276,7 +1282,7 @@ func main() {
 func IsWeekend(t time.Time) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cupRM5aZOIY)</span></b>
 
 ```go
 package main
@@ -1305,3 +1311,157 @@ func main() {
     // false
 }
 ```
+
+### <span id="NowDateOrTime">NowDateOrTime</span>
+
+<p>Return current datetime with specific format and timezone.</p>
+
+<b>Signature:</b>
+
+```go
+func NowDateOrTime(format string, timezone ...string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EZ-begEjtT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    result1 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss")
+
+	result2 := datetime.NowDateOrTime("yyyy-mm-dd hh:mm:ss", "EST")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 2023-07-26 15:01:30
+    // 2023-07-26 02:01:30
+}
+```
+
+### <span id="Timestamp">Timestamp</span>
+
+<p>Return current second timestamp.</p>
+
+<b>Signature:</b>
+
+```go
+func Timestamp(timezone ...string) int64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/iU5b7Vvjx6x)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.Timestamp()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051
+}
+```
+
+### <span id="TimestampMilli">TimestampMilli</span>
+
+<p>Return current mill second timestamp.</p>
+
+<b>Signature:</b>
+
+```go
+func TimestampMilli(timezone ...string) int64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4gvEusOTu1T)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampMilli()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331
+}
+```
+
+### <span id="TimestampMicro">TimestampMicro</span>
+
+<p>Return current micro second timestamp.</p>
+
+<b>Signature:</b>
+
+```go
+func TimestampMicro(timezone ...string) int64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2maANglKHQE)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampMicro()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331784
+}
+```
+
+### <span id="TimestampNano">TimestampNano</span>
+
+<p>Return current nano second timestamp.</p>
+
+<b>Signature:</b>
+
+```go
+func TimestampNano(timezone ...string) int64
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/A9Oq_COrcCF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/datetime"
+)
+
+func main() {
+    ts := datetime.TimestampNano()
+
+    fmt.Println(ts)
+
+    // Output:
+    // 1690363051331788000
+}
+```

docs/en/api/packages/fileutil.md

@@ -47,6 +47,7 @@ import (
 -   [WriteCsvFile](#WriteCsvFile)
 -   [WriteStringToFile](#WriteStringToFile)
 -   [WriteBytesToFile](#WriteBytesToFile)
+-   [ReadFile](#ReadFile)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -62,7 +63,7 @@ import (
 func ClearFile(path string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/NRZ0ZT-G94H)</span></b>
 
 ```go
 package main
@@ -90,7 +91,7 @@ func main() {
 func CreateFile(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lDt8PEsTNKI)</span></b>
 
 ```go
 package main
@@ -108,7 +109,7 @@ func main() {
 
 ### <span id="CreateDir">CreateDir</span>
 
-<p>Create directory in absolute path. param `absPath` like /a/, /a/b/.</p>
+<p>Create directory in absolute path. param `absPath` like /a, /a/b.</p>
 
 <b>Signature:</b>
 
@@ -116,7 +117,7 @@ func main() {
 func CreateDir(absPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qUuCe1OGQnM)</span></b>
 
 ```go
 package main
@@ -127,7 +128,7 @@ import (
 )
 
 func main() {
-    err := fileutil.CreateDir("/a/")
+    err := fileutil.CreateDir("/a/b") // will create folder /a/b
     fmt.Println(err)
 }
 ```
@@ -142,7 +143,7 @@ func main() {
 func CopyFile(srcPath string, dstPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Jg9AMJMLrJi)</span></b>
 
 ```go
 package main
@@ -170,7 +171,7 @@ func main() {
 func CurrentPath() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s74a9iBGcSw)</span></b>
 
 ```go
 package main
@@ -196,7 +197,7 @@ func main() {
 func FileMode(path string) (fs.FileMode, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2l2hI42fA3p)</span></b>
 
 ```go
 package main
@@ -225,7 +226,7 @@ func main() {
 func MiMeType(file any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bd5sevSUZNu)</span></b>
 
 ```go
 package main
@@ -256,7 +257,7 @@ func main() {
 func IsExist(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nKKXt8ZQbmh)</span></b>
 
 ```go
 package main
@@ -283,7 +284,7 @@ func main() {
 func IsLink(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TL-b-Kzvf44)</span></b>
 
 ```go
 package main
@@ -309,7 +310,7 @@ func main() {
 func IsDir(path string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/WkVwEKqtOWk)</span></b>
 
 ```go
 package main
@@ -338,7 +339,7 @@ func main() {
 func ListFileNames(path string) ([]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Tjd7Y07rejl)</span></b>
 
 ```go
 package main
@@ -364,7 +365,7 @@ func main() {
 func RemoveFile(path string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P2y0XW8a1SH)</span></b>
 
 ```go
 package main
@@ -392,7 +393,7 @@ func main() {
 func ReadFileToString(path string) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cmfwp_5SQTp)</span></b>
 
 ```go
 package main
@@ -425,7 +426,7 @@ func main() {
 func ReadFileByLine(path string)([]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/svJP_7ZrBrD)</span></b>
 
 ```go
 package main
@@ -459,7 +460,7 @@ func main() {
 func Zip(fpath string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/j-3sWBp8ik_P)</span></b>
 
 ```go
 package main
@@ -487,7 +488,7 @@ func main() {
 func ZipAppendEntry(fpath string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cxvaT8TRNQp)</span></b>
 
 ```go
 package main
@@ -515,7 +516,7 @@ func main() {
 func UnZip(zipFile string, destPath string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g0w34kS7B8m)</span></b>
 
 ```go
 package main
@@ -543,7 +544,7 @@ func main() {
 func IsZipFile(filepath string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9M0g2j_uF_e)</span></b>
 
 ```go
 package main
@@ -569,7 +570,7 @@ func main() {
 func FileSize(path string) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/H9Z05uD-Jjc)</span></b>
 
 ```go
 package main
@@ -601,7 +602,7 @@ func main() {
 func MTime(filepath string) (int64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s_Tl7lZoAaY)</span></b>
 
 ```go
 package main
@@ -633,7 +634,7 @@ func main() {
 func Sha(filepath string, shaType ...int) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VfEEcO2MJYf)</span></b>
 
 ```go
 package main
@@ -671,7 +672,7 @@ func main() {
 func ReadCsvFile(filepath string) ([][]string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OExTkhGEd3_u)</span></b>
 
 ```go
 package main
@@ -703,7 +704,7 @@ func main() {
 func WriteCsvFile(filepath string, records [][]string, append bool) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dAXm58Q5U1o)</span></b>
 
 ```go
 package main
@@ -752,7 +753,7 @@ func main() {
 func WriteBytesToFile(filepath string, content []byte) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s7QlDxMj3P8)</span></b>
 
 ```go
 package main
@@ -801,7 +802,7 @@ func main() {
 func WriteStringToFile(filepath string, content string, append bool) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GhLS6d8lH_g)</span></b>
 
 ```go
 package main
@@ -839,3 +840,41 @@ func main() {
     // hello
 }
 ```
+
+### <span id="ReadFile">ReadFile</span>
+
+<p>Read File or URL.</p>
+
+<b>Signature:</b>
+
+```go
+func ReadFile(path string) (reader io.ReadCloser, closeFn func(), err error) 
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uNep3Tr8fqF)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/fileutil"
+)
+
+func main() {
+    reader, fn, err := fileutil.ReadFile("https://httpbin.org/robots.txt")
+    if err != nil {
+        return
+    }
+    defer fn()
+
+    dat, err := io.ReadAll(reader)
+    if err != nil {
+        return
+    }
+    fmt.Println(string(dat))
+    // Output:
+    // User-agent: *
+    // Disallow: /deny
+}
+```

docs/en/api/packages/formatter.md

@@ -45,7 +45,7 @@ import (
 func Comma[T constraints.Float | constraints.Integer | string](value T, symbol string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -81,7 +81,7 @@ func main() {
 func Pretty(v any) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YsciGj3FH2x)</span></b>
 
 ```go
 package main
@@ -120,7 +120,7 @@ func main() {
 func PrettyToWriter(v any, out io.Writer) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/LPLZ3lDi5ma)</span></b>
 
 ```go
 package main
@@ -163,7 +163,7 @@ func main() {
 func DecimalBytes(size float64, precision ...int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FPXs1suwRcs)</span></b>
 
 ```go
 package main
@@ -202,7 +202,7 @@ func main() {
 func BinaryBytes(size float64, precision ...int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/G9oHHMCAZxP)</span></b>
 
 ```go
 package main
@@ -241,7 +241,7 @@ func main() {
 func ParseDecimalBytes(size string) (uint64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Am98ybWjvjj)</span></b>
 
 ```go
 package main
@@ -280,7 +280,7 @@ func main() {
 func ParseBinaryBytes(size string) (uint64, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/69v1tTT62x8)</span></b>
 
 ```go
 package main

docs/en/api/packages/function.md

@@ -47,7 +47,7 @@ import (
 func After(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eRD5k2vzUVX)</span></b>
 
 ```go
 package main
@@ -80,7 +80,7 @@ func main() {
 func Before(n int, fn any) func(args ...any) []reflect.Value
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/0HqUDIFZ3IL)</span></b>
 
 ```go
 package main
@@ -88,7 +88,6 @@ package main
 import (
     "fmt"
     "github.com/duke-git/lancet/v2/function"
-    "github.com/duke-git/lancet/v2/internal"
 )
 
 func main() {
@@ -118,7 +117,7 @@ type CurryFn[T any] func(...T) T
 func (cf CurryFn[T]) New(val T) func(...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5HopfDwANKX)</span></b>
 
 ```go
 package main
@@ -157,7 +156,7 @@ func main() {
 func Compose[T any](fnList ...func(...T) T) func(...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KKfugD4PKYF)</span></b>
 
 ```go
 package main
@@ -195,7 +194,7 @@ func main() {
 func Debounced(fn func(), duration time.Duration) func()
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/absuEGB_GN7)</span></b>
 
 ```go
 package main
@@ -245,7 +244,7 @@ func main() {
 func Delay(delay time.Duration, fn any, args ...any)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ivtc2ZE-Tye)</span></b>
 
 ```go
 package main
@@ -277,7 +276,7 @@ func main() {
 func Schedule(d time.Duration, fn any, args ...any) chan bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hbON-Xeyn5N)</span></b>
 
 ```go
 package main
@@ -317,7 +316,7 @@ the functions one by one.</p>
 func Pipeline[T any](funcs ...func(T) T) func(T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mPdUVvj6HD6)</span></b>
 
 ```go
 package main
@@ -368,7 +367,7 @@ func (w *Watcher) Reset() //reset the watcher
 func (w *Watcher) GetElapsedTime() time.Duration //get the elapsed time of function execution
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/l2yrOpCLd1I)</span></b>
 
 ```go
 package main
@@ -379,7 +378,7 @@ import (
 )
 
 func main() {
-       w := function.NewWatcher()
+    w := function.NewWatcher()
 
     w.Start()
 

docs/en/api/packages/maputil.md

@@ -43,12 +43,20 @@ import (
 -   [Merge](#Merge)
 -   [Minus](#Minus)
 -   [IsDisjoint](#IsDisjoint)
+-   [HasKey](#HasKey)
+-   [NewConcurrentMap](#NewConcurrentMap)
+-   [ConcurrentMap_Get](#ConcurrentMap_Get)
+-   [ConcurrentMap_Set](#ConcurrentMap_Set)
+-   [ConcurrentMap_GetOrSet](#ConcurrentMap_GetOrSet)
+-   [ConcurrentMap_Delete](#ConcurrentMap_Delete)
+-   [ConcurrentMap_GetAndDelete](#ConcurrentMap_GetAndDelete)
+-   [ConcurrentMap_Has](#ConcurrentMap_Has)
+-   [ConcurrentMap_Range](#ConcurrentMap_Range)
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
 
-
 ### <span id="MapTo">MapTo</span>
 
 <p>Rry to map any interface to struct or base type.</p>
@@ -59,7 +67,7 @@ import (
 func MapTo(src any, dst any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4K7KBEPgS5M)</span></b>
 
 ```go
 package main
@@ -116,7 +124,7 @@ func main() {
 func ForEach[K comparable, V any](m map[K]V, iteratee func(key K, value V))
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OaThj6iNVXK)</span></b>
 
 ```go
 package main
@@ -157,7 +165,7 @@ func main() {
 func Filter[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fSvF3wxuNG7)</span></b>
 
 ```go
 package main
@@ -202,7 +210,7 @@ func main() {
 func FilterByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7ov6BJHbVqh)</span></b>
 
 ```go
 package main
@@ -240,7 +248,7 @@ func main() {
 func FilterByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P3-9MdcXegR)</span></b>
 
 ```go
 package main
@@ -278,7 +286,7 @@ func main() {
 func OmitBy[K comparable, V any](m map[K]V, predicate func(key K, value V) bool) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YJM4Hj5hNwm)</span></b>
 
 ```go
 package main
@@ -319,7 +327,7 @@ func main() {
 func OmitByKeys[K comparable, V any](m map[K]V, keys []K) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jXGrWDBfSRp)</span></b>
 
 ```go
 package main
@@ -357,7 +365,7 @@ func main() {
 func OmitByValues[K comparable, V comparable](m map[K]V, values []V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XB7Y10uw20_U)</span></b>
 
 ```go
 package main
@@ -395,7 +403,7 @@ func main() {
 func Intersect[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Zld0oj3sjcC)</span></b>
 
 ```go
 package main
@@ -450,7 +458,7 @@ func main() {
 func Keys[K comparable, V any](m map[K]V) []K
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xNB5bTb97Wd)</span></b>
 
 ```go
 package main
@@ -490,7 +498,7 @@ func main() {
 func Merge[K comparable, V any](maps ...map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/H95LENF1uB-)</span></b>
 
 ```go
 package main
@@ -529,7 +537,7 @@ func main() {
 func Minus[K comparable, V any](mapA, mapB map[K]V) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3u5U9K7YZ9m)</span></b>
 
 ```go
 package main
@@ -571,7 +579,7 @@ func main() {
 func Values[K comparable, V any](m map[K]V) []V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CBKdUc5FTW6)</span></b>
 
 ```go
 package main
@@ -611,7 +619,7 @@ func main() {
 func KeysBy[K comparable, V any, T any](m map[K]V, mapper func(item K) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hI371iB8Up8)</span></b>
 
 ```go
 package main
@@ -652,7 +660,7 @@ func main() {
 func ValuesBy[K comparable, V any, T any](m map[K]V, mapper func(item V) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sg9-oRidh8f)</span></b>
 
 ```go
 package main
@@ -701,7 +709,7 @@ func main() {
 func MapKeys[K comparable, V any, T comparable](m map[K]V, iteratee func(key K, value V) T) map[T]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8scDxWeBDKd)</span></b>
 
 ```go
 package main
@@ -740,7 +748,7 @@ func main() {
 func MapValues[K comparable, V any, T any](m map[K]V, iteratee func(key K, value V) T) map[K]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g92aY3fc7Iw)</span></b>
 
 ```go
 package main
@@ -783,7 +791,7 @@ type Entry[K comparable, V any] struct {
 func Entries[K comparable, V any](m map[K]V) []Entry[K, V]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ltb11LNcElY)</span></b>
 
 ```go
 package main
@@ -828,7 +836,7 @@ type Entry[K comparable, V any] struct {
 func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fTdu4sCNjQO)</span></b>
 
 ```go
 package main
@@ -862,7 +870,7 @@ func main() {
 func Transform[K1 comparable, V1 any, K2 comparable, V2 any](m map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P6ovfToM3zj)</span></b>
 
 ```go
 package main
@@ -893,7 +901,7 @@ func main() {
 
 ### <span id="IsDisjoint">IsDisjoint</span>
 
-<p>Checks two maps are disjoint if they have no keys in common</p>
+<p>Checks two maps are disjoint if they have no keys in common.</p>
 
 <b>Signature:</b>
 
@@ -901,7 +909,7 @@ func main() {
 func IsDisjoint[K comparable, V any](mapA, mapB map[K]V) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -937,3 +945,418 @@ func main() {
     // false
 }
 ```
+
+### <span id="HasKey">HasKey</span>
+
+<p>Checks if map has key or not. This function is used to replace the following boilerplate code:</p>
+
+```go
+_, haskey := amap["baz"];
+
+if haskey {
+    fmt.Println("map has key baz")
+}
+```
+
+<b>Signature:</b>
+
+```go
+func HasKey[K comparable, V any](m map[K]V, key K) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/isZZHOsDhFc)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    m := map[string]int{
+        "a": 1,
+        "b": 2,
+    }
+
+    result1 := maputil.HasKey(m, "a")
+    result2 := maputil.HasKey(m, "c")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="NewConcurrentMap">NewConcurrentMap</span>
+
+<p>ConcurrentMap is like map, but is safe for concurrent use by multiple goroutines.</p>
+
+<b>Signature:</b>
+
+```go
+// NewConcurrentMap create a ConcurrentMap with specific shard count.
+func NewConcurrentMap[K comparable, V any](shardCount int) *ConcurrentMap[K, V]
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    // create a ConcurrentMap whose key type is string, value type is int
+    cm := maputil.NewConcurrentMap[string, int](100)
+}
+```
+
+### <span id="ConcurrentMap_Set">ConcurrentMap_Set</span>
+
+<p>Set the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Set(key K, value V)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+	for j := 0; j < 5; j++ {
+		go func(n int) {
+			val, ok := cm.Get(fmt.Sprintf("%d", n))
+			fmt.Println(val, ok)
+			wg2.Done()
+		}(j)
+	}
+	wg2.Wait()
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_Get">ConcurrentMap_Get</span>
+
+<p>Get the value stored in the map for a key, or nil if no.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Get(key K) (V, bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/3PenTPETJT0)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+	for j := 0; j < 5; j++ {
+		go func(n int) {
+			val, ok := cm.Get(fmt.Sprintf("%d", n))
+			fmt.Println(val, ok)
+			wg2.Done()
+		}(j)
+	}
+	wg2.Wait()
+
+    // output: (order may change)
+    // 1 true
+    // 3 true
+    // 2 true
+    // 0 true
+    // 4 true
+}
+```
+
+### <span id="ConcurrentMap_GetOrSet">ConcurrentMap_GetOrSet</span>
+
+<p>Returns the existing value for the key if present. Otherwise, it sets and returns the given value.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetOrSet(key K, value V) (actual V, ok bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/aDcDApOK01a)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg sync.WaitGroup
+    wg.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            val, ok := cm.GetOrSet(fmt.Sprintf("%d", n), n)
+            fmt.Println(val, ok)
+            wg.Done()
+        }(i)
+    }
+    wg.Wait()
+
+    // output: (order may change)
+    // 1 false
+    // 3 false
+    // 2 false
+    // 0 false
+    // 4 false
+}
+```
+
+### <span id="ConcurrentMap_Delete">ConcurrentMap_Delete</span>
+
+<p>Delete the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Delete(key K)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uTIJZYhpVMS)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            cm.Delete(fmt.Sprintf("%d", n))
+            wg2.Done()
+        }(j)
+    }
+
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_GetAndDelete">ConcurrentMap_GetAndDelete</span>
+
+<p>Returns the existing value for the key if present and then delete the value for the key. Otherwise, do nothing, just return false.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) GetAndDelete(key K) (actual V, ok bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ZyxeIXSZUiM)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            val, ok := cm.GetAndDelete(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //n, true
+
+            _, ok = cm.Get(fmt.Sprintf("%d", n))
+            fmt.Println(val, ok) //false
+
+            wg2.Done()
+        }(j)
+    }
+
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_Has">ConcurrentMap_Has</span>
+
+<p>Checks if map has the value for a key.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Has(key K) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/C8L4ul9TVwf)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+    var wg2 sync.WaitGroup
+	wg2.Add(5)
+    for j := 0; j < 5; j++ {
+        go func(n int) {
+            ok := cm.Has(fmt.Sprintf("%d", n))
+            fmt.Println(ok) // true
+            wg2.Done()
+        }(j)
+    }
+    wg2.Wait()
+}
+```
+
+### <span id="ConcurrentMap_Range">ConcurrentMap_Range</span>
+
+<p>Calls iterator sequentially for each key and value present in each of the shards in the map. If iterator returns false, range stops the iteration.</p>
+
+<b>Signature:</b>
+
+```go
+func (cm *ConcurrentMap[K, V]) Range(iterator func(key K, value V) bool)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/iqcy7P8P0Pr)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/maputil"
+)
+
+func main() {
+    cm := maputil.NewConcurrentMap[string, int](100)
+
+    var wg1 sync.WaitGroup
+    wg1.Add(5)
+
+    for i := 0; i < 5; i++ {
+        go func(n int) {
+            cm.Set(fmt.Sprintf("%d", n), n)
+            wg1.Done()
+        }(i)
+    }
+    wg1.Wait()
+
+
+    cm.Range(func(key string, value int) bool {
+        fmt.Println(value)
+        return true
+    })
+}
+```

docs/en/api/packages/mathutil.md

@@ -48,7 +48,6 @@ import (
 -   [Sum](#Sum)
 -   [Abs](#Abs)
 
-
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation
@@ -63,7 +62,7 @@ import (
 func Average[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Vv7LBwER-pz)</span></b>
 
 ```go
 package main
@@ -98,7 +97,7 @@ func main() {
 func Exponent(x, n int64) int64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uF3HGNPk8wr)</span></b>
 
 ```go
 package main
@@ -134,7 +133,7 @@ func main() {
 func Fibonacci(first, second, n int) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IscseUNMuUc)</span></b>
 
 ```go
 package main
@@ -170,7 +169,7 @@ func main() {
 func Factorial(x uint) uint
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tt6LdOK67Nx)</span></b>
 
 ```go
 package main
@@ -206,7 +205,7 @@ func main() {
 func Max[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cN8DHI0rTkH)</span></b>
 
 ```go
 package main
@@ -239,7 +238,7 @@ func main() {
 func MaxBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pbe2MT-7DV2)</span></b>
 
 ```go
 package main
@@ -283,7 +282,7 @@ func main() {
 func Min[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/21BER_mlGUj)</span></b>
 
 ```go
 package main
@@ -316,7 +315,7 @@ func main() {
 func MinBy[T any](slice []T, comparator func(T, T) bool) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/N9qgYg_Ho6f)</span></b>
 
 ```go
 package main
@@ -360,7 +359,7 @@ func main() {
 func Percent(val, total float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/s0NdFCtwuyd)</span></b>
 
 ```go
 package main
@@ -396,7 +395,7 @@ func main() {
 func RoundToFloat(x float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ghyb528JRJL)</span></b>
 
 ```go
 package main
@@ -432,7 +431,7 @@ func main() {
 func RoundToString(x float64, n int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/kZwpBRAcllO)</span></b>
 
 ```go
 package main
@@ -468,7 +467,7 @@ func main() {
 func TruncRound(x float64, n int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/aumarSHIGzP)</span></b>
 
 ```go
 package main
@@ -504,7 +503,7 @@ func main() {
 func Range[T constraints.Integer | constraints.Float](start T, count int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9ke2opxa8ZP)</span></b>
 
 ```go
 package main
@@ -543,7 +542,7 @@ func main() {
 func RangeWithStep[T constraints.Integer | constraints.Float](start, end, step T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/akLWz0EqOSM)</span></b>
 
 ```go
 package main
@@ -582,7 +581,7 @@ func main() {
 func AngleToRadian(angle float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CIvlICqrHql)</span></b>
 
 ```go
 package main
@@ -618,7 +617,7 @@ func main() {
 func RadianToAngle(radian float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dQtmOTUOMgi)</span></b>
 
 ```go
 package main
@@ -654,7 +653,7 @@ func main() {
 func PointDistance(x1, y1, x2, y2 float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RrG4JIaziM8)</span></b>
 
 ```go
 package main
@@ -684,7 +683,7 @@ func main() {
 func IsPrime(n int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Rdd8UTHZJ7u)</span></b>
 
 ```go
 package main
@@ -723,7 +722,7 @@ func main() {
 func GCD[T constraints.Integer](integers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CiEceLSoAKB)</span></b>
 
 ```go
 package main
@@ -765,7 +764,7 @@ func main() {
 func LCM[T constraints.Integer](integers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EjcZxfY7G_g)</span></b>
 
 ```go
 package main
@@ -791,7 +790,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Cos">Cos</span>
 
 <p>Returns the cosine of the radian argument.</p>
@@ -802,7 +800,7 @@ func main() {
 func Cos(radian float64, precision ...int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Sm89LoIfvFq)</span></b>
 
 ```go
 package main
@@ -834,7 +832,6 @@ func main() {
 }
 ```
 
-
 ### <span id="Sin">Sin</span>
 
 <p>Returns the sine of the radian argument.</p>
@@ -845,7 +842,7 @@ func main() {
 func Sin(radian float64, precision ...int) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/TWMQlMywDsP)</span></b>
 
 ```go
 package main
@@ -887,7 +884,7 @@ func main() {
 func Log(n, base float64) float64
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_d4bi8oyhat)</span></b>
 
 ```go
 package main
@@ -923,7 +920,7 @@ func main() {
 func Sum[T constraints.Integer | constraints.Float](numbers ...T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1To2ImAMJA7)</span></b>
 
 ```go
 package main
@@ -956,7 +953,7 @@ func main() {
 func Abs[T constraints.Integer | constraints.Float](x T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fsyBh1Os-1d)</span></b>
 
 ```go
 package main
@@ -980,4 +977,4 @@ func main() {
 	// 0.1
 	// 0.2
 }
-```
+```

docs/en/api/packages/netutil.md

@@ -51,6 +51,8 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+<link rel="stylesheet" type="text/css" href="/styles/api_doc.css">
+
 ## Documentation
 
 ### <span id="ConvertMapToQueryString">ConvertMapToQueryString</span>
@@ -63,7 +65,7 @@ import (
 func ConvertMapToQueryString(param map[string]any) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jnNt_qoSnRi)</span></b>
 
 ```go
 package main
@@ -96,7 +98,7 @@ func main() {
 func EncodeUrl(urlStr string) (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bsZ6BRC4uKI)</span></b>
 
 ```go
 package main
@@ -131,7 +133,7 @@ func main() {
 func GetInternalIp() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5mbu-gFp7ei)</span></b>
 
 ```go
 package main
@@ -163,7 +165,7 @@ func main() {
 func GetIps() []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/NUFfcEmukx1)</span></b>
 
 ```go
 package main
@@ -193,7 +195,7 @@ func main() {
 func GetMacAddrs() []string {
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Rq9UUBS_Xp1)</span></b>
 
 ```go
 package main
@@ -237,7 +239,7 @@ type PublicIpInfo struct {
 }
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YDxIfozsRHR)</span></b>
 
 ```go
 package main
@@ -267,7 +269,7 @@ func main() {
 func GetRequestPublicIp(req *http.Request) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/kxU-YDc_eBo)</span></b>
 
 ```go
 package main
@@ -305,7 +307,7 @@ func main() {
 func IsPublicIP(IP net.IP) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nmktSQpJZnn)</span></b>
 
 ```go
 package main
@@ -342,7 +344,7 @@ func main() {
 func IsInternalIP(IP net.IP) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sYGhXbgO4Cb)</span></b>
 
 ```go
 package main
@@ -386,7 +388,7 @@ type HttpRequest struct {
 }
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -443,7 +445,7 @@ func NewHttpClientWithConfig(config *HttpClientConfig) *HttpClient
 
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -474,7 +476,7 @@ func main() {
 func (client *HttpClient) SendRequest(request *HttpRequest) (*http.Response, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -528,7 +530,7 @@ func main() {
 func (client *HttpClient) DecodeResponse(resp *http.Response, target any) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jUSgynekH7G)</span></b>
 
 ```go
 package main
@@ -582,7 +584,7 @@ func main() {
 func StructToUrlValues(targetStruct any) url.Values
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pFqMkM40w9z)</span></b>
 
 ```go
 package main
@@ -964,7 +966,7 @@ func main() {
 func IsPingConnected(host string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/q8OzTijsA87)</span></b>
 
 ```go
 package main
@@ -997,7 +999,7 @@ func main() {
 func IsTelnetConnected(host string, port string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yiLCGtQv_ZG)</span></b>
 
 ```go
 package main

docs/en/api/packages/pointer.md

@@ -0,0 +1,229 @@
+# Pointer
+
+pointer contains some util functions to operate go pointer.
+
+<div STYLE="page-break-after: always;"></div>
+
+## Source:
+
+-   [https://github.com/duke-git/lancet/blob/main/pointer/pointer.go](https://github.com/duke-git/lancet/blob/main/pointer/pointer.go)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Usage:
+
+```go
+import (
+    "github.com/duke-git/lancet/v2/pointer"
+)
+```
+
+<div STYLE="page-break-after: always;"></div>
+
+## Index
+
+-   [Of](#Of)
+-   [Unwrap](#Unwrap)
+-   [UnwarpOr](#UnwarpOr)
+-   [UnwarpOrDefault](#UnwarpOrDefault)
+-   [ExtractPointer](#ExtractPointer)
+
+<div STYLE="page-break-after: always;"></div>
+
+## Documentation
+
+### <span id="Of">Of</span>
+
+<p>Returns a pointer to the pass value `v`.</p>
+
+<b>Signature:</b>
+
+```go
+func Of[T any](v T) *T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HFd70x4DrMj)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    result1 := pointer.Of(123)
+    result2 := pointer.Of("abc")
+
+    fmt.Println(*result1)
+    fmt.Println(*result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+
+### <span id="Unwrap">Unwrap</span>
+
+<p>Returns the value from the pointer.</p>
+
+<b>Signature:</b>
+
+```go
+func Unwrap[T any](p *T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/cgeu3g7cjWb)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 123
+    b := "abc"
+
+    result1 := pointer.Unwrap(&a)
+    result2 := pointer.Unwrap(&b)
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 123
+    // abc
+}
+```
+
+
+### <span id="UnwarpOr">UnwarpOr</span>
+
+<p>Returns the value from the pointer or fallback if the pointer is nil.</p>
+
+<b>Signature:</b>
+```go
+UnwarpOr[T any](p *T, fallback T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/mmNaLC38W8C)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOr(&a, 456)
+	result2 := pointer.UnwarpOr(&b, "abc")
+	result3 := pointer.UnwarpOr(c, 456)
+	result4 := pointer.UnwarpOr(d, "def")
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 456
+	// def
+}
+```
+
+
+### <span id="UnwarpOrDefault">UnwarpOrDefault</span>
+
+<p>Returns the value from the pointer or the default value if the pointer is nil.</p>
+
+<b>Signature:</b>
+```go
+UnwarpOrDefault[T any](p *T) T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ZnGIHf8_o4E)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+	a := 123
+	b := "abc"
+
+	var c *int
+	var d *string
+
+	result1 := pointer.UnwarpOrDefault(&a)
+	result2 := pointer.UnwarpOrDefault(&b)
+	result3 := pointer.UnwarpOrDefault(c)
+	result4 := pointer.UnwarpOrDefault(d)
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+	fmt.Println(result4)
+
+	// Output:
+	// 123
+	// abc
+	// 0
+	//
+}
+```
+
+
+### <span id="ExtractPointer">ExtractPointer</span>
+
+<p>Returns the underlying value by the given interface type</p>
+
+<b>Signature:</b>
+
+```go
+func ExtractPointer(value any) any
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/D7HFjeWU2ZP)</span></b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/pointer"
+)
+
+func main() {
+    a := 1
+    b := &a
+    c := &b
+    d := &c
+
+    result := pointer.ExtractPointer(d)
+
+    fmt.Println(result)
+
+    // Output:
+    // 1
+}
+```

docs/en/api/packages/random.md

@@ -29,8 +29,11 @@ import (
 -   [RandLower](#RandLower)
 -   [RandNumeral](#RandNumeral)
 -   [RandNumeralOrLetter](#RandNumeralOrLetter)
+-   [RandSymbolChar](#RandSymbolChar)
 -   [UUIdV4](#UUIdV4)
 -   [RandUniqueIntSlice](#RandUniqueIntSlice)
+-   [RandFloat](#RandFloat)
+-   [RandFloats](#RandFloats)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -46,7 +49,7 @@ import (
 func RandBytes(length int) []byte
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/EkiLESeXf8d)</span></b>
 
 ```go
 package main
@@ -72,7 +75,7 @@ func main() {
 func RandInt(min, max int) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pXyyAAI5YxD)</span></b>
 
 ```go
 package main
@@ -98,7 +101,7 @@ func main() {
 func RandString(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/W2xvRUXA7Mi)</span></b>
 
 ```go
 package main
@@ -124,7 +127,7 @@ func main() {
 func RandUpper(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/29QfOh0DVuh)</span></b>
 
 ```go
 package main
@@ -150,7 +153,7 @@ func main() {
 func RandLower(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XJtZ471cmtI)</span></b>
 
 ```go
 package main
@@ -176,7 +179,7 @@ func main() {
 func RandNumeral(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/g4JWVpHsJcf)</span></b>
 
 ```go
 package main
@@ -202,7 +205,7 @@ func main() {
 func RandNumeralOrLetter(length int) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/19CEQvpx2jD)</span></b>
 
 ```go
 package main
@@ -218,6 +221,32 @@ func main() {
 }
 ```
 
+### <span id="RandSymbolChar">RandSymbolChar</span>
+
+<p>Generate a random symbol char of specified length. Symbol chars: !@#$%^&*()_+-=[]{}|;':\",./<>?.</p>
+
+<b>Signature:</b>
+
+```go
+func RandSymbolChar(length int) string
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    randStr := random.RandSymbolChar(6)
+    fmt.Println(randStr) //@#(_")
+}
+```
+
 ### <span id="UUIdV4">UUIdV4</span>
 
 <p>Generate a random UUID of version 4 according to RFC 4122.</p>
@@ -228,7 +257,7 @@ func main() {
 func UUIdV4() (string, error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_Z9SFmr28ft)</span></b>
 
 ```go
 package main
@@ -258,7 +287,7 @@ func main() {
 func RandUniqueIntSlice(n, min, max int) []int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uBkRSOz73Ec)</span></b>
 
 ```go
 package main
@@ -273,3 +302,55 @@ func main() {
     fmt.Println(result) //[0 4 7 1 5] (random)
 }
 ```
+
+### <span id="RandFloat">RandFloat</span>
+
+<p>Generate a random float64 number between [min, max) with specific precision.</p>
+
+<b>Signature:</b>
+
+```go
+func RandFloat(min, max float64, precision int) float64
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumber := random.RandFloat(1.0, 5.0, 2)
+    fmt.Println(floatNumber) //2.14 (random number)
+}
+```
+
+### <span id="RandFloats">RandFloats</span>
+
+<p>Generate a slice of random float64 numbers of length n that do not repeat.</p>
+
+<b>Signature:</b>
+
+```go
+func RandFloats(n int, min, max float64, precision int) []float64
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/random"
+)
+
+func main() {
+    floatNumbers := random.RandFloats(5, 1.0, 5.0, 2)
+    fmt.Println(floatNumber) //[3.42 3.99 1.3 2.38 4.23] (random)
+}
+```

docs/en/api/packages/retry.md

@@ -42,7 +42,7 @@ import (
 func Context(ctx context.Context)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xnAOOXv9GkS)</span></b>
 
 ```go
 import (
@@ -89,7 +89,7 @@ func main() {
 type RetryFunc func() error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -135,7 +135,7 @@ func main() {
 func RetryTimes(n uint)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ssfVeU2SwLO)</span></b>
 
 ```go
 package main
@@ -178,7 +178,7 @@ func main() {
 func RetryDuration(d time.Duration)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main
@@ -224,7 +224,7 @@ func main() {
 func Retry(retryFunc RetryFunc, opts ...Option) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nk2XRmagfVF)</span></b>
 
 ```go
 package main

docs/en/api/packages/slice.md

@@ -77,7 +77,7 @@ import (
 -   [IsSortedByKey](#IsSortedByKey)
 -   [Sort](#Sort)
 -   [SortBy](#SortBy)
--   [SortByField<sup>deprecated</sup>](#SortByField)
+-   [SortByField](#SortByField)
 -   [Some](#Some)
 -   [StringSlice<sup>deprecated</sup>](#StringSlice)
 -   [SymmetricDifference](#SymmetricDifference)
@@ -90,6 +90,8 @@ import (
 -   [UpdateAt](#UpdateAt)
 -   [Without](#Without)
 -   [KeyBy](#KeyBy)
+-   [Join](#Join)
+-   [Partition](#Partition)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -105,7 +107,7 @@ import (
 func AppendIfAbsent[T comparable](slice []T, item T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/GNdv7Jg2Taj)</span></b>
 
 ```go
 import (
@@ -136,7 +138,7 @@ func main() {
 func Contain[T comparable](slice []T, target T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_454yEHcNjf)</span></b>
 
 ```go
 import (
@@ -167,7 +169,7 @@ func main() {
 func ContainBy[T any](slice []T, predicate func(item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/49tkHfX4GNc)</span></b>
 
 ```go
 import (
@@ -212,7 +214,7 @@ func main() {
 func ContainSubSlice[T comparable](slice, subSlice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bcuQ3UT6Sev)</span></b>
 
 ```go
 import (
@@ -243,7 +245,7 @@ func main() {
 func Chunk[T any](slice []T, size int) [][]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/b4Pou5j2L_C)</span></b>
 
 ```go
 import (
@@ -285,7 +287,7 @@ func main() {
 func Compact[T comparable](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pO5AnxEr3TK)</span></b>
 
 ```go
 import (
@@ -322,7 +324,7 @@ func main() {
 func Concat[T any](slice []T, slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/gPt-q7zr5mk)</span></b>
 
 ```go
 import (
@@ -353,7 +355,7 @@ func main() {
 func Count[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Mj4oiEnQvRJ)</span></b>
 
 ```go
 import (
@@ -386,7 +388,7 @@ func main() {
 func CountBy[T any](slice []T, predicate func(index int, item T) bool) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tHOccTMDZCC)</span></b>
 
 ```go
 import (
@@ -420,7 +422,7 @@ func main() {
 func Difference[T comparable](slice, comparedSlice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VXvadzLzhDa)</span></b>
 
 ```go
 import (
@@ -451,7 +453,7 @@ func main() {
 func DifferenceBy[T comparable](slice []T, comparedSlice []T, iteratee func(index int, item T) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DiivgwM5OnC)</span></b>
 
 ```go
 import (
@@ -486,7 +488,7 @@ func main() {
 func DifferenceWith[T any](slice []T, comparedSlice []T, comparator func(value, otherValue T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/v2U2deugKuV)</span></b>
 
 ```go
 import (
@@ -521,7 +523,7 @@ func main() {
 func DeleteAt[T any](slice []T, start int, end ...int)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pJ-d6MUWcvK)</span></b>
 
 ```go
 import (
@@ -555,7 +557,7 @@ func main() {
 func Drop[T any](slice []T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jnPO2yQsT8H)</span></b>
 
 ```go
 import (
@@ -592,7 +594,7 @@ func main() {
 func DropRight[T any](slice []T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8bcXvywZezG)</span></b>
 
 ```go
 import (
@@ -629,7 +631,7 @@ func main() {
 func DropWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4rt252UV_qs)</span></b>
 
 ```go
 import (
@@ -669,7 +671,7 @@ func main() {
 func DropRightWhile[T any](slice []T, predicate func(item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6wyK3zMY56e)</span></b>
 
 ```go
 import (
@@ -711,7 +713,7 @@ func main() {
 func Equal[T comparable](slice1, slice2 []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/WcRQJ37ifPa)</span></b>
 
 ```go
 import (
@@ -746,7 +748,7 @@ func main() {
 func EqualWith[T, U any](slice1 []T, slice2 []U, comparator func(T, U) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/b9iygtgsHI1)</span></b>
 
 ```go
 import (
@@ -781,7 +783,7 @@ func main() {
 func Every[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/R8U6Sl-j8cD)</span></b>
 
 ```go
 import (
@@ -815,7 +817,7 @@ func main() {
 func Filter[T any](slice []T, predicate func(index int, item T) bool) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/SdPna-7qK4T)</span></b>
 
 ```go
 import (
@@ -849,7 +851,7 @@ func main() {
 func Find[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CBKeBoHVLgq)</span></b>
 
 ```go
 import (
@@ -877,7 +879,7 @@ func main() {
 
 ### <span id="FindBy">FindBy</span>
 
-<p>Iterates over elements of slice, returning the first one that passes a truth test on predicate function.If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+<p>Iterates over elements of slice, returning the first one that passes a truth test on predicate function.If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing.</p>
 
 <b>Signature:</b>
 
@@ -885,7 +887,7 @@ func main() {
 func FindBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/n1lysBYl-GB)</span></b>
 
 ```go
 import (
@@ -921,7 +923,7 @@ func main() {
 func FindLast[T any](slice []T, predicate func(index int, item T) bool) (*T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FFDPV_j7URd)</span></b>
 
 ```go
 import (
@@ -949,7 +951,7 @@ func main() {
 
 ### <span id="FindLastBy">FindLastBy</span>
 
-<p>FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing</p>
+<p>FindLastBy iterates over elements of slice, returning the last one that passes a truth test on predicate function. If return T is nil or zero value then no items matched the predicate func. In contrast to Find or FindLast, its return value no longer requires dereferencing.</p>
 
 <b>Signature:</b>
 
@@ -957,7 +959,7 @@ func main() {
 func FindLastBy[T any](slice []T, predicate func(index int, item T) bool) (v T, ok bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8iqomzyCl_s)</span></b>
 
 ```go
 import (
@@ -993,7 +995,7 @@ func main() {
 func Flatten(slice any) any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hYa3cBEevtm)</span></b>
 
 ```go
 import (
@@ -1023,7 +1025,7 @@ func main() {
 func FlattenDeep(slice any) any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/yjYNHPyCFaF)</span></b>
 
 ```go
 import (
@@ -1053,7 +1055,7 @@ func main() {
 func ForEach[T any](slice []T, iteratee func(index int, item T))
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DrPaa4YsHRF)</span></b>
 
 ```go
 import (
@@ -1088,7 +1090,7 @@ func main() {
 func ForEachWithBreak[T any](slice []T, iteratee func(index int, item T) bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qScs39f3D9W)</span></b>
 
 ```go
 import (
@@ -1126,7 +1128,7 @@ func main() {
 func GroupBy[T any](slice []T, groupFn func(index int, item T) bool) ([]T, []T)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/QVkPxzPR0iA)</span></b>
 
 ```go
 import (
@@ -1162,7 +1164,7 @@ func main() {
 func GroupWith[T any, U comparable](slice []T, iteratee func(T) U) map[U][]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ApCvMNTLO8a)</span></b>
 
 ```go
 import (
@@ -1196,7 +1198,7 @@ func main() {
 func IntSlice(slice any) []int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UQDj-on9TGN)</span></b>
 
 ```go
 import (
@@ -1225,7 +1227,7 @@ func main() {
 func InterfaceSlice(slice any) []any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/FdQXF0Vvqs-)</span></b>
 
 ```go
 import (
@@ -1254,7 +1256,7 @@ func main() {
 func Intersection[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/anJXfB5wq_t)</span></b>
 
 ```go
 import (
@@ -1285,7 +1287,7 @@ func main() {
 func InsertAt[T any](slice []T, index int, value any) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hMLNxPEGJVE)</span></b>
 
 ```go
 import (
@@ -1325,7 +1327,7 @@ func main() {
 func IndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MRN1f0FpABb)</span></b>
 
 ```go
 import (
@@ -1358,7 +1360,7 @@ func main() {
 func LastIndexOf[T comparable](slice []T, item T) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DokM4cf1IKH)</span></b>
 
 ```go
 import (
@@ -1391,7 +1393,7 @@ func main() {
 func Map[T any, U any](slice []T, iteratee func(index int, item T) U) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/biaTefqPquw)</span></b>
 
 ```go
 import (
@@ -1425,7 +1427,7 @@ func main() {
 func FilterMap[T any, U any](slice []T, iteratee func(index int, item T) (U, bool)) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/J94SZ_9MiIe)</span></b>
 
 ```go
 import (
@@ -1462,7 +1464,7 @@ func main() {
 func FlatMap[T any, U any](slice []T, iteratee func(index int, item T) []U) []U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_QARWlWs1N_F)</span></b>
 
 ```go
 import (
@@ -1495,7 +1497,7 @@ func main() {
 func Merge[T any](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lbjFp784r9N)</span></b>
 
 ```go
 import (
@@ -1526,7 +1528,7 @@ func main() {
 func Reverse[T any](slice []T)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8uI8f1lwNrQ)</span></b>
 
 ```go
 import (
@@ -1556,7 +1558,7 @@ func main() {
 func Reduce[T any](slice []T, iteratee func(index int, item1, item2 T) T, initial T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/_RfXJJWIsIm)</span></b>
 
 ```go
 import (
@@ -1590,7 +1592,7 @@ func main() {
 func ReduceBy[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YKDpLi7gtee)</span></b>
 
 ```go
 import (
@@ -1626,7 +1628,7 @@ func main() {
 func ReduceRight[T any, U any](slice []T, initial U, reducer func(index int, item T, agg U) U) U
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qT9dZC03A1K)</span></b>
 
 ```go
 import (
@@ -1656,7 +1658,7 @@ func main() {
 func Replace[T comparable](slice []T, old T, new T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/P5mZp7IhOFo)</span></b>
 
 ```go
 import (
@@ -1698,7 +1700,7 @@ func main() {
 func ReplaceAll[T comparable](slice []T, old T, new T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CzqXMsuYUrx)</span></b>
 
 ```go
 import (
@@ -1726,7 +1728,7 @@ func main() {
 func Repeat[T any](item T, n int) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -1754,7 +1756,7 @@ func main() {
 func Shuffle[T any](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YHvhnWGU3Ge)</span></b>
 
 ```go
 import (
@@ -1783,7 +1785,7 @@ func main() {
 func IsAscending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9CtsFjet4SH)</span></b>
 
 ```go
 import (
@@ -1817,7 +1819,7 @@ func main() {
 func IsDescending[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/U_LljFXma14)</span></b>
 
 ```go
 import (
@@ -1851,7 +1853,7 @@ func main() {
 func IsSorted[T constraints.Ordered](slice []T) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/nCE8wPLwSA-)</span></b>
 
 ```go
 import (
@@ -1885,7 +1887,7 @@ func main() {
 func IsSortedByKey[T any, K constraints.Ordered](slice []T, iteratee func(item T) K) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tUoGB7DOHI4)</span></b>
 
 ```go
 import (
@@ -1917,8 +1919,7 @@ func main() {
 
 ### <span id="Sort">Sort</span>
 
-<p>Sorts a slice of any ordered type(number or string), use quick sort algrithm. Default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Ordered type: number(all ints uints floats) or string.
-</p>
+<p>Sorts a slice of any ordered type(number or string), use quick sort algrithm. Default sort order is ascending (asc), if want descending order, set param `sortOrder` to `desc`. Ordered type: number(all ints uints floats) or string.</p>
 
 <b>Signature:</b>
 
@@ -1926,7 +1927,7 @@ func main() {
 func Sort[T constraints.Ordered](slice []T, sortOrder ...string)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/V9AVjzf_4Fk)</span></b>
 
 ```go
 import (
@@ -1955,7 +1956,7 @@ func main() {
 
 ### <span id="SortBy">SortBy</span>
 
-<p>Sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable.<p>
+<p>Sorts the slice in ascending order as determined by the less function. This sort is not guaranteed to be stable.</p>
 
 <b>Signature:</b>
 
@@ -1963,7 +1964,7 @@ func main() {
 func SortBy[T any](slice []T, less func(a, b T) bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/DAhLQSZEumm)</span></b>
 
 ```go
 import (
@@ -2000,9 +2001,9 @@ func main() {
 }
 ```
 
-### <span id="SortByField">SortByField (Deprecated: use Sort and SortBy for replacement)</span>
+### <span id="SortByField">SortByField</span>
 
-<p>Sort struct slice by field. Slice element should be struct, field type should be int, uint, string, or bool. Default sort type is ascending (asc), if descending order, set sortType to desc</p>
+<p>Sort struct slice by field. Slice element should be struct, `field` param type should be int, uint, string, or bool. Default sort type is ascending (asc), if descending order, set `sortType` param to desc.</p>
 
 <b>Signature:</b>
 
@@ -2010,7 +2011,7 @@ func main() {
 func SortByField(slice any, field string, sortType ...string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fU1prOBP9p1)</span></b>
 
 ```go
 import (
@@ -2051,7 +2052,7 @@ func main() {
 func Some[T any](slice []T, predicate func(index int, item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4pO9Xf9NDGS)</span></b>
 
 ```go
 import (
@@ -2085,7 +2086,7 @@ func main() {
 func StringSlice(slice any) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/W0TZDWCPFcI)</span></b>
 
 ```go
 import (
@@ -2114,7 +2115,7 @@ func main() {
 func SymmetricDifference[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1CbOmtgILUU)</span></b>
 
 ```go
 import (
@@ -2145,7 +2146,7 @@ func main() {
 func ToSlice[T any](items ...T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/YzbzVq5kscN)</span></b>
 
 ```go
 import (
@@ -2173,7 +2174,7 @@ func main() {
 func ToSlicePointer[T any](items ...T) []*T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/gx4tr6_VXSF)</span></b>
 
 ```go
 import (
@@ -2208,7 +2209,7 @@ func main() {
 func Unique[T comparable](slice []T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/AXw0R3ZTE6a)</span></b>
 
 ```go
 import (
@@ -2235,7 +2236,7 @@ func main() {
 func UniqueBy[T comparable](slice []T, iteratee func(item T) T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/UR323iZLDpv)</span></b>
 
 ```go
 import (
@@ -2266,7 +2267,7 @@ func main() {
 func Union[T comparable](slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/hfXV1iRIZOf)</span></b>
 
 ```go
 import (
@@ -2297,7 +2298,7 @@ func main() {
 func UnionBy[T any, V comparable](predicate func(item T) V, slices ...[]T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HGKHfxKQsFi)</span></b>
 
 ```go
 import (
@@ -2322,7 +2323,7 @@ func main() {
 
 ### <span id="UpdateAt">UpdateAt</span>
 
-<p>Update the slice element at index. if param index < 0 or index >= len(slice), will return error. </p>
+<p>Update the slice element at index. if param index &lt 0 or index &lt= len(slice), will return error. </p>
 
 <b>Signature:</b>
 
@@ -2330,7 +2331,7 @@ func main() {
 func UpdateAt[T any](slice []T, index int, value T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/f3mh2KloWVm)</span></b>
 
 ```go
 import (
@@ -2362,7 +2363,7 @@ func main() {
 
 ### <span id="Without">Without</span>
 
-<p>Creates a slice excluding all given items. </p>
+<p>Creates a slice excluding all given items.</p>
 
 <b>Signature:</b>
 
@@ -2370,7 +2371,7 @@ func main() {
 func Without[T comparable](slice []T, items ...T) []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bwhEXEypThg)</span></b>
 
 ```go
 import (
@@ -2398,7 +2399,7 @@ func main() {
 func KeyBy[T any, U comparable](slice []T, iteratee func(item T) U) map[U]T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/uXod2LWD1Kg)</span></b>
 
 ```go
 import (
@@ -2417,3 +2418,102 @@ func main() {
     // map[1:a 2:ab 3:abc]
 }
 ```
+
+### <span id="Join">Join</span>
+
+<p>Join the slice item with specify separator.</p>
+
+<b>Signature:</b>
+
+```go
+func Join[T any](s []T, separator string) string
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/huKzqwNDD7V)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+    result1 := slice.Join(nums, ",")
+    result2 := slice.Join(nums, "-")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // 1,2,3,4,5
+    // 1-2-3-4-5
+}
+```
+
+### <span id="Partition">Partition</span>
+
+<p>Partition all slice elements with the evaluation of the given predicate functions. </p>
+
+<b>Signature:</b>
+
+```go
+func Partition[T any](slice []T, predicates ...func(item T) bool) [][]T
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/lkQ3Ri2NQhV)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+    nums := []int{1, 2, 3, 4, 5}
+
+	result1 := slice.Partition(nums)
+	result2 := slice.Partition(nums, func(n int) bool { return n%2 == 0 })
+	result3 := slice.Partition(nums, func(n int) bool { return n == 1 || n == 2 }, func(n int) bool { return n == 2 || n == 3 || n == 4 })
+
+	fmt.Println(result1)
+	fmt.Println(result2)
+	fmt.Println(result3)
+
+	// Output:
+	// [[1 2 3 4 5]]
+	// [[2 4] [1 3 5]]
+	// [[1 2] [3 4] [5]]
+}
+```
+
+### <span id="Random">Random</span>
+
+<p>Random get a random item of slice, return idx=-1 when slice is empty. </p>
+
+<b>Signature:</b>
+
+```go
+func Random[T any](slice []T) (val T, idx int)
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](TODO)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/slice"
+)
+
+func main() {
+	nums := []int{1, 2, 3, 4, 5}
+
+	val, idx := slice.Random(nums)
+	if idx >= 0 && idx < len(nums) && slice.Contain(nums, val) {
+		fmt.Println("okk")
+	}
+	// Output:
+	// okk
+}
+```

docs/en/api/packages/stream.md

@@ -51,6 +51,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## Documentation
 
 ### <span id="Of">Of</span>
@@ -63,7 +64,7 @@ import (
 func Of[T any](elems ...T) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (
@@ -93,7 +94,7 @@ func main() {
 func FromSlice[T any](source []T) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/wywTO0XZtI4)</span></b>
 
 ```go
 import (
@@ -123,7 +124,7 @@ func main() {
 func FromChannel[T any](source <-chan T) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9TZYugGMhXZ)</span></b>
 
 ```go
 import (
@@ -161,7 +162,7 @@ func main() {
 func FromRange[T constraints.Integer | constraints.Float](start, end, step T) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9Ex1-zcg-B-)</span></b>
 
 ```go
 import (
@@ -190,7 +191,7 @@ func main() {
 func Generate[T any](generator func() func() (item T, ok bool)) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/rkOWL1yA3j9)</span></b>
 
 ```go
 import (
@@ -230,7 +231,7 @@ func main() {
 func Concat[T any](a, b stream[T]) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HM4OlYk_OUC)</span></b>
 
 ```go
 import (
@@ -263,7 +264,7 @@ func main() {
 func (s stream[T]) Distinct() stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/eGkOSrm64cB)</span></b>
 
 ```go
 import (
@@ -297,7 +298,7 @@ func main() {
 func (s stream[T]) Filter(predicate func(item T) bool) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/MFlSANo-buc)</span></b>
 
 ```go
 import (
@@ -331,7 +332,7 @@ func main() {
 func (s stream[T]) Map(mapper func(item T) T) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/OtNQUImdYko)</span></b>
 
 ```go
 import (
@@ -365,7 +366,7 @@ func main() {
 func (s stream[T]) Peek(consumer func(item T)) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/u1VNzHs6cb2)</span></b>
 
 ```go
 import (
@@ -402,7 +403,7 @@ func main() {
 func (s stream[T]) Skip(n int) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fNdHbqjahum)</span></b>
 
 ```go
 import (
@@ -441,7 +442,7 @@ func main() {
 func (s stream[T]) Limit(maxSize int) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qsO4aniDcGf)</span></b>
 
 ```go
 import (
@@ -480,7 +481,7 @@ func main() {
 func (s stream[T]) Reverse() stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/A8_zkJnLHm4)</span></b>
 
 ```go
 import (
@@ -510,7 +511,7 @@ func main() {
 func (s stream[T]) Range(start, end int) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/indZY5V2f4j)</span></b>
 
 ```go
 import (
@@ -549,7 +550,7 @@ func main() {
 func (s stream[T]) Sorted(less func(a, b T) bool) stream[T]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/XXtng5uonFj)</span></b>
 
 ```go
 import (
@@ -581,7 +582,7 @@ func main() {
 func (s stream[T]) ForEach(action func(item T))
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Dsm0fPqcidk)</span></b>
 
 ```go
 import (
@@ -614,7 +615,7 @@ func main() {
 func (s stream[T]) Reduce(initial T, accumulator func(a, b T) T) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6uzZjq_DJLU)</span></b>
 
 ```go
 import (
@@ -646,7 +647,7 @@ func main() {
 func (s stream[T]) FindFirst() (T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9xEf0-6C1e3)</span></b>
 
 ```go
 import (
@@ -678,7 +679,7 @@ func main() {
 func (s stream[T]) FindLast() (T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/WZD2rDAW-2h)</span></b>
 
 ```go
 import (
@@ -710,7 +711,7 @@ func main() {
 func (s stream[T]) Max(less func(a, b T) bool) (T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/fm-1KOPtGzn)</span></b>
 
 ```go
 import (
@@ -734,7 +735,7 @@ func main() {
 
 ### <span id="Min">Min</span>
 
-<p>Returns the minimum element of this stream according to the provided less function. less fuction: a < b</p>
+<p>Returns the minimum element of this stream according to the provided less function. less fuction: a &lt b</p>
 
 <b>Signature:</b>
 
@@ -742,7 +743,7 @@ func main() {
 func (s stream[T]) Min(less func(a, b T) bool) (T, bool)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/vZfIDgGNRe_0)</span></b>
 
 ```go
 import (
@@ -774,7 +775,7 @@ func main() {
 func (s stream[T]) AllMatch(predicate func(item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/V5TBpVRs-Cx)</span></b>
 
 ```go
 import (
@@ -812,7 +813,7 @@ func main() {
 func (s stream[T]) AnyMatch(predicate func(item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/PTCnWn4OxSn)</span></b>
 
 ```go
 import (
@@ -850,7 +851,7 @@ func main() {
 func (s stream[T]) NoneMatch(predicate func(item T) bool) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/iWS64pL1oo3)</span></b>
 
 ```go
 import (
@@ -888,7 +889,7 @@ func main() {
 func (s stream[T]) Count() int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/r3koY6y_Xo-)</span></b>
 
 ```go
 import (
@@ -919,7 +920,7 @@ func main() {
 func (s stream[T]) ToSlice() []T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/jI6_iZZuVFE)</span></b>
 
 ```go
 import (

docs/en/api/packages/struct.md

@@ -1,11 +1,13 @@
-# Field
+# Structs
 
-Field is abstract struct field for provide several high level functions
+Struct is abstract struct for provide several high level functions
 
 <div STYLE="page-break-after: always;"></div>
 
 ## Source:
 
+-   [https://github.com/duke-git/lancet/blob/main/structs/struct.go](https://github.com/duke-git/lancet/blob/main/structs/struct.go)
+
 -   [https://github.com/duke-git/lancet/blob/main/structs/field.go](https://github.com/duke-git/lancet/blob/main/structs/field.go)
 
 <div STYLE="page-break-after: always;"></div>
@@ -22,6 +24,11 @@ import (
 
 ## Index:
 
+-   [New](#New)
+-   [ToMap](#ToMap)
+-   [Fields](#Fields)
+-   [Field](#Field)
+-   [IsStruct](#IsStruct)
 -   [Tag](#Tag)
 -   [Name](#Name)
 -   [Value](#Value)
@@ -31,17 +38,191 @@ import (
 -   [IsZero](#IsZero)
 -   [IsSlice](#IsSlice)
 
-> Note：Since `Field` inherits from `Struct`, it also has all the methods of 'Struct', as follows:
-
--   [ToMap](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#ToMap)
--   [Fields](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Fields)
--   [Field](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#Field)
--   [IsStruct](https://github.com/duke-git/lancet/blob/main/docs/structs/struct.md#IsStruct)
-
 <div STYLE="page-break-after: always;"></div>
 
 ## Documentation:
 
+### <span id="New">New</span>
+
+<p>The constructor function of the `Struct` </p>
+
+<b>Signature:</b>
+
+```go
+func New(value any, tagName ...string) *Struct
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    // to do something
+}
+```
+
+### <span id="ToMap">ToMap</span>
+
+<p>convert a valid struct to a map</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) ToMap() (map[string]any, error)
+```
+
+> In addition, provided a convenient static function ToMap
+
+```go
+func ToMap(v any) (map[string]any, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    // use constructor function
+    s1 := structs.New(p1)
+    m1, _ := s1.ToMap()
+
+    fmt.Println(m1)
+
+    // use static function
+    m2, _ := structs.ToMap(p1)
+
+    fmt.Println(m2)
+
+    // Output:
+    // map[name:11]
+    // map[name:11]
+}
+```
+
+### <span id="Fields">Fields</span>
+
+<p>Get all fields of a given struct, that the fields are abstract struct field</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) Fields() []*Field
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    fields := s.Fields()
+
+    fmt.Println(len(fields))
+
+    // Output:
+    // 1
+}
+```
+
+### <span id="Field">Field</span>
+
+<p>Get an abstract field of a struct by given field name </p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) Field(name string) *Field
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+    f := s.Field("Name")
+
+    fmt.Println(f.Value())
+
+    // Output:
+    // 11
+}
+```
+
+### <span id="IsStruct">IsStruct</span>
+
+<p>Check if the struct is valid</p>
+
+<b>Signature:</b>
+
+```go
+func (s *Struct) IsStruct() bool
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/structs"
+)
+
+func main() {
+    type People struct {
+        Name string `json:"name"`
+    }
+    p1 := &People{Name: "11"}
+    s := structs.New(p1)
+
+    fmt.Println(s.IsStruct())
+
+    // Output:
+    // true
+}
+```
+
 ### <span id="Tag">Tag</span>
 
 <p>Get a `Tag` of the `Field`, `Tag` is a abstract struct field tag</p>

docs/en/api/packages/strutil.md

@@ -49,6 +49,7 @@ import (
 -   [StringToBytes](#StringToBytes)
 -   [BytesToString](#BytesToString)
 -   [IsBlank](#IsBlank)
+-   [IsNotBlank](#IsNotBlank)
 -   [HasPrefixAny](#HasPrefixAny)
 -   [HasSuffixAny](#HasSuffixAny)
 -   [IndexOffset](#IndexOffset)
@@ -74,7 +75,7 @@ import (
 func After(s, char string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RbCOQqCDA7m)</span></b>
 
 ```go
 import (
@@ -114,7 +115,7 @@ func main() {
 func AfterLast(s, char string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1TegARrb8Yn)</span></b>
 
 ```go
 import (
@@ -154,7 +155,7 @@ func main() {
 func Before(s, char string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/JAWTZDS4F5w)</span></b>
 
 ```go
 import (
@@ -191,7 +192,7 @@ func main() {
 func BeforeLast(s, char string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pJfXXAoG_Te)</span></b>
 
 ```go
 import (
@@ -228,7 +229,7 @@ func main() {
 func CamelCase(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9eXP3tn2tUy)</span></b>
 
 ```go
 import (
@@ -263,7 +264,7 @@ func main() {
 func KebabCase(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dcZM9Oahw-Y)</span></b>
 
 ```go
 import (
@@ -298,7 +299,7 @@ func main() {
 func UpperKebabCase(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/zDyKNneyQXk)</span></b>
 
 ```go
 import (
@@ -333,7 +334,7 @@ func main() {
 func Capitalize(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/2OAjgbmAqHZ)</span></b>
 
 ```go
 import (
@@ -368,7 +369,7 @@ func main() {
 func IsString(v any) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/IOgq7oF9ERm)</span></b>
 
 ```go
 import (
@@ -408,7 +409,7 @@ func main() {
 func LowerFirst(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/CbzAyZmtJwL)</span></b>
 
 ```go
 import (
@@ -442,7 +443,7 @@ func main() {
 func UpperFirst(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sBbBxRbs8MM)</span></b>
 
 ```go
 import (
@@ -476,7 +477,7 @@ func main() {
 func Pad(source string, size int, padStr string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/NzImQq-VF8q)</span></b>
 
 ```go
 import (
@@ -521,7 +522,7 @@ func main() {
 func PadEnd(source string, size int, padStr string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/9xP8rN0vz--)</span></b>
 
 ```go
 import (
@@ -567,7 +568,7 @@ func main() {
 func PadStart(source string, size int, padStr string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/xpTfzArDfvT)</span></b>
 
 ```go
 import (
@@ -613,7 +614,7 @@ func main() {
 func Reverse(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/adfwalJiecD)</span></b>
 
 ```go
 import (
@@ -644,7 +645,7 @@ func main() {
 func SnakeCase(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/tgzQG11qBuN)</span></b>
 
 ```go
 import (
@@ -671,15 +672,15 @@ func main() {
 
 ### <span id="UpperSnakeCase">UpperSnakeCase</span>
 
-<p>Coverts string to upper KEBAB-CASE, non letters and numbers will be ignored.</p>
+<p>Coverts string to upper snake_case, non letters and numbers will be ignored.</p>
 
 <b>Signature:</b>
 
 ```go
-func SnakeCase(s string) string
+func UpperSnakeCase(s string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/4COPHpnLx38)</span></b>
 
 ```go
 import (
@@ -714,7 +715,7 @@ func main() {
 func SplitEx(s, sep string, removeEmptyString bool) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Us-ySSbWh-3)</span></b>
 
 ```go
 import (
@@ -755,7 +756,7 @@ func main() {
 func Substring(s string, offset int, length uint) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/q3sM6ehnPDp)</span></b>
 
 ```go
 import (
@@ -798,7 +799,7 @@ func main() {
 func Wrap(str string, wrapWith string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KoZOlZDDt9y)</span></b>
 
 ```go
 import (
@@ -825,7 +826,7 @@ func main() {
 }
 ```
 
-### <span id="Wrap">Wrap</span>
+### <span id="Unwrap">Unwrap</span>
 
 <p>Unwrap a given string from anther string. will change source string.</p>
 
@@ -835,7 +836,7 @@ func main() {
 func Unwrap(str string, wrapToken string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Ec2q4BzCpG-)</span></b>
 
 ```go
 import (
@@ -875,7 +876,7 @@ func main() {
 func SplitWords(s string) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KLiX4WiysMM)</span></b>
 
 ```go
 import (
@@ -918,7 +919,7 @@ func main() {
 func WordCount(s string) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/bj7_odx3vRf)</span></b>
 
 ```go
 import (
@@ -961,7 +962,7 @@ func main() {
 func RemoveNonPrintable(str string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/og47F5x_jTZ)</span></b>
 
 ```go
 import (
@@ -992,7 +993,7 @@ func main() {
 func StringToBytes(str string) (b []byte)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/7OyFBrf9AxA)</span></b>
 
 ```go
 import (
@@ -1023,7 +1024,7 @@ func main() {
 func BytesToString(bytes []byte) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6c68HRvJecH)</span></b>
 
 ```go
 import (
@@ -1052,7 +1053,7 @@ func main() {
 func IsBlank(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6zXRH_c0Qd3)</span></b>
 
 ```go
 import (
@@ -1076,6 +1077,45 @@ func main() {
 }
 ```
 
+### <span id="IsNotBlank">IsNotBlank</span>
+
+<p>Checks if a string is not whitespace or not empty.</p>
+
+<b>Signature:</b>
+
+```go
+func IsNotBlank(str string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/e_oJW0RAquA)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/strutil"
+)
+
+func main() {
+    result1 := strutil.IsNotBlank("")
+    result2 := strutil.IsNotBlank("	")
+    result3 := strutil.IsNotBlank("\t\v\f\n")
+    result4 := strutil.IsNotBlank(" 中文")
+    result5 := strutil.IsNotBlank(" 	world	")
+    
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+    fmt.Println(result5)
+    // Output:
+    // false
+    // false
+    // false
+    // true
+    // true
+}
+```
+
 ### <span id="HasPrefixAny">HasPrefixAny</span>
 
 <p>Checks if a string starts with any of an array of specified strings.</p>
@@ -1083,10 +1123,10 @@ func main() {
 <b>Signature:</b>
 
 ```go
-func ReplaceWithMap(str string, replaces map[string]string) string
+func HasPrefixAny(str string, prefixes []string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/8UUTl2C5slo)</span></b>
 
 ```go
 import (
@@ -1117,7 +1157,7 @@ func main() {
 func HasSuffixAny(str string, suffixes []string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/sKWpCQdOVkx)</span></b>
 
 ```go
 import (
@@ -1148,7 +1188,7 @@ func main() {
 func IndexOffset(str string, substr string, idxFrom int) int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/qZo4lV2fomB)</span></b>
 
 ```go
 import (
@@ -1190,7 +1230,7 @@ func main() {
 func ReplaceWithMap(str string, replaces map[string]string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/h3t7CNj2Vvu)</span></b>
 
 ```go
 import (
@@ -1223,7 +1263,7 @@ func main() {
 func Trim(str string, characterMask ...string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/Y0ilP0NRV3j)</span></b>
 
 ```go
 import (
@@ -1260,7 +1300,7 @@ func main() {
 func SplitAndTrim(str, delimiter string, characterMask ...string) []string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ZNL6o4SkYQ7)</span></b>
 
 ```go
 import (
@@ -1293,7 +1333,7 @@ func main() {
 func HideString(origin string, start, end int, replaceChar string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/pzbaIVCTreZ)</span></b>
 
 ```go
 import (
@@ -1332,7 +1372,7 @@ func main() {
 func ContainsAll(str string, substrs []string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/KECtK2Os4zq)</span></b>
 
 ```go
 import (
@@ -1365,7 +1405,7 @@ func main() {
 func ContainsAny(str string, substrs []string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/dZGSSMB3LXE)</span></b>
 
 ```go
 import (
@@ -1401,7 +1441,7 @@ func main() {
 func RemoveWhiteSpace(str string, repalceAll bool) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/HzLC9vsTwkf)</span></b>
 
 ```go
 import (

docs/en/api/packages/system.md

@@ -34,6 +34,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## Documentation
 
 ### <span id="IsWindows">IsWindows</span>
@@ -46,7 +47,7 @@ import (
 func IsWindows() bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 import (
@@ -70,7 +71,7 @@ func main() {
 func IsLinux() bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/zIflQgZNuxD)</span></b>
 
 ```go
 import (
@@ -94,7 +95,7 @@ func main() {
 func IsMac() bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/Mg4Hjtyq7Zc)</span></b>
 
 ```go
 import (
@@ -118,7 +119,7 @@ func main() {
 func GetOsEnv(key string) string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -148,7 +149,7 @@ func main() {
 func SetOsEnv(key, value string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/D88OYVCyjO-)</span></b>
 
 ```go
 import (
@@ -178,7 +179,7 @@ func main() {
 func RemoveOsEnv(key string) error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/fqyq4b3xUFQ)</span></b>
 
 ```go
 import (
@@ -216,7 +217,7 @@ func main() {
 func CompareOsEnv(key, comparedEnv string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/BciHrKYOHbp)</span></b>
 
 ```go
 import (
@@ -252,7 +253,7 @@ type (
 func ExecCommand(command string, opts ...Option) (stdout, stderr string, err error)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/n-2fLyZef-4)</span></b>
 
 ```go
 import (
@@ -292,7 +293,7 @@ func main() {
 func GetOsBits() int
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/ml-_XH3gJbW)</span></b>
 
 ```go
 import (

docs/en/api/packages/tuple.md

@@ -61,6 +61,7 @@ import (
 
 <div STYLE="page-break-after: always;"></div>
 
+
 ## Documentation
 
 ### <span id="Tuple2">Tuple2</span>
@@ -78,7 +79,7 @@ type Tuple2[A any, B any] struct {
 func NewTuple2[A any, B any](a A, b B) Tuple2[A, B]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/3sHVqBQpLYN)</span></b>
 
 ```go
 package main
@@ -106,7 +107,7 @@ func main() {
 func (t Tuple2[A, B]) Unbox() (A, B)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/0fD1qfCVwjm)</span></b>
 
 ```go
 package main
@@ -135,7 +136,7 @@ func main() {
 func Zip2[A any, B any](a []A, b []B) []Tuple2[A, B]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/4ncWJJ77Xio)</span></b>
 
 ```go
 package main
@@ -163,7 +164,7 @@ func main() {
 func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/KBecr60feXb)</span></b>
 
 ```go
 package main
@@ -198,7 +199,7 @@ type Tuple3[A any, B any, C any] struct {
 func NewTuple3[A any, B any, C any](a A, b B c C) Tuple3[A, B, C]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/FtH2sdCLlCf)</span></b>
 
 ```go
 package main
@@ -226,7 +227,7 @@ func main() {
 func (t Tuple3[A, B, C]) Unbox() (A, B, C)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/YojLy-id1BS)</span></b>
 
 ```go
 package main
@@ -237,9 +238,9 @@ import (
 )
 
 func main() {
-    t := tuple.NewTuple2(1, 0.1, "a")
+    t := tuple.NewTuple3(1, 0.1, "a")
     v1, v2, v3 := t.Unbox()
-    fmt.Printf("%v %v %v", t.FieldA, t.FieldB, t.FieldC)
+    fmt.Printf("%v %v %v", v1, v2, v3)
 
     // Output: 1 0.1 a
 }
@@ -255,7 +256,7 @@ func main() {
 func Zip3[A any, B any, C any](a []A, b []B, c []C) []Tuple3[A, B, C]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/97NgmsTILfu)</span></b>
 
 ```go
 package main
@@ -283,7 +284,7 @@ func main() {
 func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/bba4cpAa7KO)</span></b>
 
 ```go
 package main
@@ -321,7 +322,7 @@ type Tuple4[A any, B any, C any, D any] struct {
 func NewTuple4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/D2EqDz096tk)</span></b>
 
 ```go
 package main
@@ -349,7 +350,7 @@ func main() {
 func (t Tuple4[A, B, C, D]) Unbox() (A, B, C, D)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/ACj9YuACGgW)</span></b>
 
 ```go
 package main
@@ -378,7 +379,7 @@ func main() {
 func Zip4[A any, B any, C any, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/PEmTYVK5hL4)</span></b>
 
 ```go
 package main
@@ -406,7 +407,7 @@ func main() {
 func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/rb8z4gyYSRN)</span></b>
 
 ```go
 package main
@@ -445,7 +446,7 @@ type Tuple5[A any, B any, C any, D any, E any] struct {
 func NewTuple5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/2WndmVxPg-r)</span></b>
 
 ```go
 package main
@@ -473,7 +474,7 @@ func main() {
 func (t Tuple5[A, B, C, D, E]) Unbox() (A, B, C, D, E)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/GyIyZHjCvoS)</span></b>
 
 ```go
 package main
@@ -502,7 +503,7 @@ func main() {
 func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/fCAAJLMfBIP)</span></b>
 
 ```go
 package main
@@ -530,7 +531,7 @@ func main() {
 func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/gyl6vKfhqPb)</span></b>
 
 ```go
 package main
@@ -570,7 +571,7 @@ type Tuple6[A any, B any, C any, D any, E any, F any] struct {
 func NewTuple6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/VjqcCwEJZbs)</span></b>
 
 ```go
 package main
@@ -598,7 +599,7 @@ func main() {
 func (t Tuple6[A, B, C, D, E, F]) Unbox() (A, B, C, D, E, F)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/FjIHV7lpxmW)</span></b>
 
 ```go
 package main
@@ -627,7 +628,7 @@ func main() {
 func Zip6[A any, B any, C any, D any, E any, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/oWPrnUYuFHo)</span></b>
 
 ```go
 package main
@@ -655,7 +656,7 @@ func main() {
 func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/l41XFqCyh5E)</span></b>
 
 ```go
 package main
@@ -696,7 +697,7 @@ type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
 func NewTuple7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/dzAgv_Ezub9)</span></b>
 
 ```go
 package main
@@ -724,7 +725,7 @@ func main() {
 func (t Tuple7[A, B, C, D, E, F, G]) Unbox() (A, B, C, D, E, F, G)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/R9I8qeDk0zs)</span></b>
 
 ```go
 package main
@@ -753,7 +754,7 @@ func main() {
 func Zip7[A any, B any, C any, D any, E any, F any, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/WUJuo897Egf)</span></b>
 
 ```go
 package main
@@ -781,7 +782,7 @@ func main() {
 func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/hws_P1Fr2j3)</span></b>
 
 ```go
 package main
@@ -823,7 +824,7 @@ type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
 func NewTuple8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/YA9S0rz3dRz)</span></b>
 
 ```go
 package main
@@ -851,7 +852,7 @@ func main() {
 func (t Tuple8[A, B, C, D, E, F, G, H]) Unbox() (A, B, C, D, E, F, G, H)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/PRxLBBb4SMl)</span></b>
 
 ```go
 package main
@@ -880,7 +881,7 @@ func main() {
 func Zip8[A any, B any, C any, D any, E any, F any, G any, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/8V9jWkuJfaQ)</span></b>
 
 ```go
 package main
@@ -908,7 +909,7 @@ func main() {
 func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/1SndOwGsZB4)</span></b>
 
 ```go
 package main
@@ -953,7 +954,7 @@ func NewTuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a
 
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/yS2NGGtZpQr)</span></b>
 
 ```go
 package main
@@ -981,7 +982,7 @@ func main() {
 func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unbox() (A, B, C, D, E, F, G, H, I)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/oFJFGTAuOa8)</span></b>
 
 ```go
 package main
@@ -1010,7 +1011,7 @@ func main() {
 func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/cgsL15QYnfz)</span></b>
 
 ```go
 package main
@@ -1038,7 +1039,7 @@ func main() {
 func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/91-BU_KURSA)</span></b>
 
 ```go
 package main
@@ -1084,7 +1085,7 @@ func NewTuple10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J
 
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/799qqZg0hUv)</span></b>
 
 ```go
 package main
@@ -1115,7 +1116,7 @@ func main() {
 func (t Tuple10[A, B, C, D, E, F, G, H, I, J]) Unbox() (A, B, C, D, E, F, G, H, I, J)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/qfyx3x_X0Cu)</span></b>
 
 ```go
 package main
@@ -1134,8 +1135,6 @@ func main() {
     fmt.Printf("%v %v %v %v %v %v %v %v %v %v", v1, v2, v3, v4, v5, v6, v7, v8, v9, v10)
 
     // Output: 1 0.1 a true 2 2.2 b c map[a:1] {a}
-
-    // Output: 1 0.1 a true 2 2.2 b c map[a:1]
 }
 ```
 
@@ -1149,7 +1148,7 @@ func main() {
 func Zip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, j []J) []Tuple10[A, B, C, D, E, F, G, H, I, J]
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/YSR-2cXnrY4)</span></b>
 
 ```go
 package main
@@ -1177,7 +1176,7 @@ func main() {
 func Unzip10[A any, B any, C any, D any, E any, F any, G any, H any, I any, J any](tuples []Tuple10[A, B, C, D, E, F, G, H, I, J]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, []J)
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/-taQB6Wfre_z)</span></b>
 
 ```go
 package main

docs/en/api/packages/validator.md

@@ -55,9 +55,20 @@ import (
 -   [IsZeroValue](#IsZeroValue)
 -   [IsGBK](#IsGBK)
 -   [IsPrintable](#IsPrintable)
+-   [IsBin](#IsBin)
+-   [IsHex](#IsHex)
+-   [IsBase64URL](#IsBase64URL)
+-   [IsJWT](#IsJWT)
+-   [IsVisa](#IsVisa)
+-   [IsMasterCard](#IsMasterCard)
+-   [IsAmericanExpress](#IsAmericanExpress)
+-   [IsUnionPay](#IsUnionPay)
+-   [IsChinaUnionPay](#IsChinaUnionPay)
 
 <div STYLE="page-break-after: always;"></div>
 
+<link rel="stylesheet" type="text/css" href="/styles/api_doc.css">
+
 ## Documentation
 
 ### <span id="ContainChinese">ContainChinese</span>
@@ -70,7 +81,7 @@ import (
 func ContainChinese(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/7DpU0uElYeM)</span></b>
 
 ```go
 import (
@@ -104,7 +115,7 @@ func main() {
 func ContainLetter(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/lqFD04Yyewp)</span></b>
 
 ```go
 import (
@@ -138,7 +149,7 @@ func main() {
 func ContainLower(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/Srqi1ItvnAA)</span></b>
 
 ```go
 import (
@@ -172,7 +183,7 @@ func main() {
 func ContainUpper(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/CmWeBEk27-z)</span></b>
 
 ```go
 import (
@@ -206,7 +217,7 @@ func main() {
 func IsAlpha(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/7Q5sGOz2izQ)</span></b>
 
 ```go
 import (
@@ -240,7 +251,7 @@ func main() {
 func IsAllUpper(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/ZHctgeK1n4Z)</span></b>
 
 ```go
 import (
@@ -274,7 +285,7 @@ func main() {
 func IsAllLower(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/GjqCnOfV6cM)</span></b>
 
 ```go
 import (
@@ -308,7 +319,7 @@ func main() {
 func IsASCII(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/hfQNPLX0jNa)</span></b>
 
 ```go
 import (
@@ -348,7 +359,7 @@ func main() {
 func IsBase64(base64 string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/sWHEySAt6hl)</span></b>
 
 ```go
 import (
@@ -379,7 +390,7 @@ func main() {
 func IsChineseMobile(mobileNum string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/GPYUlGTOqe3)</span></b>
 
 ```go
 import (
@@ -410,7 +421,7 @@ func main() {
 func IsChineseIdNum(id string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/d8EWhl2UGDF)</span></b>
 
 ```go
 import (
@@ -441,7 +452,7 @@ func main() {
 func IsChinesePhone(phone string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/RUD_-7YZJ3I)</span></b>
 
 ```go
 import (
@@ -472,7 +483,7 @@ func main() {
 func IsCreditCard(creditCart string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/sNwwL6B0-v4)</span></b>
 
 ```go
 import (
@@ -503,7 +514,7 @@ func main() {
 func IsDns(dns string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/jlYApVLLGTZ)</span></b>
 
 ```go
 import (
@@ -537,7 +548,7 @@ func main() {
 func IsEmail(email string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/Os9VaFlT33G)</span></b>
 
 ```go
 import (
@@ -568,7 +579,7 @@ func main() {
 func IsEmptyString(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/dpzgUjFnBCX)</span></b>
 
 ```go
 import (
@@ -602,7 +613,7 @@ func main() {
 func IsInt(v any) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/eFoIHbgzl-z)</span></b>
 
 ```go
 import (
@@ -639,7 +650,7 @@ func main() {
 func IsFloat(v any) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/vsyG-sxr99_Z)</span></b>
 
 ```go
 import (
@@ -676,7 +687,7 @@ func main() {
 func IsNumber(v any) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/mdJHOAvtsvF)</span></b>
 
 ```go
 import (
@@ -713,7 +724,7 @@ func main() {
 func IsIntStr(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/jQRtFv-a0Rk)</span></b>
 
 ```go
 import (
@@ -750,7 +761,7 @@ func main() {
 func IsFloatStr(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/LOYwS_Oyl7U)</span></b>
 
 ```go
 import (
@@ -787,7 +798,7 @@ func main() {
 func IsNumberStr(s string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/LzaKocSV79u)</span></b>
 
 ```go
 import (
@@ -824,7 +835,7 @@ func main() {
 func IsJSON(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/8Kip1Itjiil)</span></b>
 
 ```go
 import (
@@ -861,7 +872,7 @@ func main() {
 func IsRegexMatch(s, regex string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/z_XeZo_litG)</span></b>
 
 ```go
 import (
@@ -892,7 +903,7 @@ func main() {
 func IsIp(ipstr string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/FgcplDvmxoD)</span></b>
 
 ```go
 import (
@@ -929,7 +940,7 @@ func main() {
 func IsIpV4(ipstr string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/zBGT99EjaIu)</span></b>
 
 ```go
 import (
@@ -960,7 +971,7 @@ func main() {
 func IsIpV6(ipstr string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/AHA0r0AzIdC)</span></b>
 
 ```go
 import (
@@ -983,7 +994,7 @@ func main() {
 
 ### <span id="IsStrongPassword">IsStrongPassword</span>
 
-<p>Check if the string is strong password (alpha(lower+upper) + number + special chars(!@#$%^&*()?><)).</p>
+<p>Check if the string is strong password (alpha(lower+upper) + number + special chars(!@#$%^&*()?gt&lt)).</p>
 
 <b>Signature:</b>
 
@@ -991,7 +1002,7 @@ func main() {
 func IsStrongPassword(password string, length int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/QHdVcSQ3uDg)</span></b>
 
 ```go
 import (
@@ -1022,7 +1033,7 @@ func main() {
 func IsUrl(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/pbJGa7F98Ka)</span></b>
 
 ```go
 import (
@@ -1057,7 +1068,7 @@ func main() {
 func IsWeakPassword(password string, length int) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/wqakscZH5gH)</span></b>
 
 ```go
 import (
@@ -1088,7 +1099,7 @@ func main() {
 func IsZeroValue(value any) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/UMrwaDCi_t4)</span></b>
 
 ```go
 import (
@@ -1125,7 +1136,7 @@ func main() {
 func IsGBK(data []byte) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/E2nt3unlmzP)</span></b>
 
 ```go
 import (
@@ -1157,7 +1168,7 @@ func main() {
 func IsPrintable(str string) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/Pe1FE2gdtTP)</span></b>
 
 ```go
 import (
@@ -1186,3 +1197,300 @@ func main() {
     // false
 }
 ```
+
+### <span id="IsBin">IsBin</span>
+
+<p>Checks if a give string is a valid binary value or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsBin(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/ogPeg2XJH4P)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBin("0101")
+    result2 := validator.IsBin("0b1101")
+    result3 := validator.IsBin("b1101")
+    result4 := validator.IsBin("1201")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsHex">IsHex</span>
+
+<p>Checks if a give string is a valid hexadecimal value or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsHex(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/M2qpHbEwmm7)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsHex("0xabcde")
+    result2 := validator.IsHex("0XABCDE")
+    result3 := validator.IsHex("cdfeg")
+    result4 := validator.IsHex("0xcdfeg")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsBase64URL">IsBase64URL</span>
+
+<p>Checks if a give string is a valid URL-safe Base64 encoded string.</p>
+
+<b>Signature:</b>
+
+```go
+func IsBase64URL(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/vhl4mr8GZ6S)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ")
+    result2 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ==")
+    result3 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ=")
+    result4 := validator.IsBase64URL("SAGsbG8sIHdvcmxkIQ===")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+    fmt.Println(result3)
+    fmt.Println(result4)
+
+    // Output:
+    // true
+    // true
+    // false
+    // false
+}
+```
+
+### <span id="IsJWT">IsJWT</span>
+
+<p>Checks if a give string is is a valid JSON Web Token (JWT).</p>
+
+<b>Signature:</b>
+
+```go
+func IsJWT(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/R6Op7heJbKI)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsJWT("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibWVzc2FnZSI6IlB1dGluIGlzIGFic29sdXRlIHNoaXQiLCJpYXQiOjE1MTYyMzkwMjJ9.wkLWA5GtCpWdxNOrRse8yHZgORDgf8TpJp73WUQb910")
+    result2 := validator.IsJWT("abc")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsVisa">IsVisa</span>
+
+<p>Checks if a give string is a valid visa card nubmer or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsVisa(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/SdS2keOyJsl)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsVisa("4111111111111111")
+    result2 := validator.IsVisa("123")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsMasterCard">IsMasterCard</span>
+
+<p>Checks if a give string is a valid mastercard nubmer or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsMasterCard(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/CwWBFRrG27b)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsMasterCard("5425233430109903")
+    result2 := validator.IsMasterCard("4111111111111111")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsAmericanExpress">IsAmericanExpress</span>
+
+<p>Checks if a give string is a valid american express nubmer or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsAmericanExpress(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/HIDFpcOdpkd)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsAmericanExpress("342883359122187")
+    result2 := validator.IsAmericanExpress("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsUnionPay">IsVisa</span>
+
+<p>Checks if a give string is a valid union pay nubmer or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsUnionPay(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/CUHPEwEITDf)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsUnionPay("6221263430109903")
+    result2 := validator.IsUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```
+
+### <span id="IsChinaUnionPay">IsChinaUnionPay</span>
+
+<p>Checks if a give string is a valid china union pay nubmer or not.</p>
+
+<b>Signature:</b>
+
+```go
+func IsChinaUnionPay(v string) bool
+```
+
+<b>Example:<span style="float:right;display:inline-block">[Run](https://go.dev/play/p/yafpdxLiymu)</span></b>
+
+```go
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/validator"
+)
+
+func main() {
+    result1 := validator.IsChinaUnionPay("6250941006528599")
+    result2 := validator.IsChinaUnionPay("3782822463100007")
+
+    fmt.Println(result1)
+    fmt.Println(result2)
+
+    // Output:
+    // true
+    // false
+}
+```

docs/en/api/packages/xerror.md

@@ -58,7 +58,7 @@ type XError struct {
 func New(format string, args ...any) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -87,7 +87,7 @@ func main() {
 func Wrap(cause error, message ...any) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/5385qT2dCi4)</span></b>
 
 ```go
 package main
@@ -118,7 +118,7 @@ func main() {
 func Unwrap(err error) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/LKMLep723tu)</span></b>
 
 ```go
 package main
@@ -153,24 +153,25 @@ func main() {
 func (e *XError) Wrap(cause error) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/RpjJ5u5sc97)</span></b>
 
 ```go
 package main
 
 import (
     "fmt"
+    "errors"
     "github.com/duke-git/lancet/v2/xerror"
 )
 
 func main() {
-    err := xerror.New("wrong password")
-    wrapErr := xerror.Wrap(err, "error")
+    err1 := xerror.New("error").With("level", "high")
+	err2 := err1.Wrap(errors.New("invalid username"))
 
-    fmt.Println(wrapErr.Error())
+	fmt.Println(err2.Error())
 
-    // Output:
-    // error: wrong password
+	// Output:
+	// error: invalid username
 }
 ```
 
@@ -184,7 +185,7 @@ func main() {
 func (e *XError) Unwrap() error
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/VUXJ8BST4c6)</span></b>
 
 ```go
 package main
@@ -217,7 +218,7 @@ func main() {
 func (e *XError) With(key string, value any) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -249,7 +250,7 @@ func main() {
 func (e *XError) Id(id string) *XError
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -286,7 +287,7 @@ func main() {
 func (e *XError) Is(target error) bool
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/X6HBlsy58U9)</span></b>
 
 ```go
 package main
@@ -323,7 +324,7 @@ func main() {
 func (e *XError) Values() map[string]any
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/ow8UISXX_Dp)</span></b>
 
 ```go
 package main
@@ -356,7 +357,7 @@ func main() {
 func (e *XError) StackTrace() StackTrace
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/6FAvSQpa7pc)</span></b>
 
 ```go
 package main
@@ -390,7 +391,7 @@ func main() {
 func (e *XError) Info() *errInfo
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/1ZX0ME1F-Jb)</span></b>
 
 ```go
 package main
@@ -430,7 +431,7 @@ func main() {
 func (e *XError) Error() string
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/w4oWZts7q7f)</span></b>
 
 ```go
 package main
@@ -458,7 +459,7 @@ func main() {
 func TryUnwrap[T any](val T, err error) T
 ```
 
-<b>Example:</b>
+<b>Example:<span style="float:right;display:inline-block;">[Run](https://go.dev/play/p/acyZVkNZEeW)</span></b>
 
 ```go
 package main

docs/en/guide/contribution_guide.md

@@ -0,0 +1,37 @@
+# Lancet Contribution Guide
+
+Hi! Thank you for choosing Lancet.
+
+Lancet is a powerful, efficient, and reusable util function library of go. It makes Go dev easier by taking the hassle out of working with concurrency, net, math, slice, string, etc.
+
+We are excited that you are interested in contributing to lancet. Before submitting your contribution though, please make sure to take a moment and read through the following guidelines.
+
+## Issue Guidelines
+
+- Issues are exclusively for bug reports, feature requests and design-related topics. Other questions may be closed directly.
+
+- Before submitting an issue, please check if similar problems have already been issued.
+
+- Please specify which version of Lancet and Go you are using, and provide OS information. [Go Playground](https://go.dev/play/) is recommended to build a live demo so that your issue can be reproduced clearly.
+
+## Pull Request Guidelines
+
+- Fork this repository to your own account. Do not create branches here.
+
+- Commit info should be formatted as `type(scope): info about commit`. eg. `fix(package): [scrollbar] fix xxx bug`.
+
+  1. type: type must be one of [chore, docs, feat, fix, refactor, release, test].
+
+  2. scope: scope must be one of [package, file, internal].
+
+  3. header: header must not be longer than 72 characters.
+
+- Rebase before creating a PR to keep commit history clear.
+
+- Before submitting a PR, please execute the unit test command: `go test -v ./...` to ensure that all unit test tasks should pass.
+
+- Make sure PRs are created to `v2` branch instead of `master` branch.
+
+- If your PR fixes a bug, please provide a description about the related bug.
+
+- If the PR is for a new feature, make sure to complete the relevant documentation (/lancet/docs/en/api/packages).

docs/en/guide/contributors.md

@@ -0,0 +1,6 @@
+# Contributors
+<b>Thank you to all the people who contributed to lancet!</b>
+
+<a href="https://github.com/duke-git/lancet/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=duke-git/lancet" />
+</a>