diff --git a/copystructure.go b/copystructure.go
new file mode 100644
index 0000000..9506044
--- /dev/null
+++ b/copystructure.go
@@ -0,0 +1,103 @@
+package sprig
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// deepcopy performs a deep copy of the given interface{}.
+func deepcopy(src interface{}) (interface{}, error) {
+	if src == nil {
+		return make(map[string]interface{}), nil
+	}
+	return copyValue(reflect.ValueOf(src))
+}
+
+// copyValue handles copying using reflection for non-map types
+func copyValue(original reflect.Value) (interface{}, error) {
+	switch original.Kind() {
+	case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32,
+		reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32,
+		reflect.Uint64, reflect.Uintptr, reflect.Float32, reflect.Float64,
+		reflect.Complex64, reflect.Complex128, reflect.String, reflect.Array:
+		return original.Interface(), nil
+
+	case reflect.Interface:
+		if original.IsNil() {
+			return original.Interface(), nil
+		}
+		return copyValue(original.Elem())
+
+	case reflect.Map:
+		if original.IsNil() {
+			return original.Interface(), nil
+		}
+		copied := reflect.MakeMap(original.Type())
+
+		var err error
+		var child interface{}
+		iter := original.MapRange()
+		for iter.Next() {
+			key := iter.Key()
+			value := iter.Value()
+
+			if value.Kind() == reflect.Interface && value.IsNil() {
+				copied.SetMapIndex(key, value)
+				continue
+			}
+
+			child, err = copyValue(value)
+			if err != nil {
+				return nil, err
+			}
+			copied.SetMapIndex(key, reflect.ValueOf(child))
+		}
+		return copied.Interface(), nil
+
+	case reflect.Pointer:
+		if original.IsNil() {
+			return original.Interface(), nil
+		}
+		copied, err := copyValue(original.Elem())
+		if err != nil {
+			return nil, err
+		}
+		ptr := reflect.New(original.Type().Elem())
+		ptr.Elem().Set(reflect.ValueOf(copied))
+		return ptr.Interface(), nil
+
+	case reflect.Slice:
+		if original.IsNil() {
+			return original.Interface(), nil
+		}
+		copied := reflect.MakeSlice(original.Type(), original.Len(), original.Cap())
+		for i := 0; i < original.Len(); i++ {
+			val, err := copyValue(original.Index(i))
+			if err != nil {
+				return nil, err
+			}
+			copied.Index(i).Set(reflect.ValueOf(val))
+		}
+		return copied.Interface(), nil
+
+	case reflect.Struct:
+		copied := reflect.New(original.Type()).Elem()
+		for i := 0; i < original.NumField(); i++ {
+			elem, err := copyValue(original.Field(i))
+			if err != nil {
+				return nil, err
+			}
+			copied.Field(i).Set(reflect.ValueOf(elem))
+		}
+		return copied.Interface(), nil
+
+	case reflect.Func, reflect.Chan, reflect.UnsafePointer:
+		if original.IsNil() {
+			return original.Interface(), nil
+		}
+		return original.Interface(), nil
+
+	default:
+		return original.Interface(), fmt.Errorf("unsupported type %v", original)
+	}
+}
diff --git a/copystructure_test.go b/copystructure_test.go
new file mode 100644
index 0000000..7684726
--- /dev/null
+++ b/copystructure_test.go
@@ -0,0 +1,358 @@
+package sprig
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestCopy_Nil(t *testing.T) {
+	result, err := deepcopy(nil)
+	require.NoError(t, err)
+	assert.Equal(t, map[string]interface{}{}, result)
+}
+
+func TestCopy_PrimitiveTypes(t *testing.T) {
+	tests := []struct {
+		name  string
+		input interface{}
+	}{
+		{"bool", true},
+		{"int", 42},
+		{"int8", int8(8)},
+		{"int16", int16(16)},
+		{"int32", int32(32)},
+		{"int64", int64(64)},
+		{"uint", uint(42)},
+		{"uint8", uint8(8)},
+		{"uint16", uint16(16)},
+		{"uint32", uint32(32)},
+		{"uint64", uint64(64)},
+		{"float32", float32(3.14)},
+		{"float64", 3.14159},
+		{"complex64", complex64(1 + 2i)},
+		{"complex128", 1 + 2i},
+		{"string", "hello world"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := deepcopy(tt.input)
+			require.NoError(t, err)
+			assert.Equal(t, tt.input, result)
+		})
+	}
+}
+
+func TestCopy_Array(t *testing.T) {
+	input := [3]int{1, 2, 3}
+	result, err := deepcopy(input)
+	require.NoError(t, err)
+	assert.Equal(t, input, result)
+}
+
+func TestCopy_Slice(t *testing.T) {
+	t.Run("slice of ints", func(t *testing.T) {
+		input := []int{1, 2, 3, 4, 5}
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultSlice, ok := result.([]int)
+		require.True(t, ok)
+		assert.Equal(t, input, resultSlice)
+
+		// Verify it's a deep copy by modifying original
+		input[0] = 999
+		assert.Equal(t, 1, resultSlice[0])
+	})
+
+	t.Run("slice of strings", func(t *testing.T) {
+		input := []string{"a", "b", "c"}
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Equal(t, input, result)
+	})
+
+	t.Run("nil slice", func(t *testing.T) {
+		var input []int
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("slice of maps", func(t *testing.T) {
+		input := []map[string]interface{}{
+			{"key1": "value1"},
+			{"key2": "value2"},
+		}
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultSlice, ok := result.([]map[string]interface{})
+		require.True(t, ok)
+		assert.Equal(t, input, resultSlice)
+
+		// Verify deep copy
+		input[0]["key1"] = "modified"
+		assert.Equal(t, "value1", resultSlice[0]["key1"])
+	})
+}
+
+func TestCopy_Map(t *testing.T) {
+	t.Run("map[string]interface{}", func(t *testing.T) {
+		input := map[string]interface{}{
+			"string": "value",
+			"int":    42,
+			"bool":   true,
+			"nested": map[string]interface{}{
+				"inner": "value",
+			},
+		}
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultMap, ok := result.(map[string]interface{})
+		require.True(t, ok)
+		assert.Equal(t, input, resultMap)
+
+		// Verify deep copy
+		input["string"] = "modified"
+		assert.Equal(t, "value", resultMap["string"])
+
+		nestedInput := input["nested"].(map[string]interface{})
+		nestedResult := resultMap["nested"].(map[string]interface{})
+		nestedInput["inner"] = "modified"
+		assert.Equal(t, "value", nestedResult["inner"])
+	})
+
+	t.Run("map[string]string", func(t *testing.T) {
+		input := map[string]string{
+			"key1": "value1",
+			"key2": "value2",
+		}
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Equal(t, input, result)
+	})
+
+	t.Run("nil map", func(t *testing.T) {
+		var input map[string]interface{}
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+
+	t.Run("map with nil values", func(t *testing.T) {
+		input := map[string]interface{}{
+			"key1": "value1",
+			"key2": nil,
+		}
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultMap, ok := result.(map[string]interface{})
+		require.True(t, ok)
+		assert.Equal(t, input, resultMap)
+		assert.Nil(t, resultMap["key2"])
+	})
+}
+
+func TestCopy_Struct(t *testing.T) {
+	type TestStruct struct {
+		Name     string
+		Age      int
+		Active   bool
+		Scores   []int
+		Metadata map[string]interface{}
+	}
+
+	input := TestStruct{
+		Name:   "John",
+		Age:    30,
+		Active: true,
+		Scores: []int{95, 87, 92},
+		Metadata: map[string]interface{}{
+			"level": "advanced",
+			"tags":  []string{"go", "programming"},
+		},
+	}
+
+	result, err := deepcopy(input)
+	require.NoError(t, err)
+
+	resultStruct, ok := result.(TestStruct)
+	require.True(t, ok)
+	assert.Equal(t, input, resultStruct)
+
+	// Verify deep copy
+	input.Name = "Modified"
+	input.Scores[0] = 999
+	assert.Equal(t, "John", resultStruct.Name)
+	assert.Equal(t, 95, resultStruct.Scores[0])
+}
+
+func TestCopy_Pointer(t *testing.T) {
+	t.Run("pointer to int", func(t *testing.T) {
+		value := 42
+		input := &value
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultPtr, ok := result.(*int)
+		require.True(t, ok)
+		assert.Equal(t, *input, *resultPtr)
+
+		// Verify they point to different memory locations
+		assert.NotSame(t, input, resultPtr)
+
+		// Verify deep copy
+		*input = 999
+		assert.Equal(t, 42, *resultPtr)
+	})
+
+	t.Run("pointer to struct", func(t *testing.T) {
+		type Person struct {
+			Name string
+			Age  int
+		}
+
+		input := &Person{Name: "Alice", Age: 25}
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		resultPtr, ok := result.(*Person)
+		require.True(t, ok)
+		assert.Equal(t, *input, *resultPtr)
+		assert.NotSame(t, input, resultPtr)
+	})
+
+	t.Run("nil pointer", func(t *testing.T) {
+		var input *int
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+}
+
+func TestCopy_Interface(t *testing.T) {
+	t.Run("interface{} with value", func(t *testing.T) {
+		var input interface{} = "hello"
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Equal(t, input, result)
+	})
+
+	t.Run("nil interface{}", func(t *testing.T) {
+		var input interface{}
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		// deepcopy(nil) returns an empty map according to the implementation
+		assert.Equal(t, map[string]interface{}{}, result)
+	})
+
+	t.Run("interface{} with complex value", func(t *testing.T) {
+		var input interface{} = map[string]interface{}{
+			"key": "value",
+			"nested": map[string]interface{}{
+				"inner": 42,
+			},
+		}
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Equal(t, input, result)
+	})
+}
+
+func TestCopy_ComplexNested(t *testing.T) {
+	input := map[string]interface{}{
+		"users": []map[string]interface{}{
+			{
+				"name": "Alice",
+				"age":  30,
+				"addresses": []map[string]interface{}{
+					{"type": "home", "city": "NYC"},
+					{"type": "work", "city": "SF"},
+				},
+			},
+			{
+				"name": "Bob",
+				"age":  25,
+				"addresses": []map[string]interface{}{
+					{"type": "home", "city": "LA"},
+				},
+			},
+		},
+		"metadata": map[string]interface{}{
+			"version": "1.0",
+			"flags":   []bool{true, false, true},
+		},
+	}
+
+	result, err := deepcopy(input)
+	require.NoError(t, err)
+
+	resultMap, ok := result.(map[string]interface{})
+	require.True(t, ok)
+	assert.Equal(t, input, resultMap)
+
+	// Verify deep copy by modifying nested values
+	users := input["users"].([]map[string]interface{})
+	addresses := users[0]["addresses"].([]map[string]interface{})
+	addresses[0]["city"] = "Modified"
+
+	resultUsers := resultMap["users"].([]map[string]interface{})
+	resultAddresses := resultUsers[0]["addresses"].([]map[string]interface{})
+	assert.Equal(t, "NYC", resultAddresses[0]["city"])
+}
+
+func TestCopy_Functions(t *testing.T) {
+	t.Run("function", func(t *testing.T) {
+		input := func() string { return "hello" }
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		// Functions should be copied as-is (same reference)
+		resultFunc, ok := result.(func() string)
+		require.True(t, ok)
+		assert.Equal(t, input(), resultFunc())
+	})
+
+	t.Run("nil function", func(t *testing.T) {
+		var input func()
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+}
+
+func TestCopy_Channels(t *testing.T) {
+	t.Run("channel", func(t *testing.T) {
+		input := make(chan int, 1)
+		input <- 42
+
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+
+		// Channels should be copied as-is (same reference)
+		resultChan, ok := result.(chan int)
+		require.True(t, ok)
+
+		// Since channels are copied as references, verify we can read from the result channel
+		value := <-resultChan
+		assert.Equal(t, 42, value)
+	})
+
+	t.Run("nil channel", func(t *testing.T) {
+		var input chan int
+		result, err := deepcopy(input)
+		require.NoError(t, err)
+		assert.Nil(t, result)
+	})
+}
diff --git a/dict.go b/dict.go
index 4315b35..caa61b6 100644
--- a/dict.go
+++ b/dict.go
@@ -2,7 +2,6 @@ package sprig
 
 import (
 	"dario.cat/mergo"
-	"github.com/mitchellh/copystructure"
 )
 
 func get(d map[string]interface{}, key string) interface{} {
@@ -144,7 +143,7 @@ func deepCopy(i interface{}) interface{} {
 }
 
 func mustDeepCopy(i interface{}) (interface{}, error) {
-	return copystructure.Copy(i)
+	return deepcopy(i)
 }
 
 func dig(ps ...interface{}) (interface{}, error) {
diff --git a/go.mod b/go.mod
index 2fdb8b8..5e4d1e1 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,6 @@ require (
 	github.com/Masterminds/semver/v3 v3.4.0
 	github.com/google/uuid v1.6.0
 	github.com/huandu/xstrings v1.5.0
-	github.com/mitchellh/copystructure v1.2.0
 	github.com/shopspring/decimal v1.4.0
 	github.com/spf13/cast v1.9.2
 	github.com/stretchr/testify v1.10.0
@@ -20,8 +19,6 @@ require (
 require (
 	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
-	github.com/mitchellh/reflectwalk v1.0.2 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )
diff --git a/go.sum b/go.sum
index 9333cec..6163dde 100644
--- a/go.sum
+++ b/go.sum
@@ -1,14 +1,9 @@
-dario.cat/mergo v1.0.1 h1:Ra4+bf83h2ztPIQYNP99R6m+Y7KfnARDfID+a+vLl4s=
-dario.cat/mergo v1.0.1/go.mod h1:uNxQE+84aUszobStD9th8a29P2fMDhsBdgRYvZOxGmk=
 dario.cat/mergo v1.0.2 h1:85+piFYR1tMbRrLcDwR18y4UKJ3aH1Tbzi24VRW1TK8=
 dario.cat/mergo v1.0.2/go.mod h1:E/hbnu0NxMFBjpMIE34DRGLWqDy0g5FuKDhCb31ngxA=
 github.com/Masterminds/goutils v1.1.1 h1:5nUrii3FMTL5diU80unEVvNevw1nH4+ZV4DSLVJLSYI=
 github.com/Masterminds/goutils v1.1.1/go.mod h1:8cTjp+g8YejhMuvIA5y2vz3BpJxksy863GQaJW2MFNU=
-github.com/Masterminds/semver/v3 v3.3.0 h1:B8LGeaivUe71a5qox1ICM/JLl0NqZSW5CHyL+hmvYS0=
-github.com/Masterminds/semver/v3 v3.3.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
 github.com/Masterminds/semver/v3 v3.4.0 h1:Zog+i5UMtVoCU8oKka5P7i9q9HgrJeGzI9SA1Xbatp0=
 github.com/Masterminds/semver/v3 v3.4.0/go.mod h1:4V+yj/TJE1HU9XfppCwVMZq3I84lprf4nC11bSS5beM=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/frankban/quicktest v1.14.6 h1:7Xjx+VpznH+oBnejlPUj8oUpdxnVs4f8XU8WnHkI4W8=
@@ -33,25 +28,13 @@ github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZV
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
 github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
 github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
-github.com/spf13/cast v1.7.0 h1:ntdiHjuueXFgm5nzDRdOS4yfT43P5Fnud6DH50rz/7w=
-github.com/spf13/cast v1.7.0/go.mod h1:ancEpBxwJDODSW/UG4rDrAqiKolqNNh2DX3mk86cAdo=
 github.com/spf13/cast v1.9.2 h1:SsGfm7M8QOFtEzumm7UZrZdLLquNdzFYfIbEXntcFbE=
 github.com/spf13/cast v1.9.2/go.mod h1:jNfB8QC9IA6ZuY2ZjDp0KtFO2LZZlg4S/7bzP6qqeHo=
-github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
-github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
-github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
 github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
 github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
-golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
 golang.org/x/crypto v0.40.0 h1:r4x+VvoG5Fm+eJcxMaY8CQM7Lb0l1lsmjGBQ6s8BfKM=
 golang.org/x/crypto v0.40.0/go.mod h1:Qr1vMER5WyS2dfPHAlsOj01wgLbsyWtFn/aY+5+ZdxY=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
-gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
-gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
-gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=