flag to disable encoding of regex matches in 'rewrites' and 'redirects'

primary use case:
* regex pattern matches a subset of the URL pathname
  example (configs):
    - source:
        '/foo/:bar*'
    - destination:
        '/:bar'
    - purpose:
      * 'rewrites' rule would be used to silently ignore
        the leading 'foo/' directory in path
      * 'redirects' rule would be used to trigger a 301 redirect
        to a new URL that removes
        the leading 'foo/' directory in path
  example (behavior):
    - request URL path:
        '/foo/a/b/c/d/e/f.txt'
    - :bar interpolates to value (before encoding):
        'a/b/c/d/e/f.txt'
    - :bar interpolates to value (after default encoding):
        encodeURIComponent('a/b/c/d/e/f.txt') === 'a%2Fb%2Fc%2Fd%2Fe%2Ff.txt'
* if the corresponding 'rewrites' or 'redirects' rule includes the flag:
    {"raw": true}
  then the raw value will be returned without any encoding

based on:
* upstream PR 85
    vercel/serve-handler#85

references:
* pathToRegExp.compile(data, options)
    https://github.com/pillarjs/path-to-regexp#compile-reverse-path-to-regexp

road blocks:
* pathToRegExp bug
    pillarjs/path-to-regexp#260
    pillarjs/path-to-regexp#261
  status:
  - the desired behavior will remain broken until this PR is merged
  - 'source' patterns that match one or more '/' characters
    cause the library to throw an Error for a failed assertion

Author: warren-bank

lib/serve-handler/README.md

@@ -130,7 +130,7 @@ You can also use so-called "routing segments" as follows:
 ```json
 {
   "rewrites": [
-    { "source": "/projects/:id/edit", "destination": "/edit-project-:id.html" },
+    { "source": "/projects/:id/edit", "destination": "/edit-project-:id.html" }
   ]
 }
 ```
@@ -139,6 +139,16 @@ Now, if a visitor accesses `/projects/123/edit`, it will respond with the file `
 
 **NOTE:** The paths can contain globs (matched using [minimatch](https://github.com/isaacs/minimatch)) or regular expressions (match using [path-to-regexp](https://github.com/pillarjs/path-to-regexp)).
 
+By default, values matched by a regular expression are encoded by `encodeURIComponent` before being included in the rewritten URL. This encoding can be disabled with the flag:
+
+```json
+{
+  "rewrites": [
+    { "source": "/foo/:bar*", "destination": "/:bar", "raw": true }
+  ]
+}
+```
+
 ### redirects (Array)
 
 In order to redirect visits to a certain path to a different one (or even an external URL), you can use this option:
@@ -167,7 +177,7 @@ Just like with [rewrites](#rewrites-array), you can also use routing segments:
 
 In the example above, `/old-docs/12` would be forwarded to `/new-docs/12` with status code [301](https://en.wikipedia.org/wiki/HTTP_301). In addition `/old` would be forwarded to `/new` with status code [302](https://en.wikipedia.org/wiki/HTTP_302).
 
-**NOTE:** The paths can contain globs (matched using [minimatch](https://github.com/isaacs/minimatch)) or regular expressions (match using [path-to-regexp](https://github.com/pillarjs/path-to-regexp)).
+**NOTE:** The paths can contain globs (matched using [minimatch](https://github.com/isaacs/minimatch)) or regular expressions (match using [path-to-regexp](https://github.com/pillarjs/path-to-regexp)). Just like with [rewrites](#rewrites-array), you can also disable the encoding of regular expression matches by adding `{raw: true}`.
 
 By default, the querystring and hash are not preserved by the redirect. The following boolean attributes enable this behavior:
 

lib/serve-handler/src/index.js

@@ -68,7 +68,7 @@ const sourceMatches = (source, requestPath, allowSegments) => {
   return null
 }
 
-const toTarget = (source, destination, previousPath) => {
+const toTarget = (source, destination, previousPath, raw) => {
   const matches = sourceMatches(source, previousPath, true)
 
   if (!matches) {
@@ -87,7 +87,9 @@ const toTarget = (source, destination, previousPath) => {
     props[name] = results[index + 1]
   }
 
-  return toPath(props)
+  const options = raw ? {encode: value => value} : {}
+
+  return toPath(props, options)
 }
 
 const applyRewrites = (requestPath, rewrites = [], repetitive) => {
@@ -103,8 +105,8 @@ const applyRewrites = (requestPath, rewrites = [], repetitive) => {
   }
 
   for (let index = 0; index < rewritesCopy.length; index++) {
-    const {source, destination} = rewrites[index]
-    const target = toTarget(source, destination, requestPath)
+    const {source, destination, raw} = rewrites[index]
+    const target = toTarget(source, destination, requestPath, raw)
 
     if (target) {
       // Remove rules that were already applied
@@ -177,8 +179,8 @@ const shouldRedirect = (decodedPath, {redirects = [], trailingSlash}, cleanUrl)
   // This is currently the fastest way to
   // iterate over an array
   for (let index = 0; index < redirects.length; index++) {
-    const {source, destination, type, preserveQuery, preserveHash} = redirects[index]
-    const target = toTarget(source, destination, decodedPath)
+    const {source, destination, type, preserveQuery, preserveHash, raw} = redirects[index]
+    const target = toTarget(source, destination, decodedPath, raw)
 
     if (target) {
       return {