fix: fix issue #274

2025-09-26 19:41:20 +08:00 · 2024-12-02 17:06:06 +08:00
parent 7fb49515ce
commit 3cd546d7f2
8 changed files with 354 additions and 377 deletions
--- a/compare/compare_internal.go
+++ b/compare/compare_internal.go
@@ -3,6 +3,7 @@ package compare
 import (
 	"bytes"
 	"encoding/json"
+	"math/big"
 	"reflect"
 	"time"

@@ -24,6 +25,13 @@ func compareValue(operator string, left, right any) bool {

 	case reflect.Struct, reflect.Slice, reflect.Map:
 		return compareRefValue(operator, left, right, leftType.Kind())
+
+	case reflect.Ptr:
+		if leftVal, ok := left.(*big.Int); ok {
+			if rightVal, ok := right.(*big.Int); ok {
+				return compareBigInt(operator, leftVal, rightVal)
+			}
+		}
 	}

 	return false
@@ -155,169 +163,129 @@ func compareBasicValue(operator string, leftValue, rightValue any) bool {
 	}

 	switch leftVal := leftValue.(type) {
-	case json.Number:
-		if left, err := leftVal.Float64(); err == nil {
-			switch rightVal := rightValue.(type) {
-			case json.Number:
-				if right, err := rightVal.Float64(); err == nil {
-					switch operator {
-					case equal:
-						if left == right {
-							return true
-						}
-					case lessThan:
-						if left < right {
-							return true
-						}
-					case greaterThan:
-						if left > right {
-							return true
-						}
-					case lessOrEqual:
-						if left <= right {
-							return true
-						}
-					case greaterOrEqual:
-						if left >= right {
-							return true
-						}
-					}
-
-				}
-
-			case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-				right, err := convertor.ToFloat(rightValue)
-				if err != nil {
-					return false
-				}
-				switch operator {
-				case equal:
-					if left == right {
-						return true
-					}
-				case lessThan:
-					if left < right {
-						return true
-					}
-				case greaterThan:
-					if left > right {
-						return true
-					}
-				case lessOrEqual:
-					if left <= right {
-						return true
-					}
-				case greaterOrEqual:
-					if left >= right {
-						return true
-					}
-				}
-			}
-
+	case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+		left, err := convertor.ToBigInt(leftValue)
+		if err != nil {
+			return false
 		}

-	case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+		right, err := convertor.ToBigInt(rightValue)
+		if err != nil {
+			return false
+		}
+
+		return compareBigInt(operator, left, right)
+
+	case float32, float64:
 		left, err := convertor.ToFloat(leftValue)
 		if err != nil {
 			return false
 		}
-		switch rightVal := rightValue.(type) {
-		case json.Number:
-			if right, err := rightVal.Float64(); err == nil {
-				switch operator {
-				case equal:
-					if left == right {
-						return true
-					}
-				case lessThan:
-					if left < right {
-						return true
-					}
-				case greaterThan:
-					if left > right {
-						return true
-					}
-				case lessOrEqual:
-					if left <= right {
-						return true
-					}
-				case greaterOrEqual:
-					if left >= right {
-						return true
-					}
-				}
-			}
-		case float32, float64, int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-			right, err := convertor.ToFloat(rightValue)
-			if err != nil {
-				return false
-			}
-
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			case lessThan:
-				if left < right {
-					return true
-				}
-			case greaterThan:
-				if left > right {
-					return true
-				}
-			case lessOrEqual:
-				if left <= right {
-					return true
-				}
-			case greaterOrEqual:
-				if left >= right {
-					return true
-				}
-			}
+		right, err := convertor.ToFloat(rightValue)
+		if err != nil {
+			return false
 		}

+		return compareFloats(operator, left, right)
+
 	case string:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case string:
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			case lessThan:
-				if left < right {
-					return true
-				}
-			case greaterThan:
-				if left > right {
-					return true
-				}
-			case lessOrEqual:
-				if left <= right {
-					return true
-				}
-			case greaterOrEqual:
-				if left >= right {
-					return true
-				}
-			}
+			return compareStrings(operator, left, right)
 		}

 	case bool:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case bool:
-			switch operator {
-			case equal:
-				if left == right {
-					return true
-				}
-			}
+			return compareBools(operator, left, right)
 		}

+	case json.Number:
+		if left, err := leftVal.Float64(); err == nil {
+			switch rightVal := rightValue.(type) {
+			case json.Number:
+				if right, err := rightVal.Float64(); err == nil {
+					return compareFloats(operator, left, right)
+				}
+			case float32, float64:
+				right, err := convertor.ToFloat(rightValue)
+				if err != nil {
+					return false
+				}
+				return compareFloats(operator, left, right)
+
+			case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
+				right, err := convertor.ToBigInt(rightValue)
+				if err != nil {
+					return false
+				}
+				left, err := convertor.ToBigInt(left)
+				return compareBigInt(operator, left, right)
+			}
+		}
 	}

 	return false
 }
+
+// compareBigInt compares two big.Int values based on the operator
+func compareBigInt(operator string, left, right *big.Int) bool {
+	switch operator {
+	case equal:
+		return left.Cmp(right) == 0
+	case lessThan:
+		return left.Cmp(right) < 0
+	case greaterThan:
+		return left.Cmp(right) > 0
+	case lessOrEqual:
+		return left.Cmp(right) <= 0
+	case greaterOrEqual:
+		return left.Cmp(right) >= 0
+	}
+	return false
+}
+
+// compareFloats compares two float64 values based on the operator
+func compareFloats(operator string, left, right float64) bool {
+	switch operator {
+	case equal:
+		return left == right
+	case lessThan:
+		return left < right
+	case greaterThan:
+		return left > right
+	case lessOrEqual:
+		return left <= right
+	case greaterOrEqual:
+		return left >= right
+	}
+	return false
+}
+
+// compareStrings compares two string values based on the operator
+func compareStrings(operator string, left, right string) bool {
+	switch operator {
+	case equal:
+		return left == right
+	case lessThan:
+		return left < right
+	case greaterThan:
+		return left > right
+	case lessOrEqual:
+		return left <= right
+	case greaterOrEqual:
+		return left >= right
+	}
+	return false
+}
+
+// compareBools compares two boolean values based on the operator
+func compareBools(operator string, left, right bool) bool {
+	switch operator {
+	case equal:
+		return left == right
+	}
+	return false
+}
--- a/compare/compare_test.go
+++ b/compare/compare_test.go
@@ -2,6 +2,7 @@ package compare

 import (
 	"encoding/json"
+	"math/big"
 	"testing"
 	"time"

@@ -12,213 +13,191 @@ func TestEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqual")

-	// basic type
-	assert.Equal(true, Equal(1, 1))
-	assert.Equal(true, Equal(int64(1), int64(1)))
-	assert.Equal(true, Equal("a", "a"))
-	assert.Equal(true, Equal(true, true))
-	assert.Equal(true, Equal([]int{1, 2, 3}, []int{1, 2, 3}))
-	assert.Equal(true, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}))
-
-	assert.Equal(false, Equal(1, 2))
-	assert.Equal(false, Equal(1, int64(1)))
-	assert.Equal(false, Equal("a", "b"))
-	assert.Equal(false, Equal(true, false))
-	assert.Equal(false, Equal([]int{1, 2}, []int{1, 2, 3}))
-	assert.Equal(false, Equal(map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}))
-
-	// time
-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	time3 := time1.Add(time.Second)
-
-	assert.Equal(false, Equal(time1, time2))
-	assert.Equal(true, Equal(time2, time3))
-
-	// struct
-	st1 := struct {
-		A string
-		B string
+	tests := []struct {
+		left  any
+		right any
+		want  bool
 	}{
-		A: "a",
-		B: "b",
+		{1, 1, true},
+		{int64(1), int64(1), true},
+		{"a", "a", true},
+		{true, true, true},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
+		{1, 2, false},
+		{1, int64(1), false},
+		{"a", "b", false},
+		{true, false, false},
+		{[]int{1, 2}, []int{1, 2, 3}, false},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a"}, false},
+		{time.Now(), time.Now(), true},
+		{time.Now(), time.Now().Add(time.Second), false},
+		{[]byte("hello"), []byte("hello"), true},
+		{[]byte("hello"), []byte("world"), false},
+		{json.Number("123"), json.Number("123"), true},
+		{json.Number("123"), json.Number("124"), false},
+
+		{big.NewInt(123), big.NewInt(123), true},
 	}

-	st2 := struct {
-		A string
-		B string
-	}{
-		A: "a",
-		B: "b",
+	for _, tt := range tests {
+		assert.Equal(tt.want, Equal(tt.left, tt.right))
 	}

-	st3 := struct {
-		A string
-		B string
-	}{
-		A: "a1",
-		B: "b",
-	}
-
-	assert.Equal(true, Equal(st1, st2))
-	assert.Equal(false, Equal(st1, st3))
-
-	//byte slice
-	bs1 := []byte("hello")
-	bs2 := []byte("hello")
-	assert.Equal(true, Equal(bs1, bs2))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`123`), &jsonNumber2)
-
-	assert.Equal(true, Equal(jsonNumber1, jsonNumber2))
-
 }

 func TestEqualValue(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestEqualValue")

-	assert.Equal(true, EqualValue(1, 1))
-	assert.Equal(true, EqualValue(int(1), int64(1)))
-	assert.Equal(true, EqualValue(1, "1"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 1, true},
+		{int64(1), int64(1), true},
+		{"a", "a", true},
+		{true, true, true},
+		{[]int{1, 2, 3}, []int{1, 2, 3}, true},
+		{map[int]string{1: "a", 2: "b"}, map[int]string{1: "a", 2: "b"}, true},
+		{1, 2, false},
+		{1, int64(1), true},
+		{"a", "b", false},
+		{true, false, false},
+		{[]int{1, 2}, []int{1, 2, 3}, false},
+	}

-	assert.Equal(false, EqualValue(1, "2"))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`123`), &jsonNumber2)
-
-	assert.Equal(true, EqualValue(jsonNumber1, 123))
+	for _, tt := range tests {
+		assert.Equal(tt.want, EqualValue(tt.left, tt.right))
+	}
 }

 func TestLessThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessThan")

-	assert.Equal(true, LessThan(1, 2))
-	assert.Equal(true, LessThan(1.1, 2.2))
-	assert.Equal(true, LessThan("a", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 2, true},
+		{1.1, 2.2, true},
+		{"a", "b", true},
+		{time.Now(), time.Now().Add(time.Second), true},
+		{[]byte("hello1"), []byte("hello2"), true},
+		{json.Number("123"), json.Number("124"), true},
+		{645680099112988673, 645680099112988675, true},
+		{1, 1, false},
+		{1, int64(1), false},
+	}

-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, LessThan(time1, time2))
-
-	assert.Equal(false, LessThan(1, 1))
-	assert.Equal(false, LessThan(1, int64(1)))
-
-	bs1 := []byte("hello1")
-	bs2 := []byte("hello2")
-	assert.Equal(true, LessThan(bs1, bs2))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`124`), &jsonNumber2)
-
-	assert.Equal(true, LessThan(jsonNumber1, jsonNumber2))
+	for _, tt := range tests {
+		assert.Equal(tt.want, LessThan(tt.left, tt.right))
+	}
 }

 func TestGreaterThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")

-	assert.Equal(true, GreaterThan(2, 1))
-	assert.Equal(true, GreaterThan(2.2, 1.1))
-	assert.Equal(true, GreaterThan("b", "a"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{2, 1, true},
+		{2.2, 1.1, true},
+		{"b", "a", true},
+		{time.Now().Add(time.Second), time.Now(), true},
+		{[]byte("hello2"), []byte("hello1"), true},
+		{json.Number("124"), json.Number("123"), true},
+		{645680099112988675, 645680099112988673, true},
+		{1, 1, false},
+		{1, int64(1), false},
+	}

-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, GreaterThan(time2, time1))
+	for _, tt := range tests {
+		assert.Equal(tt.want, GreaterThan(tt.left, tt.right))
+	}

-	assert.Equal(false, GreaterThan(1, 2))
-	assert.Equal(false, GreaterThan(int64(2), 1))
-	assert.Equal(false, GreaterThan("b", "c"))
-
-	bs1 := []byte("hello1")
-	bs2 := []byte("hello2")
-	assert.Equal(true, GreaterThan(bs2, bs1))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`124`), &jsonNumber2)
-
-	assert.Equal(true, GreaterThan(jsonNumber2, jsonNumber1))
 }

 func TestLessOrEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessOrEqual")

-	assert.Equal(true, LessOrEqual(1, 2))
-	assert.Equal(true, LessOrEqual(1, 1))
-	assert.Equal(true, LessOrEqual(1.1, 2.2))
-	assert.Equal(true, LessOrEqual("a", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{1, 2, true},
+		{1, 1, true},
+		{1.1, 2.2, true},
+		{"a", "b", true},
+		{time.Now(), time.Now().Add(time.Second), true},
+		{[]byte("hello1"), []byte("hello2"), true},
+		{json.Number("123"), json.Number("124"), true},
+		{645680099112988673, 645680099112988675, true},
+		{2, 1, false},
+		{1, int64(2), false},
+	}

-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, LessOrEqual(time1, time2))
-
-	assert.Equal(false, LessOrEqual(2, 1))
-	assert.Equal(false, LessOrEqual(1, int64(2)))
-
-	bs1 := []byte("hello1")
-	bs2 := []byte("hello2")
-	assert.Equal(true, LessOrEqual(bs1, bs2))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`124`), &jsonNumber2)
-
-	assert.Equal(true, LessOrEqual(jsonNumber1, jsonNumber2))
+	for _, tt := range tests {
+		assert.Equal(tt.want, LessOrEqual(tt.left, tt.right))
+	}
 }

 func TestGreaterOrEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")

-	assert.Equal(true, GreaterOrEqual(2, 1))
-	assert.Equal(true, GreaterOrEqual(1, 1))
-	assert.Equal(true, GreaterOrEqual(2.2, 1.1))
-	assert.Equal(true, GreaterOrEqual("b", "b"))
+	tests := []struct {
+		left  any
+		right any
+		want  bool
+	}{
+		{2, 1, true},
+		{1, 1, true},
+		{2.2, 1.1, true},
+		{"b", "b", true},
+		{time.Now().Add(time.Second), time.Now(), true},
+		{[]byte("hello2"), []byte("hello1"), true},
+		{json.Number("124"), json.Number("123"), true},
+		{645680099112988675, 645680099112988673, true},
+		{1, 2, false},
+		{int64(2), 1, false},
+		{"b", "c", false},
+	}

-	time1 := time.Now()
-	time2 := time1.Add(time.Second)
-	assert.Equal(true, GreaterOrEqual(time2, time1))
-
-	assert.Equal(false, GreaterOrEqual(1, 2))
-	assert.Equal(false, GreaterOrEqual(int64(2), 1))
-	assert.Equal(false, GreaterOrEqual("b", "c"))
-
-	bs1 := []byte("hello1")
-	bs2 := []byte("hello2")
-	assert.Equal(true, GreaterOrEqual(bs2, bs1))
-
-	// json.Number
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`124`), &jsonNumber2)
-
-	assert.Equal(true, GreaterOrEqual(jsonNumber2, jsonNumber1))
+	for _, tt := range tests {
+		assert.Equal(tt.want, GreaterOrEqual(tt.left, tt.right))
+	}
 }

 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))
+	tests := []struct {
+		left  float64
+		right float64
+		delta float64
+		want  bool
+	}{
+		{1, 1, 0, true},
+		{1, 2, 0, false},
+		{2.0 / 3.0, 0.66667, 0.001, true},
+		{2.0 / 3.0, 0.0, 0.001, false},
+		{float64(74.96) - float64(20.48), 54.48, 0, false},
+		{float64(74.96) - float64(20.48), 54.48, 1e-14, true},
+		{float64(float32(80.45)), float64(80.45), 0, false},
+		{float64(float32(80.45)), float64(80.45), 1e-5, true},
+	}

-	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))
+	for _, tt := range tests {
+		assert.Equal(tt.want, InDelta(tt.left, tt.right, tt.delta))
+	}
 }
--- a/convertor/convertor.go
+++ b/convertor/convertor.go
@@ -20,7 +20,6 @@ import (
 	"strings"

 	"github.com/duke-git/lancet/v2/structs"
-	"golang.org/x/exp/constraints"
 	"golang.org/x/text/encoding/simplifiedchinese"
 	"golang.org/x/text/transform"
 )
@@ -488,7 +487,7 @@ func ToRawUrlBase64(value any) string {

 // ToBigInt converts an integer of any supported type (int, int64, uint64, etc.) to *big.Int
 // Play: todo
-func ToBigInt[T constraints.Integer](v T) (*big.Int, error) {
+func ToBigInt[T any](v T) (*big.Int, error) {
 	result := new(big.Int)

 	switch v := any(v).(type) {
--- a/convertor/convertor_test.go
+++ b/convertor/convertor_test.go
@@ -748,9 +748,10 @@ func TestToBigInt(t *testing.T) {
 	assert := internal.NewAssert(t, "TestToBigInt")

 	tests := []struct {
-		name  string
-		input int64
-		want  *big.Int
+		name   string
+		input  any
+		want   *big.Int
+		hasErr bool
 	}{
 		{
 			name:  "int",
@@ -759,17 +760,17 @@ func TestToBigInt(t *testing.T) {
 		},
 		{
 			name:  "int8",
-			input: int64(int8(127)),
+			input: int8(127),
 			want:  big.NewInt(127),
 		},
 		{
 			name:  "int16",
-			input: int64(int16(32000)),
+			input: int16(32000),
 			want:  big.NewInt(32000),
 		},
 		{
 			name:  "int32",
-			input: int64(int32(123456)),
+			input: int32(123456),
 			want:  big.NewInt(123456),
 		},
 		{
@@ -777,13 +778,43 @@ func TestToBigInt(t *testing.T) {
 			input: int64(987654321),
 			want:  big.NewInt(987654321),
 		},
+		{
+			name:  "uint",
+			input: uint(987654321),
+			want:  big.NewInt(987654321),
+		},
+		{
+			name:  "uint8",
+			input: uint8(255),
+			want:  big.NewInt(255),
+		},
+		{
+			name:  "uint16",
+			input: uint16(65535),
+			want:  big.NewInt(65535),
+		},
+		{
+			name:  "uint32",
+			input: uint32(4294967295),
+			want:  big.NewInt(4294967295),
+		},
+		{
+			name:  "uint64",
+			input: uint64(18446744073709551615),
+			want:  new(big.Int).SetUint64(18446744073709551615),
+		},
+		{
+			name:   "unsupported type",
+			input:  3.14, // Unsupported type
+			hasErr: true,
+		},
 	}

 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			got, err := ToBigInt(tt.input)
-			if err != nil {
-				t.Errorf("ToBigInt() error = %v", err)
+			if (err != nil) != tt.hasErr {
+				t.Errorf("ToBigInt() error = %v, hasErr %v", err, tt.hasErr)
 				return
 			}

--- a/cryptor/rsa_private_example.pem
+++ b/cryptor/rsa_private_example.pem
@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJKAIBAAKCAgEAxyEWKk4SEjsNfEJ0pBH7dLaWGuHVwQn45oOG4Bo5XwQhpgTm
-1TD+OgFg69BSeJduGtUExbcWEk8SAWgaSMk92y8L/33cncabwDhLzMNOk1NBie9S
-cUENh8zVq5oJF6B16Ijk6gbhAuQ2KExA//FNwU/AeG+nY5/mXMAqnxkl/INJd+UC
-RoEOZ+fvWDVyIS0zqb1XIQoi+rGVfcpaFX+O+wPyHbbgRVVQjgimSq1DRSFHX19v
-RNQNWnNR0x01PsyTsSjNGTOKRInfupQEB17B7EmOFU8NV7+PIoIlKSnSkl6jhpMP
-Zd+Kd55ldlnybOLCFE4e+tzbCIG9pvI+wEDlKs/q4EUS8a4vJzpSc+WPAzohIkG6
-NTN6mh0V86dfexk+5lrnZ+zOb47769pOJy2NnTMwUd6MMJDe5rm2coMSTNI/8uD3
-vHiQuh1Sbc/ognbk0kgI8/8mqjmy/C3nCbB4hzwdYrv04HOT3WIL7rWWmWYkwbO+
-JitXFaFka0/2dQiA4P+po3Q4JipMEskG7SlWNZAMvpuU5OnRW5d40sJz4vsEVwzO
-BoPWVupXplXlZ6ipBGySovL8LJGUI6CF6qfwG8gCjojkz1Y44gxyR/Zt0idqZkel
-TBReIHiYK5r3Ql4OiGfCmMhDD+PQA3FlD0gNC48ZLXknzEfvOnzqkETx3YMCAwEA
-AQKCAgAxh4RI34RVLoULLEhw6twdyrCJXTTawA094OcyZLNyc8ee0MdNrdL+QIuH
-/BgXUKsdV3DJcOG3ih1TZj5rbkrJculMElVGlTj2Vcpc0xN/R40crv9VljW0Wnmn
-JjguvUW2oh42K6HaI0NpQJZGUxHhDGI2UqdS+1nEJjQzwICXT1x9yuOG/+DCbYk1
-6o1JvUGFbcf3Ots6eeNSF3vSrxi0TOXzCCK+fBr+SR57op8B2eYzzbwSZaAwqFBo
-73Hn/eCahyiEpTI2HAkfEmPyJVqc2CrUGAacldQXZEGz/GgY6htIhNmmoDSDzk00
-Y+kNtlVJ0aiZA0gj1ImEtepvzXRygjkFwcnaP1jezdT9yOQeEgPDIMzLWHB+25HA
-2lBlTtobPBkBMrnDSEbNtrKY/P8pwXCdPNveO29ILJYgMwpxF5+yA2KcAzCILUvK
-c1HTJHgso3+7okUhmotQ1cs1rqe1W8kAL4SW9dREeyTrEjMtSjUfGrtYWtarZHJi
-qDzB6RKXwr21fNcNnTF3OJtnaslSpWcSowSrd/s3d9M2EURHAOi+pLJas7YubyvW
-uJkKayvCy7XbF7FWd/AqKraZ3SpFINos8WJP8jqzdVgduaqa3HncRoLRGuVCy0tB
-8/x5D8nlGBXme7FVhGghAvpPu/nKrxcjB6XVXpuMgqlpPm/haQKCAQEA7AF2AhlQ
-pZ5u9KceNenzUK18ZV2cIdFq0/Sn1Vh0DGzEdIuNTxBBgR/qtz9qX6xd29skVKU5
-JGvihegI5aL4bkYXUBGn6xdi3E3fdAiZ34zLlhGCMDz2509kUzfUjg5ws1nBS1kW
-HhPQDWObaUszWTqEWglByCHauMMZO4NxMxce9REdC0qMKyWda9T2TN4zGKvi9ftP
-RvLE4Jr8/0xYKVi/5yQEc+NZSTWl7SXWAgQJONjfxY8pyxEhXHXA8/DgO79ANaAy
-xk0PuzjEp8LmMACpCr+DR0Nc6FtWDhtfGBy4aza/ThfsH8ordXOrv/24eJR3bPDA
-B0xDR7+6QObcfwKCAQEA1//XbU4WbAE1jVUXX01CMiKUJyXli+hcBuTz37PElaHn
-ASmoVZzKuOF0PlTdAUNHd3VckP+/MlGSZLyrdinVu3QnnzYmzfLHRvxs0/KG43V4
-cswI+vPA3UAALYp7mlgPGSVwZvAl0nk3OVdNXB7ubDw2aUtPHOHt9F1tnatQQTOI
-YnyhUaE5IIlwEgn+7iwCLBhZdGSK5ldZh1l+kCgGXSV7A2mY71ktkeUl66ZIy0/Q
-4vZqoGRi8iEKy5zh48yw0971ATEl//6T5BWsjQZ4lXPPStN6mNWC/kdWLrQTc2Do
-iHVR/BRZXpOyRpzvJ/ygMv5bU2vwxz3bnIk0x4wM/QKCAQBvSAkS2Ej0rw32gk52
-cYfvRL5hNZCHSa2rn7L7oCeoLCk+IwdQfoPElP4hxd8smaPwJRauavHUwKIhLdX0
-IbIunRIlCQ46hd5xrq5skhmsFUFx03OltzlcvEy8CJlLGnf9uZaxJqKNMB5sEcmY
-DoN50WPS6IaCDaSKdkQRkdrwkjhgqd8eEdqiBayCyfoRKLzDJ1lvTz6EX7iBh9M/
-tgnkBRsHrC4FTvAs2wUQG0Ub0jde/LQW/XhhbgRjCose+zdgNL/cCVunsXJ3fz8L
-M5VCkS0kCkWmdpb6YQbkw/dE8VXsB/aQpisKmlN/oDkd4E75XFgroCGLz2PyEu+J
-5tGVAoIBAQCjuIWGkVjHdscroGK91uak77bSUZRDTtVqWGJNnooUTQq2w+eXNOgn
-6KPelx6JVYC3GFsYgPFgZ5oKB0QDpcQeePWLZVVWZ34K3Uxz/nGluSWaBfOMm/QE
-//ziiAQWQkb3bXxcWgyhE0X7jaPSfpODsMQhXXbS0qE1xxdOGksTkMcAt6zjHcwa
-UHKFCdSUnQDsgWxUn9z0qSLwR7J5/AyOz9kFBiZozXSQEFuE2Z51lMMlNVguyMiC
-9O6k1P4XV9B0V5vn0mQWPNXGXXNT1aLSzVxDQDa936CRsmqtrcrMepjmzd5druLq
-oBLSGSPhcEfRPyDkA34W11k9tnYuBobVAoIBAD/7gL7teaalfpiAxDmnoWKiFcT9
-XEBdfBF6grlieGFCIaHgK9/Piz8E/NsoSw0eRghIJRWuIZyGvPnuecUKdv81oaCJ
-gTr3UYL8IcpKSWRl0qSmzl/UeMXlYLJZPoThjU5v7KZqKS+yVZj4Z0vA0dN2cY0h
-5qFm33Nq4jmmsYw/PhPmKHTwZtgdhHV7gfN8d5KJLBsgEDfJggiv0LHJ22LZvFK8
-6KgBcnNExCRK0nx8Zn+iAnK7tKg2XHR8nSTWmUDdYQJBxMAtdvIOWrOHeg4RoxGT
-m3TstAN8J+h3P8NSzXwT6ekHj+MHuW5VdZkbYxaDY2pFDQE7XzcCPHww1nA=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 -----END rsa private key-----
--- a/cryptor/rsa_public_example.pem
+++ b/cryptor/rsa_public_example.pem
@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxyEWKk4SEjsNfEJ0pBH7
-dLaWGuHVwQn45oOG4Bo5XwQhpgTm1TD+OgFg69BSeJduGtUExbcWEk8SAWgaSMk9
-2y8L/33cncabwDhLzMNOk1NBie9ScUENh8zVq5oJF6B16Ijk6gbhAuQ2KExA//FN
-wU/AeG+nY5/mXMAqnxkl/INJd+UCRoEOZ+fvWDVyIS0zqb1XIQoi+rGVfcpaFX+O
-+wPyHbbgRVVQjgimSq1DRSFHX19vRNQNWnNR0x01PsyTsSjNGTOKRInfupQEB17B
-7EmOFU8NV7+PIoIlKSnSkl6jhpMPZd+Kd55ldlnybOLCFE4e+tzbCIG9pvI+wEDl
-Ks/q4EUS8a4vJzpSc+WPAzohIkG6NTN6mh0V86dfexk+5lrnZ+zOb47769pOJy2N
-nTMwUd6MMJDe5rm2coMSTNI/8uD3vHiQuh1Sbc/ognbk0kgI8/8mqjmy/C3nCbB4
-hzwdYrv04HOT3WIL7rWWmWYkwbO+JitXFaFka0/2dQiA4P+po3Q4JipMEskG7SlW
-NZAMvpuU5OnRW5d40sJz4vsEVwzOBoPWVupXplXlZ6ipBGySovL8LJGUI6CF6qfw
-G8gCjojkz1Y44gxyR/Zt0idqZkelTBReIHiYK5r3Ql4OiGfCmMhDD+PQA3FlD0gN
-C48ZLXknzEfvOnzqkETx3YMCAwEAAQ==
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAtgIZs9XNOtSKkDhGqXu7
+kEM4Lwr+A3P+Zc5qQ2hdIj95kp1S2xbk7yvXfYSK7vP1u+dW/X5u1iLEErKhm2Gv
+5N7sZfYT33v/w+R3VnceNBr+hAuPUihSWCWp1auywRvELpz83SgOEHt6IyRtcFLm
+VgcW8Ii2oAkD+0KrXeX2h62aqWf89joPlNwgZtbCaz9ROUhZRvsI6B7cUnqOLcoF
+b6VKZq0wfn1z/QOapN62dy7gcYhinC+u5Y5cWcycBj4y5xXArlUKDOLGi7yBt8xv
+P5eM5EJ2G8y8yMbu1v0/4LLohkuqiNGOfpx3nfgeq3WthbPTkCyMxro/bObJWG9J
+E9fAj/ex1eU/f+LfZt73nziBxGx9R7kvF5+UkbtSrOSSwKHSl0Y+593q+rT7sWfu
+RYiUBYEEeeuyo245hIQDkpLqtZg1+6tvh7FFPmdKNQy65JAyRCP/MCwsuuo4KgH2
+3Bml+EZbEz2mBk1BdBKfxO7j4QsWFXJ+s1NOEERcTddKIz6uB2K/rvvi8vxY2blB
+pZFjSXFbTk6i5+uNqF5WbgDxobZ3vkHWog6AgglyVuhjtMacq9xnUnTNuTGuiZWh
+Y3LXALV9a3JyVwFWzn8VkBdm9Vch6NA49czwkRXZghvexxtUoduAwheVoYn281CP
+AMTYgbhocnIOfHqWDo3pAkCAwEAAQ==
 -----END rsa public key-----
--- a/docs/api/packages/convertor.md
+++ b/docs/api/packages/convertor.md
@@ -1153,12 +1153,12 @@ func main() {

 ### <span id="ToBigInt">ToBigInt</span>

-<p>值转换为bigInt。</p>
+<p>将整数值转换为bigInt。</p>

 <b>函数签名:<span style="float:right;display:inline-block;">[运行](todo)</span></b>

 ```go
-func ToBigInt[T constraints.Integer](v T) (*big.Int, error)
+func ToBigInt[T any](v T) (*big.Int, error)
 ```

 <b>示例:</b>
--- a/docs/en/api/packages/convertor.md
+++ b/docs/en/api/packages/convertor.md
@@ -1126,7 +1126,7 @@ func main() {
 <b>Signature:<span style="float:right;display:inline-block;">[Run](todo)</span></b>

 ```go
-func ToBigInt[T constraints.Integer](v T) (*big.Int, error)
+func ToBigInt[T any](v T) (*big.Int, error)
 ```

 <b>Example:</b>