diff --git a/diffmatchpatch/diffmatchpatch.go b/diffmatchpatch/diffmatchpatch.go
index fd3da27..2ca8a48 100644
--- a/diffmatchpatch/diffmatchpatch.go
+++ b/diffmatchpatch/diffmatchpatch.go
@@ -11,105 +11,9 @@
 package diffmatchpatch
 
 import (
-	"strings"
 	"time"
-	"unicode/utf8"
 )
 
-// unescaper unescapes selected chars for compatibility with JavaScript's encodeURI.
-// In speed critical applications this could be dropped since the
-// receiving application will certainly decode these fine.
-// Note that this function is case-sensitive.  Thus "%3F" would not be
-// unescaped.  But this is ok because it is only called with the output of
-// HttpUtility.UrlEncode which returns lowercase hex.
-//
-// Example: "%3f" -> "?", "%24" -> "$", etc.
-var unescaper = strings.NewReplacer(
-	"%21", "!", "%7E", "~", "%27", "'",
-	"%28", "(", "%29", ")", "%3B", ";",
-	"%2F", "/", "%3F", "?", "%3A", ":",
-	"%40", "@", "%26", "&", "%3D", "=",
-	"%2B", "+", "%24", "$", "%2C", ",", "%23", "#", "%2A", "*")
-
-// indexOf returns the first index of pattern in str, starting at str[i].
-func indexOf(str string, pattern string, i int) int {
-	if i > len(str)-1 {
-		return -1
-	}
-	if i <= 0 {
-		return strings.Index(str, pattern)
-	}
-	ind := strings.Index(str[i:], pattern)
-	if ind == -1 {
-		return -1
-	}
-	return ind + i
-}
-
-// lastIndexOf returns the last index of pattern in str, starting at str[i].
-func lastIndexOf(str string, pattern string, i int) int {
-	if i < 0 {
-		return -1
-	}
-	if i >= len(str) {
-		return strings.LastIndex(str, pattern)
-	}
-	_, size := utf8.DecodeRuneInString(str[i:])
-	return strings.LastIndex(str[:i+size], pattern)
-}
-
-// Return the index of pattern in target, starting at target[i].
-func runesIndexOf(target, pattern []rune, i int) int {
-	if i > len(target)-1 {
-		return -1
-	}
-	if i <= 0 {
-		return runesIndex(target, pattern)
-	}
-	ind := runesIndex(target[i:], pattern)
-	if ind == -1 {
-		return -1
-	}
-	return ind + i
-}
-
-func min(x, y int) int {
-	if x < y {
-		return x
-	}
-	return y
-}
-
-func max(x, y int) int {
-	if x > y {
-		return x
-	}
-	return y
-}
-
-func runesEqual(r1, r2 []rune) bool {
-	if len(r1) != len(r2) {
-		return false
-	}
-	for i, c := range r1 {
-		if c != r2[i] {
-			return false
-		}
-	}
-	return true
-}
-
-// The equivalent of strings.Index for rune slices.
-func runesIndex(r1, r2 []rune) int {
-	last := len(r1) - len(r2)
-	for i := 0; i <= last; i++ {
-		if runesEqual(r1[i:i+len(r2)], r2) {
-			return i
-		}
-	}
-	return -1
-}
-
 // DiffMatchPatch holds the configuration for diff-match-patch operations.
 type DiffMatchPatch struct {
 	// Number of seconds to map a diff before giving up (0 for infinity).
diff --git a/diffmatchpatch/diffmatchpatch_test.go b/diffmatchpatch/diffmatchpatch_test.go
index 830e4bd..8bc5f88 100644
--- a/diffmatchpatch/diffmatchpatch_test.go
+++ b/diffmatchpatch/diffmatchpatch_test.go
@@ -7,110 +7,3 @@
 // http://code.google.com/p/google-diff-match-patch/
 
 package diffmatchpatch
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestRunesIndexOf(t *testing.T) {
-	type TestCase struct {
-		Pattern string
-		Start   int
-
-		Expected int
-	}
-
-	for i, tc := range []TestCase{
-		{"abc", 0, 0},
-		{"cde", 0, 2},
-		{"e", 0, 4},
-		{"cdef", 0, -1},
-		{"abcdef", 0, -1},
-		{"abc", 2, -1},
-		{"cde", 2, 2},
-		{"e", 2, 4},
-		{"cdef", 2, -1},
-		{"abcdef", 2, -1},
-		{"e", 6, -1},
-	} {
-		actual := runesIndexOf([]rune("abcde"), []rune(tc.Pattern), tc.Start)
-		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
-	}
-}
-
-func TestIndexOf(t *testing.T) {
-	type TestCase struct {
-		String   string
-		Pattern  string
-		Position int
-
-		Expected int
-	}
-
-	for i, tc := range []TestCase{
-		{"hi world", "world", -1, 3},
-		{"hi world", "world", 0, 3},
-		{"hi world", "world", 1, 3},
-		{"hi world", "world", 2, 3},
-		{"hi world", "world", 3, 3},
-		{"hi world", "world", 4, -1},
-		{"abbc", "b", -1, 1},
-		{"abbc", "b", 0, 1},
-		{"abbc", "b", 1, 1},
-		{"abbc", "b", 2, 2},
-		{"abbc", "b", 3, -1},
-		{"abbc", "b", 4, -1},
-		// The greek letter beta is the two-byte sequence of "\u03b2".
-		{"a\u03b2\u03b2c", "\u03b2", -1, 1},
-		{"a\u03b2\u03b2c", "\u03b2", 0, 1},
-		{"a\u03b2\u03b2c", "\u03b2", 1, 1},
-		{"a\u03b2\u03b2c", "\u03b2", 3, 3},
-		{"a\u03b2\u03b2c", "\u03b2", 5, -1},
-		{"a\u03b2\u03b2c", "\u03b2", 6, -1},
-	} {
-		actual := indexOf(tc.String, tc.Pattern, tc.Position)
-		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
-	}
-}
-
-func TestLastIndexOf(t *testing.T) {
-	type TestCase struct {
-		String   string
-		Pattern  string
-		Position int
-
-		Expected int
-	}
-
-	for i, tc := range []TestCase{
-		{"hi world", "world", -1, -1},
-		{"hi world", "world", 0, -1},
-		{"hi world", "world", 1, -1},
-		{"hi world", "world", 2, -1},
-		{"hi world", "world", 3, -1},
-		{"hi world", "world", 4, -1},
-		{"hi world", "world", 5, -1},
-		{"hi world", "world", 6, -1},
-		{"hi world", "world", 7, 3},
-		{"hi world", "world", 8, 3},
-		{"abbc", "b", -1, -1},
-		{"abbc", "b", 0, -1},
-		{"abbc", "b", 1, 1},
-		{"abbc", "b", 2, 2},
-		{"abbc", "b", 3, 2},
-		{"abbc", "b", 4, 2},
-		// The greek letter beta is the two-byte sequence of "\u03b2".
-		{"a\u03b2\u03b2c", "\u03b2", -1, -1},
-		{"a\u03b2\u03b2c", "\u03b2", 0, -1},
-		{"a\u03b2\u03b2c", "\u03b2", 1, 1},
-		{"a\u03b2\u03b2c", "\u03b2", 3, 3},
-		{"a\u03b2\u03b2c", "\u03b2", 5, 3},
-		{"a\u03b2\u03b2c", "\u03b2", 6, 3},
-	} {
-		actual := lastIndexOf(tc.String, tc.Pattern, tc.Position)
-		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
-	}
-}
diff --git a/diffmatchpatch/mathutil.go b/diffmatchpatch/mathutil.go
new file mode 100644
index 0000000..aed242b
--- /dev/null
+++ b/diffmatchpatch/mathutil.go
@@ -0,0 +1,23 @@
+// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
+// https://github.com/sergi/go-diff
+// See the included LICENSE file for license details.
+//
+// go-diff is a Go implementation of Google's Diff, Match, and Patch library
+// Original library is Copyright (c) 2006 Google Inc.
+// http://code.google.com/p/google-diff-match-patch/
+
+package diffmatchpatch
+
+func min(x, y int) int {
+	if x < y {
+		return x
+	}
+	return y
+}
+
+func max(x, y int) int {
+	if x > y {
+		return x
+	}
+	return y
+}
diff --git a/diffmatchpatch/stringutil.go b/diffmatchpatch/stringutil.go
new file mode 100644
index 0000000..ef2867c
--- /dev/null
+++ b/diffmatchpatch/stringutil.go
@@ -0,0 +1,94 @@
+// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
+// https://github.com/sergi/go-diff
+// See the included LICENSE file for license details.
+//
+// go-diff is a Go implementation of Google's Diff, Match, and Patch library
+// Original library is Copyright (c) 2006 Google Inc.
+// http://code.google.com/p/google-diff-match-patch/
+
+package diffmatchpatch
+
+import (
+	"strings"
+	"unicode/utf8"
+)
+
+// unescaper unescapes selected chars for compatibility with JavaScript's encodeURI.
+// In speed critical applications this could be dropped since the
+// receiving application will certainly decode these fine.
+// Note that this function is case-sensitive.  Thus "%3F" would not be
+// unescaped.  But this is ok because it is only called with the output of
+// HttpUtility.UrlEncode which returns lowercase hex.
+//
+// Example: "%3f" -> "?", "%24" -> "$", etc.
+var unescaper = strings.NewReplacer(
+	"%21", "!", "%7E", "~", "%27", "'",
+	"%28", "(", "%29", ")", "%3B", ";",
+	"%2F", "/", "%3F", "?", "%3A", ":",
+	"%40", "@", "%26", "&", "%3D", "=",
+	"%2B", "+", "%24", "$", "%2C", ",", "%23", "#", "%2A", "*")
+
+// indexOf returns the first index of pattern in str, starting at str[i].
+func indexOf(str string, pattern string, i int) int {
+	if i > len(str)-1 {
+		return -1
+	}
+	if i <= 0 {
+		return strings.Index(str, pattern)
+	}
+	ind := strings.Index(str[i:], pattern)
+	if ind == -1 {
+		return -1
+	}
+	return ind + i
+}
+
+// lastIndexOf returns the last index of pattern in str, starting at str[i].
+func lastIndexOf(str string, pattern string, i int) int {
+	if i < 0 {
+		return -1
+	}
+	if i >= len(str) {
+		return strings.LastIndex(str, pattern)
+	}
+	_, size := utf8.DecodeRuneInString(str[i:])
+	return strings.LastIndex(str[:i+size], pattern)
+}
+
+// Return the index of pattern in target, starting at target[i].
+func runesIndexOf(target, pattern []rune, i int) int {
+	if i > len(target)-1 {
+		return -1
+	}
+	if i <= 0 {
+		return runesIndex(target, pattern)
+	}
+	ind := runesIndex(target[i:], pattern)
+	if ind == -1 {
+		return -1
+	}
+	return ind + i
+}
+
+func runesEqual(r1, r2 []rune) bool {
+	if len(r1) != len(r2) {
+		return false
+	}
+	for i, c := range r1 {
+		if c != r2[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// The equivalent of strings.Index for rune slices.
+func runesIndex(r1, r2 []rune) int {
+	last := len(r1) - len(r2)
+	for i := 0; i <= last; i++ {
+		if runesEqual(r1[i:i+len(r2)], r2) {
+			return i
+		}
+	}
+	return -1
+}
diff --git a/diffmatchpatch/stringutil_test.go b/diffmatchpatch/stringutil_test.go
new file mode 100644
index 0000000..ab2bc10
--- /dev/null
+++ b/diffmatchpatch/stringutil_test.go
@@ -0,0 +1,116 @@
+// Copyright (c) 2012-2016 The go-diff authors. All rights reserved.
+// https://github.com/sergi/go-diff
+// See the included LICENSE file for license details.
+//
+// go-diff is a Go implementation of Google's Diff, Match, and Patch library
+// Original library is Copyright (c) 2006 Google Inc.
+// http://code.google.com/p/google-diff-match-patch/
+
+package diffmatchpatch
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRunesIndexOf(t *testing.T) {
+	type TestCase struct {
+		Pattern string
+		Start   int
+
+		Expected int
+	}
+
+	for i, tc := range []TestCase{
+		{"abc", 0, 0},
+		{"cde", 0, 2},
+		{"e", 0, 4},
+		{"cdef", 0, -1},
+		{"abcdef", 0, -1},
+		{"abc", 2, -1},
+		{"cde", 2, 2},
+		{"e", 2, 4},
+		{"cdef", 2, -1},
+		{"abcdef", 2, -1},
+		{"e", 6, -1},
+	} {
+		actual := runesIndexOf([]rune("abcde"), []rune(tc.Pattern), tc.Start)
+		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+	}
+}
+
+func TestIndexOf(t *testing.T) {
+	type TestCase struct {
+		String   string
+		Pattern  string
+		Position int
+
+		Expected int
+	}
+
+	for i, tc := range []TestCase{
+		{"hi world", "world", -1, 3},
+		{"hi world", "world", 0, 3},
+		{"hi world", "world", 1, 3},
+		{"hi world", "world", 2, 3},
+		{"hi world", "world", 3, 3},
+		{"hi world", "world", 4, -1},
+		{"abbc", "b", -1, 1},
+		{"abbc", "b", 0, 1},
+		{"abbc", "b", 1, 1},
+		{"abbc", "b", 2, 2},
+		{"abbc", "b", 3, -1},
+		{"abbc", "b", 4, -1},
+		// The greek letter beta is the two-byte sequence of "\u03b2".
+		{"a\u03b2\u03b2c", "\u03b2", -1, 1},
+		{"a\u03b2\u03b2c", "\u03b2", 0, 1},
+		{"a\u03b2\u03b2c", "\u03b2", 1, 1},
+		{"a\u03b2\u03b2c", "\u03b2", 3, 3},
+		{"a\u03b2\u03b2c", "\u03b2", 5, -1},
+		{"a\u03b2\u03b2c", "\u03b2", 6, -1},
+	} {
+		actual := indexOf(tc.String, tc.Pattern, tc.Position)
+		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+	}
+}
+
+func TestLastIndexOf(t *testing.T) {
+	type TestCase struct {
+		String   string
+		Pattern  string
+		Position int
+
+		Expected int
+	}
+
+	for i, tc := range []TestCase{
+		{"hi world", "world", -1, -1},
+		{"hi world", "world", 0, -1},
+		{"hi world", "world", 1, -1},
+		{"hi world", "world", 2, -1},
+		{"hi world", "world", 3, -1},
+		{"hi world", "world", 4, -1},
+		{"hi world", "world", 5, -1},
+		{"hi world", "world", 6, -1},
+		{"hi world", "world", 7, 3},
+		{"hi world", "world", 8, 3},
+		{"abbc", "b", -1, -1},
+		{"abbc", "b", 0, -1},
+		{"abbc", "b", 1, 1},
+		{"abbc", "b", 2, 2},
+		{"abbc", "b", 3, 2},
+		{"abbc", "b", 4, 2},
+		// The greek letter beta is the two-byte sequence of "\u03b2".
+		{"a\u03b2\u03b2c", "\u03b2", -1, -1},
+		{"a\u03b2\u03b2c", "\u03b2", 0, -1},
+		{"a\u03b2\u03b2c", "\u03b2", 1, 1},
+		{"a\u03b2\u03b2c", "\u03b2", 3, 3},
+		{"a\u03b2\u03b2c", "\u03b2", 5, 3},
+		{"a\u03b2\u03b2c", "\u03b2", 6, 3},
+	} {
+		actual := lastIndexOf(tc.String, tc.Pattern, tc.Position)
+		assert.Equal(t, tc.Expected, actual, fmt.Sprintf("Test case #%d, %#v", i, tc))
+	}
+}