fix: github action failed

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:
+	case int, uint, int8, uint8, int16, uint16, int32, uint32, int64, uint64:
-		if left, err := leftVal.Float64(); err == nil {
+		left, err := convertor.ToBigInt(leftValue)
-			switch rightVal := rightValue.(type) {
+		if err != nil {
-			case json.Number:
+			return false
-				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 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) {
+		right, err := convertor.ToFloat(rightValue)
-		case json.Number:
+		if err != nil {
-			if right, err := rightVal.Float64(); 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 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
-				}
-			}
 		}
 
+		return compareFloats(operator, left, right)
+
 	case string:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case string:
-			switch operator {
+			return compareStrings(operator, left, right)
-			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 bool:
 		left := leftVal
 		switch right := rightValue.(type) {
 		case bool:
-			switch operator {
+			return compareBools(operator, left, right)
-			case equal:
-				if left == right {
-					return true
-				}
-			}
 		}
 
+	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
+}

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
+	tests := []struct {
-	assert.Equal(true, Equal(1, 1))
+		left  any
-	assert.Equal(true, Equal(int64(1), int64(1)))
+		right any
-	assert.Equal(true, Equal("a", "a"))
+		want  bool
-	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
 	}{
-		A: "a",
+		{1, 1, true},
-		B: "b",
+		{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 {
+	for _, tt := range tests {
-		A string
+		assert.Equal(tt.want, Equal(tt.left, tt.right))
-		B string
-	}{
-		A: "a",
-		B: "b",
 	}
 
-	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))
+	tests := []struct {
-	assert.Equal(true, EqualValue(int(1), int64(1)))
+		left  any
-	assert.Equal(true, EqualValue(1, "1"))
+		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"))
+	for _, tt := range tests {
-
+		assert.Equal(tt.want, EqualValue(tt.left, tt.right))
-	// json.Number
+	}
-	var jsonNumber1, jsonNumber2 json.Number
-	json.Unmarshal([]byte(`123`), &jsonNumber1)
-	json.Unmarshal([]byte(`123`), &jsonNumber2)
-
-	assert.Equal(true, EqualValue(jsonNumber1, 123))
 }
 
 func TestLessThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestLessThan")
 
-	assert.Equal(true, LessThan(1, 2))
+	tests := []struct {
-	assert.Equal(true, LessThan(1.1, 2.2))
+		left  any
-	assert.Equal(true, LessThan("a", "b"))
+		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()
+	for _, tt := range tests {
-	time2 := time1.Add(time.Second)
+		assert.Equal(tt.want, LessThan(tt.left, tt.right))
-	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))
 }
 
 func TestGreaterThan(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	assert.Equal(true, GreaterThan(2, 1))
+	tests := []struct {
-	assert.Equal(true, GreaterThan(2.2, 1.1))
+		left  any
-	assert.Equal(true, GreaterThan("b", "a"))
+		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()
+	for _, tt := range tests {
-	time2 := time1.Add(time.Second)
+		assert.Equal(tt.want, GreaterThan(tt.left, tt.right))
-	assert.Equal(true, GreaterThan(time2, time1))
+	}
 
-	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))
+	tests := []struct {
-	assert.Equal(true, LessOrEqual(1, 1))
+		left  any
-	assert.Equal(true, LessOrEqual(1.1, 2.2))
+		right any
-	assert.Equal(true, LessOrEqual("a", "b"))
+		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()
+	for _, tt := range tests {
-	time2 := time1.Add(time.Second)
+		assert.Equal(tt.want, LessOrEqual(tt.left, tt.right))
-	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))
 }
 
 func TestGreaterOrEqual(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestGreaterThan")
 
-	assert.Equal(true, GreaterOrEqual(2, 1))
+	tests := []struct {
-	assert.Equal(true, GreaterOrEqual(1, 1))
+		left  any
-	assert.Equal(true, GreaterOrEqual(2.2, 1.1))
+		right any
-	assert.Equal(true, GreaterOrEqual("b", "b"))
+		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()
+	for _, tt := range tests {
-	time2 := time1.Add(time.Second)
+		assert.Equal(tt.want, GreaterOrEqual(tt.left, tt.right))
-	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))
 }
 
 func TestInDelta(t *testing.T) {
 	t.Parallel()
 	assert := internal.NewAssert(t, "TestInDelta")
 
-	assert.Equal(true, InDelta(1, 1, 0))
+	tests := []struct {
-	assert.Equal(false, InDelta(1, 2, 0))
+		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))
+	for _, tt := range tests {
-	assert.Equal(false, InDelta(2.0/3.0, 0.0, 0.001))
+		assert.Equal(tt.want, InDelta(tt.left, tt.right, tt.delta))
-
+	}
-	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.go

@@ -14,6 +14,7 @@ import (
 	"fmt"
 	"io"
 	"math"
+	"math/big"
 	"reflect"
 	"strconv"
 	"strings"
@@ -483,3 +484,36 @@ func ToRawUrlBase64(value any) string {
 		return base64.RawURLEncoding.EncodeToString(marshal)
 	}
 }
+
+// ToBigInt converts an integer of any supported type (int, int64, uint64, etc.) to *big.Int
+// Play: todo
+func ToBigInt[T any](v T) (*big.Int, error) {
+	result := new(big.Int)
+
+	switch v := any(v).(type) {
+	case int:
+		result.SetInt64(int64(v)) // Convert to int64 for big.Int
+	case int8:
+		result.SetInt64(int64(v))
+	case int16:
+		result.SetInt64(int64(v))
+	case int32:
+		result.SetInt64(int64(v))
+	case int64:
+		result.SetInt64(v)
+	case uint:
+		result.SetUint64(uint64(v)) // Convert to uint64 for big.Int
+	case uint8:
+		result.SetUint64(uint64(v))
+	case uint16:
+		result.SetUint64(uint64(v))
+	case uint32:
+		result.SetUint64(uint64(v))
+	case uint64:
+		result.SetUint64(v)
+	default:
+		return nil, fmt.Errorf("unsupported type: %T", v)
+	}
+
+	return result, nil
+}

convertor/convertor_example_test.go

@@ -571,3 +571,12 @@ func ExampleToRawUrlBase64() {
 	// dHJ1ZQ
 	// ZXJy
 }
+
+func ExampleToBigInt() {
+	n := 9876543210
+	bigInt, _ := ToBigInt(n)
+
+	fmt.Println(bigInt)
+	// Output:
+	// 9876543210
+}

convertor/convertor_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"math/big"
 	"reflect"
 	"strconv"
 	"testing"
@@ -741,3 +742,83 @@ func TestToRawUrlBase64(t *testing.T) {
 	d15, _ := base64.RawURLEncoding.DecodeString(r15)
 	assert.Equal("4+3/4?=", string(d15))
 }
+
+func TestToBigInt(t *testing.T) {
+	t.Parallel()
+	assert := internal.NewAssert(t, "TestToBigInt")
+
+	tests := []struct {
+		name   string
+		input  any
+		want   *big.Int
+		hasErr bool
+	}{
+		{
+			name:  "int",
+			input: 42,
+			want:  big.NewInt(42),
+		},
+		{
+			name:  "int8",
+			input: int8(127),
+			want:  big.NewInt(127),
+		},
+		{
+			name:  "int16",
+			input: int16(32000),
+			want:  big.NewInt(32000),
+		},
+		{
+			name:  "int32",
+			input: int32(123456),
+			want:  big.NewInt(123456),
+		},
+		{
+			name:  "int64",
+			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) != tt.hasErr {
+				t.Errorf("ToBigInt() error = %v, hasErr %v", err, tt.hasErr)
+				return
+			}
+
+			assert.Equal(tt.want, got)
+		})
+	}
+}

cryptor/rsa_private_example.pem

@@ -1,51 +1,51 @@
 -----BEGIN rsa private key-----
-MIIJJwIBAAKCAgEAxZGG6vSSETKwW7bxx7NA1tXmNh+0AAsOmdwOyd77C/F7bmf3
+MIIJKQIBAAKCAgEA66tu9qYNO0QeeeMaEJohWeBS7KdPQwVFt+5+kRhPST+xI6A8
-iacdzsdJgumWpBZLpo7Xdke/6NWbzizdbawbBKkLH5vdZpEYJsbIx9vQYPRrAL1t
+TtfccOtZM4Zc7BnSfTTQvcvF6HhOOn+PDYoiVr/2dK4yZHm7wH35riqtvv0TYVNT
-aRHpWwqC86aZHhJ8afo5KARkW8U1BB+MCfJ0oGOgkpHPbbs7jRNhrUP52BPbdRUw
+deKDmW3vZy8SR7Cpedl5a+BEc7D1PBqHMwFnf/aJLY3AWp8VbHf0g1HcIL1xTXsF
-7ZwwJHEseuAvw+nv80UmHdI5mrgKj//8r+cB1JnErqJi0yTOgYwKqOPFcMoaCoyL
+XFn283zUEHrg1XNmJlT0nLuKaBjIqGBqWZWIfCyOK5ZhhKP9vhRhY+u+/HQ1+CLw
-RdMV8en1QZ7nY6KWF32K/OBGM8++lRsZGttFThx3Zs54QU2GFgthH5rkMtucuZUX
+66qzAN6ZngR6Ra6B0bvx0D38Hy/FxLonDautozd17C+zwQ6V5/PHLDRAqcZRvJUJ
-DN2k+QqV1XrSC/a+IDZ1zhx0+NUuExktOpOqkvc4IslIOPAcBJ4MoUWShOy91rW3
+3E163gGEjBOTLU5T4FGxOaSBO4Dpw6J+wJRFuOyq3fB6M62R5x66U53p3GlWpNWs
-4QSV2ZgD6VMTYMce6xpH4Oh680I4ZtewZiRdBnQ4EADoxPbiBHfTQJfzUBtaZDXq
+YkN3mk3JfI0+xsbi/Ry5jhdXOHANrks7eoo8SoAOEWidMZGRYpkiTkFgMHmjsrM5
-OFNN+friCITTKice0dByDlCN85bL7et0hyIsFU1xi0SmFbt3IBFwsJf5B/aorLhZ
+sUmsEpM+B93Kouij3CH3p9KAzfAz/I573pBz3xuXDsbhlQIncRLOIFXP/VxU/IUs
-qwCIUFvf7EahOH51PlGr7M2ltZtpgHmFBzB0zYAoYOnDU1+avzVP5l9fObH4uLl8
+f81blhsWZ8ZQg1HyB7vWDyAR0BFuIKWDMlznM85kMoPpCpI1UUfOw1hLQwHRBuVI
-/fjeAr8pSB0drjaKf0Bj434aKrrftDyeGuMWpXhFu9rr/eXXUVqU/jBfHR+60m+M
+U8v+lgJhimHZtrDPEvOmXLTGBJLUePFEMI7lbL9XQTkMBXRgJ7hjxfYutUv6Wpoy
-BK9h8efkqtVW3EqNVApsapRFo/LNNDAC9lCKWuFBjh0igdZNjSuatG9O9rMCAwEA
+YP/vfUq7GN6X4JQzgCd1timJc/ljqTDbzT5NGxk8mhjoAhZFpRciSyt5+6MCAwEA
-AQKCAgAkwpkZ6nurG4VY60c9YwrzbkUxWODDCUukMR/HS+fmJv5SYqHaSO/w43+4
+AQKCAgBZYp9mq5qPJQoOHuXu8BbAOQYavmagu+oyliGpNLg1xxOPuKHHIbZ5mbou
-DgJrcYKN8RIB/gOlLOmaiRqCJ323dkSNkxC03tZhkKcXGL1C7Pdj4dsTq7OBrwkC
+gcLSxgSA+rxFkHlS7/Zz15fRgdf+YTbAEKYKV+WvX9iIh6V4sBJesrUQHEbftcO8
-kML4p3PivB4aZgbOVHky1TPXPfeZSDA+VUcFIctIyoxoErfQDpHMzS6XZ3JFtZET
+tizPxiCxl5unH9u2qaKKFmG7Jcg0z7Q98+rGNFpy1piGClFclZ3YzlU9Lt4sgecJ
-I9d/Wm29E+atscnqEchVVsoLaK4cgqfn3msI4lZSIF5zYj4AaHpD8DaRvV7d7iwm
+DSIjs25GEajpnXQkgWnx+we7TK0Es/2EaLg6D90Y8C/0LyE0LXueztnj+M2GAefv
-E4z2KvBGWqObvZcSWNsbHzmil53jlMRaqpwRen0yaNefa9B97gLRPP5W9H6Xn/KV
++DDMJyEUBJ315tyuk3cGY7iWRcxJAKsYVwttqPOQk3SyvmrcOd0cksa3qSd19sto
-EA85DqX9lGSC/yR8kB3Mi+iwd31LGsxXWHwTZEtyMLGjNxhkFU122iCFGsVex8zn
+ObBz2aaUiUeX3l4pzH5ddk9vCY3bmGj5GzkqDHTT1Bj9Xi1gw5H3Kl3o+4CTIJOb
-2bWWQ1ANczA9gyAe8Frap2ydlZw5wiToaF4+82RnndQy0RSWWUXiKSrnZjqXDEOf
+VbhRacUczEI65e+Ad/cVR6x+iqQN1zTAzI8f90Y/HJttSE2M/T725jhpC270sFiL
-NDMXBM3STT2eE6xLgIFyV/1vll4/YXoJKU217Zg4zkZ7AFWpfGXzWtlZ63ku2Ek1
++qaqVPQHBpr3yDX/IdsLTYo9UaK4Y7fWUmRGTBYCmYhR5h3CW7NX9ICXnvYDB2x3
-CD8bupgTM9dLcC5vkgaiOSdSVClmgI3wr0Gbg4Swxl/DccpabOHc4/lEm59SuSXj
+67EJcYfQSj4hBfgNLO3qMRw8ijg8TGMHW0IK9XUX9XEhy1AL+aWeXlkgs1JxYGIV
-s4ZUh93dxoYvsNvzyPD0AdIhEp2xSofD6Q4qU4l5kBudIYS4xYXKVzwbbP5spixe
+JTMDPz+vO3ISmkJ9aLR2TlgeXytDJ+9l8OuZxrG5fZhTKqMne9krV4fJHamq04qU
-7qdbQnD9s+ufPjFBMRgU0FV25dyKVNCM6JlfwdYGkVDYSclDQQKCAQEA/a43eS/0
+18g5sJmqVkVugUAn93e7/ll+UVnKMriuX55+JRs5ol0Rj11GsQKCAQEA/1/lXPWD
-GGhASs4uM7P1iLMiDkFfsotJsPQ3klIv6m1XBjKFl4y5M0SbP9NBb0cPsReR4xCx
+YkYMrx9BHuNOSCAol/TCvntD+uB5BoCRpC4TQ6nsAkQEPUVBiw2fs5slIaPotEJC
-vyxui4gAVhjc6HBj//zegLjdzg2aGZdc0zrYocaW5CHd/IyQyRv5JwbVWWUC+Y9f
+VblhHaEg8TduXJvr+5XrtFuQuj27rMRqx+t0m3aOT+2Z72cp79b1wiZ4iJ7U/Mf9
-RlNEZB/WFzHbLjXaVDiVwiadURHVb0gr8LBJNp0CZ/poqQf3JwNLshVA79EE7aKv
+mga28GrqfCIgfWwn9wUJyyEBPtnuNC8JH7mI+eY3FOyMNQgQFJSDQl/nsA7tRO1w
-2R2CKTFzv/GrePMZxoAH7U89qg7Nx9mmJfkC0DgTSem20ADdCDzivhFkYWRmd2k8
+q7GmjeFG2mZrY24c0x6Jd7HwQBZREMzw8x3xZdbM5Sj1E802QfnEzYbuvT8BCOUW
-5E35d5ZCUz8YsDhaaIEi4MkRrC4wx8TJ/M9l0jWNNtoqqROhSdMQ40Hlc+azURWH
+gP5+2khuu1rAjVvpXiWZUD9iGvmRVDrtSUhyXpjGfa4b5DG6OuelqRGk6VKF9pfL
-0jeVVw+iQYUBQwKCAQEAx1/4ZU+RzG6PiyImzfD30i972mhJk1KJ6m1K6WkklS6E
+UD8orAlASesCewKCAQEA7D8vCOxQQBpIHB1GzXma3Bbe0Z6AH8hp9ltNO3Ynry2s
-r1GttarK/ZLdueOsHQ0+YsAz8HECWJluvlI1GoXwvtrQJ4uB2vAyaSb9mer96O4G
+Md5HdeQVDLZjjmgk+pZOerhjtCkKitgyjumZSigbPgSsvdjHDr+5UIHdZ3KIdpbE
-+VjOhXBtLCKrE1Gir2ciUM/49etFe5phplxflmNKIZm/8RFSRtcMfM0NyIXvQKRL
+tBO4ovzq/EGm5RKlTt+f1N65qIo72ySVBZJvzDt3yD6iUZyMSjOOx4pklHq3SzQE
-j3rsbG6MofhPQe5dqV/e/KkgK0YTZjz9qlFiAUOQK5RtJ634QHa+27wygQ71KoIr
+WBnZtgDzG30nU5PMupiyeRLLLi5iA27hIUF2D4hNuC3VZsDdU36e9AMi6d+wgyIN
-A/gfKTzo4Hvlt1ZIoVSc/wJI5q3jcTp3jecnE7ZeqZEq39ECSFK4wIp+BTV9dgDF
+vM0z67Kb+KjpfOTN89ZozPpAVDk82T98Z2dJkEOwCmGazdcIncUhrDbPOjoAVTaj
-rqJfBv+T8WXPWlyWYL2PDaVjkcP+hnZyndhrxIjl0QKCAQATGzQCZKI11GRDPhQs
+YH8LGb/qdGv+cw9TmiIpcdlnWz9BC7GS/Myv6qoW+QKCAQEA7hHQGSEoIm17Vaal
-wLkVeqht+m6CvAro0Pv+gUIqneGYDeYR6/9m5RvsSrT69Jcx91x9hZxdkbMhvzSH
+Zs4xJDwWm9Kp2jm/3hl1ugIRxCTQALxgMJyH9zahK6i/wQhZTUsonSNIA/KV/rE/
-R4gb2ZsuhJUdjM7n3g5lLwlGv3/hb1ueAw79HnkpLHovfkxDV2BJ+4ppeYwFHoC5
+rKAoWl1hWWEiIzlZasYyN5XEliuCwYt8kDbI0s4x4k1bPmvu4i5wEFfAq96mnOqP
-bn/bkyLGhRyCavYeTQGOSBlHH3/kJR8xRaLsWDU9MvpYh1FEvrFoVIB6Ecbj412c
+Prnx3/r8JuSjhKJ4LsersSpILzMf5xgfMXp0GtwxYX4x/6a4rwC7YQ6ZgvZSduIU
-b09C5MxkLvBp5zX1wPeuva3N3ltf41lQj9G9CNOc8zkAp76vtygghkSXzWekoiSM
+03W3lzIH3SkSrmtLtfMYD7l+xqabbH0a9meAUb11X3whZBjuZ65coJYwrICUcZok
-sIvjedsVU+SUmZBDL5ds9F1iNRyuIGpqXzQnV9sl/EehVi059X479SstohIVZJAL
+4LRx3VZZ8FLM4mq0YsFWIlfs7eyD8nwqTvAJQGq7Wj6pyTuRqZItIP3RpDW9DORy
-70CRAoIBADx/69FaXuTJG/fdaicOGzWFwTCaetEgt8cSWSwRAs/eKNdGks7Qv/5I
+8nYMEQKCAQAnmTugCkQ1SnJ1y+53OH/djjPQ/PlK2oPwWENsyRRDx6sKPNDLkOx6
-hc31v3GlZivzJQ+uS0b1cDyCl6ivwkk3/vgxBjuYrcNo2IXPYDNBn44km660WfyN
+UgQD9a7lFdaXuVp080AiH7TxwXQBOxG95nix5akP7tD4Dpx233rCLelQqdGT+ELG
-nJolKJfPVQNuyJ5fQVtrknw4Ba2N/Z3KmQse9XeXpCtu0eLqeZqFAITOiVWyCizQ
+/5Yi5Wox+0fGHYMPHgSEafBUm8QDfqBIPz9j4JKfSV8QUUEkpiEdCN4Fime0mxok
-O8TG/1b5R6Il9CQNhK9+jH8VaQb3KJWA2cqzqORu5CWrqyusjUrT6xeuQE50NDqC
+rGiwGKEDUd7wblcCKaIiIy63LUrFtboZOg2ACKnQefPYwMHUY7spb8bPs7GVOz3r
-fkevACUsluNvHw4Y8C6YzlSaMypxKbKM4ZS/SNEHgRa0L9+GxsZ7H4GJtgpandsf
+gxyH464lxfWRDg1EUMfDPmHyzxxEgyP5yXxyLi3yi/1l6VX404oEvoDKBuFscn+w
-yNcjx2Idw34hlOBTuDW3Vbp+RN2DqTECggEAYKowYENmxNCiIyVTT8dhunMOoT1h
+/f0LejEwL7O0spUhdUvI0v3pQ8Hk2pe5AoIBAQDKVG3BQi3gbNIOT3wWGyMgaADT
-v9Qn5Rh9QlvcTN+ncnkc41VqO4yV/FbPM+q1cpUiBV4UZL4rQMTOOaqqL2B2p5Li
+5f97nmq/8a/BvylEYL17dUqS4sB+ARGbKehXr+WknBtNUKdvfnufN7jwNfb1TfDm
-urWNxTNq/eB7ZfODLqXVfMvRwPKdKxyIjmUZE3bI60imHEDOZ2qWQTYSdE+2zfHJ
+aVue2PF/Twicd81CKxAZkwlvYBUMoSNj+djVQuN5KMk8+0N0zedEiG0jxwhu61sN
-IGLuhvU6Exf9rWCIfijaARBgR3ySG7446mZdn9oOUFyqH14GduYwLmecS4EHdwkZ
+dLJg68c46MdxWcFtM2OJeNLDtM07eF7LcJ9yagdgDV1sROLsIf0NY08PDwMEt/1E
-urb+eIB04u6a48F9wg2Jgz/3BV/S3/8UA3pG1sjFdRHlIIozK4hM7mOe65zO3Tp3
+eV34Z7faYoO7tYOT4so45ldfLDENoyp7mnOyKYGEx8L0lxfwLIqltF959RS0K+dV
-nEho0UzzTj1VU00v7fWNQJBPWlst0Bk6gKInRQZxAYBmvsyiw4+Jt3516A==
+0g9MJCZimpjLiBGwSz4ZxTFGC8wmsX0upA/K8W7LUxYV6mmbCenvikJPBRQn
 -----END rsa private key-----

cryptor/rsa_public_example.pem

@@ -1,14 +1,14 @@
 -----BEGIN rsa public key-----
-MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxZGG6vSSETKwW7bxx7NA
+MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA66tu9qYNO0QeeeMaEJoh
-1tXmNh+0AAsOmdwOyd77C/F7bmf3iacdzsdJgumWpBZLpo7Xdke/6NWbzizdbawb
+WeBS7KdPQwVFt+5+kRhPST+xI6A8TtfccOtZM4Zc7BnSfTTQvcvF6HhOOn+PDYoi
-BKkLH5vdZpEYJsbIx9vQYPRrAL1taRHpWwqC86aZHhJ8afo5KARkW8U1BB+MCfJ0
+Vr/2dK4yZHm7wH35riqtvv0TYVNTdeKDmW3vZy8SR7Cpedl5a+BEc7D1PBqHMwFn
-oGOgkpHPbbs7jRNhrUP52BPbdRUw7ZwwJHEseuAvw+nv80UmHdI5mrgKj//8r+cB
+f/aJLY3AWp8VbHf0g1HcIL1xTXsFXFn283zUEHrg1XNmJlT0nLuKaBjIqGBqWZWI
-1JnErqJi0yTOgYwKqOPFcMoaCoyLRdMV8en1QZ7nY6KWF32K/OBGM8++lRsZGttF
+fCyOK5ZhhKP9vhRhY+u+/HQ1+CLw66qzAN6ZngR6Ra6B0bvx0D38Hy/FxLonDaut
-Thx3Zs54QU2GFgthH5rkMtucuZUXDN2k+QqV1XrSC/a+IDZ1zhx0+NUuExktOpOq
+ozd17C+zwQ6V5/PHLDRAqcZRvJUJ3E163gGEjBOTLU5T4FGxOaSBO4Dpw6J+wJRF
-kvc4IslIOPAcBJ4MoUWShOy91rW34QSV2ZgD6VMTYMce6xpH4Oh680I4ZtewZiRd
+uOyq3fB6M62R5x66U53p3GlWpNWsYkN3mk3JfI0+xsbi/Ry5jhdXOHANrks7eoo8
-BnQ4EADoxPbiBHfTQJfzUBtaZDXqOFNN+friCITTKice0dByDlCN85bL7et0hyIs
+SoAOEWidMZGRYpkiTkFgMHmjsrM5sUmsEpM+B93Kouij3CH3p9KAzfAz/I573pBz
-FU1xi0SmFbt3IBFwsJf5B/aorLhZqwCIUFvf7EahOH51PlGr7M2ltZtpgHmFBzB0
+3xuXDsbhlQIncRLOIFXP/VxU/IUsf81blhsWZ8ZQg1HyB7vWDyAR0BFuIKWDMlzn
-zYAoYOnDU1+avzVP5l9fObH4uLl8/fjeAr8pSB0drjaKf0Bj434aKrrftDyeGuMW
+M85kMoPpCpI1UUfOw1hLQwHRBuVIU8v+lgJhimHZtrDPEvOmXLTGBJLUePFEMI7l
-pXhFu9rr/eXXUVqU/jBfHR+60m+MBK9h8efkqtVW3EqNVApsapRFo/LNNDAC9lCK
+bL9XQTkMBXRgJ7hjxfYutUv6WpoyYP/vfUq7GN6X4JQzgCd1timJc/ljqTDbzT5N
-WuFBjh0igdZNjSuatG9O9rMCAwEAAQ==
+Gxk8mhjoAhZFpRciSyt5+6MCAwEAAQ==
 -----END rsa public key-----

docs/api/packages/convertor.md

@@ -47,6 +47,7 @@ import (
 -   [ToUrlBase64](#ToUrlBase64)
 -   [ToRawStdBase64](#ToRawStdBase64)
 -   [ToRawUrlBase64](#ToRawUrlBase64)
+-   [ToBigInt](#ToBigInt)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1148,4 +1149,34 @@ func main() {
     // dHJ1ZQ
     // ZXJy
 }
+```
+
+### <span id="ToBigInt">ToBigInt</span>
+
+<p>将整数值转换为bigInt。</p>
+
+<b>函数签名:<span style="float:right;display:inline-block;">[运行](todo)</span></b>
+
+```go
+func ToBigInt[T any](v T) (*big.Int, error)
+```
+
+<b>示例:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    n := 9876543210
+    bigInt, _ := convertor.ToBigInt(n)
+
+    fmt.Println(bigInt)
+    // Output:
+    // 9876543210
+}
 ```

docs/en/api/packages/convertor.md

@@ -47,6 +47,7 @@ import (
 -   [ToUrlBase64](#ToUrlBase64)
 -   [ToRawStdBase64](#ToRawStdBase64)
 -   [ToRawUrlBase64](#ToRawUrlBase64)
+-   [ToBigInt](#ToBigInt)
 
 <div STYLE="page-break-after: always;"></div>
 
@@ -1116,4 +1117,34 @@ func main() {
     // map[a:1 b:2] false
     // &{test 1 0.1 true <nil> } false
 }
+```
+
+### <span id="ToBigInt">ToBigInt</span>
+
+<p>Converts an integer of any supported type (int, int64, uint64, etc.) to *big.Int</p>
+
+<b>Signature:<span style="float:right;display:inline-block;">[Run](todo)</span></b>
+
+```go
+func ToBigInt[T any](v T) (*big.Int, error)
+```
+
+<b>Example:</b>
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/duke-git/lancet/v2/convertor"
+)
+
+func main() {
+    n := 9876543210
+    bigInt, _ := convertor.ToBigInt(n)
+
+    fmt.Println(bigInt)
+    // Output:
+    // 9876543210
+}
 ```