diff --git a/Rest.Net.Tests/ServeFileTests.cs b/Rest.Net.Tests/ServeFileTests.cs
new file mode 100644
index 0000000..77478fa
--- /dev/null
+++ b/Rest.Net.Tests/ServeFileTests.cs
@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using FluentAssertions;
+using MontoyaTech.Rest.Net;
+using Xunit;
+
+namespace Rest.Net.Tests
+{
+    public class ServeFileTests
+    {
+        public string BaseDirectory = null;
+
+        public string TestDirectory = null;
+
+        public string TestFile = null;
+
+        public ServeFileTests()
+        {
+            this.BaseDirectory = Path.Combine(Environment.CurrentDirectory, "test");
+
+            if (!Directory.Exists(this.BaseDirectory))
+                Directory.CreateDirectory(this.BaseDirectory);
+
+            this.TestDirectory = Path.Combine(this.BaseDirectory, "test2");
+
+            if (!Directory.Exists(this.TestDirectory))
+                Directory.CreateDirectory(this.TestDirectory);
+
+            this.TestFile = Path.Combine(this.BaseDirectory, "test.html");
+
+            if (!File.Exists(this.TestFile))
+                File.WriteAllText(this.TestFile, "hello world");
+        }
+
+        [Fact]
+        public void ServeMultiple_File_ShouldWork()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(this.BaseDirectory, "/test.html", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeFalse();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestFile);
+        }
+
+        [Fact]
+        public void ServeMultiple_Directory_ShouldWork()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(this.BaseDirectory, "/test2", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeTrue();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestDirectory);
+        }
+
+        [Fact]
+        public void ServeMultiple_NavigatingUp_Should_NotWork()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(this.BaseDirectory, "../test.html", null, out string resolvedPath, out bool isDirectory).Should().BeFalse();
+        }
+
+        [Fact]
+        public void ServeMultiple_Correct_NavigatingUp_Should_Work()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(this.BaseDirectory, "a/b/../../test.html", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeFalse();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestFile);
+        }
+
+        [Fact]
+        public void ServeMultiple_NavigatingUp_Multiple_Should_NotWork()
+        {
+            HttpListenerResponseExtensions.ResolveMultiPagePath(this.BaseDirectory, "test/../../test.html", null, out string resolvedPath, out bool isDirectory).Should().BeFalse();
+        }
+
+        [Fact]
+        public void ServeSingle_File_ShouldWork()
+        {
+            HttpListenerResponseExtensions.ResolveSinglePagePath(this.BaseDirectory, "/test.html", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeFalse();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestFile);
+        }
+
+        [Fact]
+        public void ServeSingle_Directory_ShouldWork()
+        {
+            HttpListenerResponseExtensions.ResolveSinglePagePath(this.BaseDirectory, "/test2", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeTrue();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestDirectory);
+        }
+
+        [Fact]
+        public void ServeSingle_File_Route_ShouldWork()
+        {
+            HttpListenerResponseExtensions.ResolveSinglePagePath(this.BaseDirectory, "/a/b/test.html", null, out string resolvedPath, out bool isDirectory).Should().BeTrue();
+
+            isDirectory.Should().BeFalse();
+
+            resolvedPath.Should().BeEquivalentTo(this.TestFile);
+        }
+    }
+}
diff --git a/Rest.Net/HttpListenerResponseExtensions.cs b/Rest.Net/HttpListenerResponseExtensions.cs
index 56a5bca..bbff058 100644
--- a/Rest.Net/HttpListenerResponseExtensions.cs
+++ b/Rest.Net/HttpListenerResponseExtensions.cs
@@ -501,21 +501,248 @@ namespace MontoyaTech.Rest.Net
         /// <summary>
         /// Sets the response to serve a file in the context of a multi page application.
         /// </summary>
-        /// <param name="response"></param>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, HttpListenerRequest request)
+        /// <param name="response">The response to modify</param>
+        /// <param name="basePath">The base path where to serve files from</param>
+        /// <param name="request">The request to serve</param>
+        /// <param name="indexFile">The name of the index file, default is index.html</param>
+        /// <param name="compress">Whether or not to compress files served. Default is false.</param>
+        /// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
+        /// <returns>The modified response</returns>
+        public static HttpListenerResponse ServeMultiPage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
         {
+            if (ResolveMultiPagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
+            {
+                if (isDirectory)
+                {
+                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                }
+                else
+                {
+                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                    }
+                    else
+                    {
+                        if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
+                            return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
+                        else
+                            return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
+                    }
+                }
+            }
+            else
+            {
+                return response.WithStatus(HttpStatusCode.NotFound);
+            }
+        }
+
+        internal static bool ResolveMultiPagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
+        {
+            resolvedPath = null;
+
+            isDirectory = false;
+
+            //If the requestPath is pointing to nothing change that to the index file.
+            if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
+                requestPath = indexFile;
+
+            //Break th erequest path into it's components so we can enfore staying in the base path.
+            var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
+
+            for (int i = 0; i < components.Count; i++)
+            {
+                if (components[i].Trim() == "..")
+                {
+                    components.RemoveAt(i--);
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+                }
+                else if (components[i].Trim() == "...")
+                {
+                    components.RemoveAt(i--);
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+                }
+                else if (components[i].Trim() == ".")
+                {
+                    components.RemoveAt(i--);
+                }
+            }
+
+            if (components.Count == 0)
+                return false;
+
+            var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));
+
+            if (File.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                return true;
+            }
+            else if (Directory.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                isDirectory = true;
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }
         }
 
         /// <summary>
         /// Sets the response to serve a file in the context of a single page application.
         /// </summary>
-        /// <param name="response"></param>
-        /// <param name="request"></param>
-        /// <returns></returns>
-        public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, HttpListenerRequest request)
+        /// <param name="response">The response to modify</param>
+        /// <param name="basePath">The base path where to serve files from</param>
+        /// <param name="request">The request to serve</param>
+        /// <param name="indexFile">The name of the index file, default is index.html</param>
+        /// <param name="compress">Whether or not to compress files served. Default is false.</param>
+        /// <param name="compressExtensions">A collection of file extensions that should be compressed, example: .jpg, default is null. If and compress is true, all files will be compressed.</param>
+        /// <returns>The modified response</returns>
+        public static HttpListenerResponse ServeSinglePage(this HttpListenerResponse response, string basePath, HttpListenerRequest request, string indexFile = "index.html", bool compress = false, HashSet<string> compressExtensions = null)
         {
+            if (ResolveSinglePagePath(basePath, request.Url.LocalPath, indexFile, out string resolvedPath, out bool isDirectory))
+            {
+                if (isDirectory)
+                {
+                    return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                }
+                else
+                {
+                    if (request.HttpMethod.Equals("head", StringComparison.CurrentCultureIgnoreCase))
+                    {
+                        return response.WithNoBody().WithStatus(HttpStatusCode.NoContent);
+                    }
+                    else
+                    {
+                        if (compress && (compressExtensions == null || compressExtensions.Contains(Path.GetExtension(resolvedPath))))
+                            return response.WithStatus(HttpStatusCode.OK).WithCompressedFile(resolvedPath);
+                        else
+                            return response.WithStatus(HttpStatusCode.OK).WithFile(resolvedPath);
+                    }
+                }
+            }
+            else
+            {
+                return response.WithStatus(HttpStatusCode.NotFound);
+            }
+        }
+
+        internal static bool ResolveSinglePagePath(string basePath, string requestPath, string indexFile, out string resolvedPath, out bool isDirectory)
+        {
+            resolvedPath = null;
+
+            isDirectory = false;
+
+            //If the requestPath is pointing to nothing change that to the index file.
+            if (string.IsNullOrWhiteSpace(requestPath) || requestPath == "/" || requestPath == ".")
+                requestPath = indexFile;
+
+            //Break th erequest path into it's components so we can enfore staying in the base path.
+            var components = requestPath.Split(new char[] { '/', '\\' }, StringSplitOptions.RemoveEmptyEntries).ToList();
+
+            for (int i = 0; i < components.Count; i++)
+            {
+                if (components[i].Trim() == "..")
+                {
+                    components.RemoveAt(i--);
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+                }
+                else if (components[i].Trim() == "...")
+                {
+                    components.RemoveAt(i--);
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+
+                    if (i >= 0)
+                        components.RemoveAt(i--);
+                    else
+                        return false; //Trying to jump outside of basePath
+                }
+                else if (components[i].Trim() == ".")
+                {
+                    components.RemoveAt(i--);
+                }
+            }
+
+            if (components.Count == 0)
+                return false;
+
+            var absolutePath = Path.Combine(basePath, components.Separate(Path.DirectorySeparatorChar));
+
+            if (File.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                return true;
+            }
+            else if (Directory.Exists(absolutePath))
+            {
+                resolvedPath = absolutePath;
+
+                isDirectory = true;
+
+                return true;
+            }
+            else
+            {
+                //Try to components that don't exist and try again
+                while (components.Count > 0)
+                {
+                    string path = Path.Combine(basePath, components[0]);
+
+                    if (File.Exists(path) || Directory.Exists(path))
+                        break;
+                    else
+                        components.RemoveAt(0);
+                }
+
+                if (components.Count == 0)
+                    return false;
+
+                absolutePath = Path.Combine(basePath, components.Separate(Path.PathSeparator));
+
+                if (File.Exists(absolutePath))
+                {
+                    resolvedPath = absolutePath;
+
+                    return true;
+                }
+                else if (Directory.Exists(absolutePath))
+                {
+                    resolvedPath = absolutePath;
+
+                    isDirectory = true;
+
+                    return true;
+                }
+
+                return false;
+            }
         }
     }
 }
diff --git a/Rest.Net/Rest.Net.csproj b/Rest.Net/Rest.Net.csproj
index 31923dd..a77cf3b 100644
--- a/Rest.Net/Rest.Net.csproj
+++ b/Rest.Net/Rest.Net.csproj
@@ -17,7 +17,7 @@
     <AssemblyName>MontoyaTech.Rest.Net</AssemblyName>
     <RootNamespace>MontoyaTech.Rest.Net</RootNamespace>
     <GenerateDocumentationFile>True</GenerateDocumentationFile>
-    <Version>1.6.2</Version>
+    <Version>1.6.3</Version>
     <PackageReleaseNotes></PackageReleaseNotes>
     <PackageIcon>Logo_Symbol_Black_Outline.png</PackageIcon>
   </PropertyGroup>
diff --git a/Rest.Net/StringExtensions.cs b/Rest.Net/StringExtensions.cs
index d3bcbd0..c51e144 100644
--- a/Rest.Net/StringExtensions.cs
+++ b/Rest.Net/StringExtensions.cs
@@ -18,5 +18,39 @@ namespace MontoyaTech.Rest.Net
 
             return count;
         }
+
+        public static string Separate(this IList<string> input, char separator)
+        {
+            if (input == null || input.Count == 0)
+                return "";
+            else if (input.Count < 2)
+                return input[0];
+
+            var builder = new StringBuilder();
+
+            builder.Append(input[0]);
+
+            for (int i = 1; i < input.Count; i++)
+                builder.Append(separator).Append(input[1]);
+
+            return builder.ToString();
+        }
+
+        public static string Separate(this IList<string> input, string separator)
+        {
+            if (input == null || input.Count == 0)
+                return "";
+            else if (input.Count < 2)
+                return input[0];
+
+            var builder = new StringBuilder();
+
+            builder.Append(input[0]);
+
+            for (int i = 1; i < input.Count; i++)
+                builder.Append(separator).Append(input[1]);
+
+            return builder.ToString();
+        }
     }
 }