expediate 0.0.2

package/.gitignore

@@ -0,0 +1,14 @@
+# Git ignore
+# ------------------------
+*
+!*/
+# ------------------------
+
+node_modules/
+!*.js
+!*.html
+!package.json
+!.git*
+!.npm*
+!dist/**/*
+

package/.npmignore

@@ -0,0 +1,14 @@
+# Npm ignore
+# ------------------------
+*
+!*/
+# ------------------------
+
+node_modules/
+!*.js
+!*.html
+!package.json
+!.git*
+!.npm*
+!dist/**/*
+

package/README.md

@@ -0,0 +1,83 @@
+# Expediate
+
+This small library serve as a router facility for a web server.
+For compatibility reason it keep the exact same interface as express.js,
+however it doesn't intent to provide all the features.
+
+  [![NPM Version][npm-image]][npm-url]
+  [![NPM Downloads][downloads-image]][downloads-url]
+  [![Linux Build][travis-image]][travis-url]
+  [![Windows Build][appveyor-image]][appveyor-url]
+  [![Test Coverage][coveralls-image]][coveralls-url]
+
+```js
+const expediate = require('expediate')
+const app = expediate()
+
+app.get('/', function (req, res) {
+  res.send('Hello World')
+})
+
+app.listen(3000)
+```
+
+The main reason for this package is that expressjs grow to become extra
+complicated with tons of dependencies. Expediate aims to keep thing simple
+while retaining the most widely used features.
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/).
+
+Before installing, [download and install Node.js](https://nodejs.org/en/download/).
+
+If this is a brand new project, make sure to create a `package.json` first with
+the [`npm init` command](https://docs.npmjs.com/creating-a-package-json-file).
+
+Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```bash
+$ npm install expediate
+```
+
+## Usage
+
+
+### Middleware
+
+ json => Parse Json body
+ static => Serve static files
+ urlencdeded => Parse url encoded
+
+```js
+var apiApp = expediate()
+apiApp.use('/myEndpoint', ...)
+
+var app = expediate();
+var app.use('/api', apiApp);
+
+app.listen(80)
+app.listen(443, { key: 'xx', cert: 'xx' })
+apiApp.listen(8900) // Only api
+```
+
+
+
+## License
+
+  [MIT](LICENSE)
+
+
+[npm-image]: https://img.shields.io/npm/v/expediate.svg
+[npm-url]: https://npmjs.org/package/expediate
+[downloads-image]: https://img.shields.io/npm/dm/expediate.svg
+[downloads-url]: https://npmcharts.com/compare/expediate?minimal=true
+[travis-image]: https://img.shields.io/travis/axfab/expediate/master.svg?label=linux
+[travis-url]: https://travis-ci.org/axfab/expediate
+[appveyor-image]: https://img.shields.io/appveyor/ci/axfab/expediate/master.svg?label=windows
+[appveyor-url]: https://ci.appveyor.com/project/axfab/expediate
+[coveralls-image]: https://img.shields.io/coveralls/axfab/expediate/master.svg
+[coveralls-url]: https://coveralls.io/r/axfab/expediate?branch=master
+

package/index.js

@@ -0,0 +1,266 @@
+/* Copyright 2021 Fabien Bavent
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+
+const http = require('http'),
+  https = require('https'),
+  serveStatic = require('./static.js');
+
+/**
+ * Prepare an layer object to define a new route
+ *
+ * @param {String} method
+ * @param {String} [path]
+ * @param {Listener} listener
+ * @return {Layer}
+ */
+function buildRouteLayer(method, path, listener) {
+  if (method)
+    method = method.toUpperCase();
+  if (typeof path === 'function') {
+    listener = path;
+    path = '/';
+  }
+  let parts = path.split('/').filter(x => x.length > 0);
+  return { method, path, parts, listener };
+};
+
+/**
+ * Check if a request match the current route(layer)
+ *
+ * In case the request match the route, we update the request
+ * path field and the queries.route map depending on route parameters
+ *
+ * @param {Layer} layer
+ * @param {http.ClientRequest} req
+ * @param {String[]} parts
+ * @return {Bool}
+ */
+function matchRouteLayer(layer, req, parts) {
+  if (layer.method && layer.method != req.method)
+    return false;
+  let params = {}
+  for (let i = 0; ; ++i) {
+    if (layer.parts.length <= i) {
+      req.path = '/' + parts.slice(i).join('/');
+      req.queries.route = params;
+      return true;
+    } else if (parts.length <= i)
+      return false;
+    else if (layer.parts[i][0] == ':')
+      params[layer.parts[i].substring(1)] = parts[i];
+    else if (layer.parts[i] != parts[i])
+      return false;
+  }
+};
+
+/**
+ * Extends the request and response object of a http request
+ * with parameters and helper.
+ *
+ * @param {http.ClientRequest} req
+ * @param {http.ServerResponse} res
+ */
+function updateHttpObject(req, res) {
+  if (req.queries)
+    return
+  req.queries = {};
+
+  let qry = new URL(`http://${req.headers.host}${req.url}`)
+  req.originalUrl = req.url;
+  req.path = qry.pathname
+
+  // Parse URL-encoded data
+  let params = {};
+  for(var pair of qry.searchParams.entries())
+    params[pair[0]] = pair[1];
+  req.queries.url = params;
+
+  // Parse cookies
+  if (req.cookies == null) {
+    req.cookies = {};
+    var cookies = req.headers.cookie;
+    if (cookies) {
+      cookies = cookies.split(';')
+        .map(x => x.replace(/^\s+|\s+$/g, '').split('='));
+      for (var k in cookies) {
+        let key = cookies[k][0]
+        let val = cookies[k][1]
+        req.cookies[key] = val;
+        if (typeof val == 'string') {
+          // TODO s: Cookie is signed, j: Cookie is a JSON
+        }
+      }
+    }
+  }
+
+
+  res.setHeader('X-Powered-By', 'Expediate');
+
+  res.send = (data) => {
+    res.write(data);
+    res.end();
+  }
+
+  res.status = (code, headers) => {
+    if (headers)
+      for (var k in headers)
+        res.setHeader(k, headers[k])
+    res.writeHead(code)
+    return res;
+  };
+
+  res.redirect = (url) => {
+    let status = 302;
+    res.setHeader('location', url);
+    res.writeHead(status)
+    res.write(`Found. Redirecting to ${url}`);
+    res.end();
+  };
+
+  res.cookie = function (name, value, options) {
+    var opts = options || {};
+
+    if (opts.signed && !res.req.secret)
+      throw new Error('cookieParser("secret") required for signed cookies');
+
+    var val = typeof value === 'object'
+      ? 'j:' + JSON.stringify(value)
+      : String(value);
+
+    if (opts.signed)
+      val = 's:' + sign(val, res.req.secret);
+
+    let txt = `${name}=${String(val)}`
+
+    if ('maxAge' in opts) {
+      opts.expires = new Date(Date.now() + opts.maxAge);
+      opts.maxAge /= 1000;
+    }
+
+    if (opts.path == null)
+      opts.path = '/';
+    txt += `; Path=${opts.path}`
+
+    res.setHeader('Set-Cookie', txt);
+    return res;
+  };
+
+};
+
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+module.exports = Router;
+
+/**
+ * This function create a new router function as a web listener.
+ */
+function Router() {
+
+  const routes = [];
+
+  const listener = function(req, res, done) {
+    const method = req.method;
+    const url = req.url;
+    let idx = 0;
+    updateHttpObject(req, res);
+    const parts = req.path.split('/').filter(x => x.length > 0);
+
+    const next = () => {
+      while (idx < routes.length) {
+        let layer = routes[idx++];
+        if (matchRouteLayer(layer, req, parts))
+          return layer.listener(req, res, next);
+      }
+
+      if (done)
+        return done();
+      return res.status(404).end(`Cannot ${method} ${url}`);
+    }
+
+    try {
+      next();
+    } catch (e) {
+      console.warn(e)
+      res.status(500).end(`Error ${method} ${url}`)
+    }
+  };
+
+  listener.use = (p, l) => routes.push(buildRouteLayer(null, p, l));
+  listener.all = (p, l) => routes.push(buildRouteLayer(null, p, l));
+  listener.get = (p, l) => routes.push(buildRouteLayer('GET', p, l));
+  listener.put = (p, l) => routes.push(buildRouteLayer('PUT', p, l));
+  listener.post = (p, l) => routes.push(buildRouteLayer('POST', p, l));
+  listener.delete = (p, l) => routes.push(buildRouteLayer('DELETE', p, l));
+  listener.patch = (p, l) => routes.push(buildRouteLayer('PATCH', p, l));
+
+  listener.listen = (port, opts, cb) => {
+    if (typeof opts === 'function') {
+      cb = opts;
+      opts = null;
+    }
+    if (opts && opts.key && opts.cert)
+      https.createServer(opts, listener).listen(port, cb);
+    else
+      http.createServer(listener).listen(port, cb);
+  };
+
+  return listener;
+};
+
+// -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+Router.logger = () => {
+  return (req, res, next) => {
+    const nclr = '\x1b[0m';
+    const colors = [
+      '\x1b[31m', '\x1b[33m', '\x1b[32m', '\x1b[33m', '\x1b[31m', '\x1b[91m'];
+    const rec = new Intl.DateTimeFormat('en-GB', {
+      month: 'short',
+      day:'2-digit',
+      hour:'2-digit',
+      minute:'2-digit'}).format();
+    const path = req.path;
+    req.received = new Date().getTime();
+    res.on('finish', ev => {
+      req.elapsed = new Date().getTime() - req.received;
+      const clr = colors[parseInt(res.statusCode / 100)];
+      const ip = req.headers['x-forwarded-for'] || req.connection.remoteAddress;
+      const user = req.session ? `${req.session.username}/${req.session.ssid}` : '-'
+      const status = `${clr}${res.statusCode}${nclr}`
+      const elp = `${req.elapsed} ms`
+      console.log(`${rec} ${status} ${req.method} ${path} ${ip} <${user}> ${elp}`);
+    })
+    next();
+  };
+};
+
+Router.static = serveStatic;
+
+Router.session = (opts) => {
+  return (req, res, next) => {
+    let ssid = req.cookies.ssid;
+    req.session = opts.openSession(ssid);
+    if (ssid != req.session.ssid)
+      res.cookie('ssid', req.session.ssid);
+    next();
+  };
+};

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "expediate",
+  "version": "0.0.2",
+  "description": "Fast and simple, minimalist web framework",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "Fabien Bavent <fabien.bavet@gmail.com>",
+  "license": "MIT",
+  "dependencies": {
+    "mime": "^1.6.0"
+  }
+}

package/sample.js

@@ -0,0 +1,9 @@
+
+const expediate = require('./index.js')
+    app = expediate();
+
+
+app.use('/', expediate.logger())
+app.use('/', expediate.static('.'))
+app.listen(80)
+

package/static.js

@@ -0,0 +1,388 @@
+/* Copyright 2021 Fabien Bavent
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+'use strict';
+
+const fs = require('fs'),
+    path = require('path');
+const mime = require('mime');
+
+// Regular expression to match a path with a directory up component.
+const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/
+
+const HTTP = {
+  NOT_MODIFIED: res => httpSend(res, 304),
+  FORBIDDEN: res => httpSend(res, 403, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Forbidden'),
+  NOT_FOUND: res => httpSend(res, 404, {
+        // 'Content-Type': 'text/html; charset=UTF-8',
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Not Found'),
+  NOT_ALLOWED: res => httpSend(res, 405, { 'Allow': 'GET, HEAD' }),
+  PRECONDITION_FAILS: res => httpSend(res, 412, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, 'Precondition Failed'),
+  INTERNAL_ERROR: (res, err) => httpSend(res, 500, {
+        'Content-Security-Policy': "default-src 'none'",
+        'X-Content-Type-Options': 'nosniff'
+      }, `Internal error: ${err}`),
+};
+
+// Destroy a read stream properly
+function destroyReadStream(stream) {
+  stream.destroy()
+  if (typeof stream.close === 'function') {
+    // node.js core bug work-around
+    stream.on('open', _ => {
+      if (typeof stream.fd === 'number')
+        stream.close()
+    })
+  }
+}
+
+function removeContentHeaders(res) {
+  var keys = Object.keys(res.getHeaders() || {});
+  for (let key of keys) {
+    if (key.substr(0, 8) === 'content-' && key != 'content-location')
+      res.removeHeader(key)
+  }
+}
+
+// Create a simple ETag based on file metadata
+function createETag(stat) {
+  var mtime = stat.mtime.getTime().toString(16)
+  var size = stat.size.toString(16)
+  return 'W/"' + size + '-' + mtime + '"'
+}
+
+// Basic utility for default answers
+function httpSend (res, code, headers, body) {
+  headers = headers || {}
+  body = body || ''
+  res.statusCode = code;
+  for (let k in headers)
+    res.setHeader(k.toString(), headers[k].toString())
+  res.setHeader('Content-Length', Buffer.byteLength(body))
+  if (body)
+    res.write(body);
+  res.end();
+}
+
+// Parse a HTTP token list.
+function parseTokenList (str) {
+  var end = 0
+  var list = []
+  var start = 0
+
+  // gather tokens
+  for (var i = 0, len = str.length; i < len; i++) {
+    switch (str.charCodeAt(i)) {
+      case 0x20: /*   */
+        if (start === end) {
+          start = end = i + 1
+        }
+        break
+      case 0x2c: /* , */
+        list.push(str.substring(start, end))
+        start = end = i + 1
+        break
+      default:
+        end = i + 1
+        break
+    }
+  }
+
+  // final token
+  list.push(str.substring(start, end))
+
+  return list
+}
+
+// Parse an HTTP Date into a number.
+function parseHttpDate (date) {
+  var timestamp = date && Date.parse(date)
+
+  return typeof timestamp === 'number'
+    ? timestamp
+    : NaN
+}
+
+function hasCondition(req) {
+  return req['if-match'] ||
+    req['if-unmodified-since'] ||
+    req['if-none-match'] ||
+    req['if-modified-since']
+}
+
+function conditionMatch(req, res) {
+
+  // if-match
+  const match = req['if-match']
+  if (match) {
+    const etag = res['etag']
+    if (match === etag || match === '*')
+      return true;
+    for (let tag of parseTokenList(match))
+      if (match === tag || match === 'W/' + tag || 'W/' + match === tag)
+        return true;
+  }
+
+  // if-unmodified-since
+  const lastModified = parseHttpDate(res['last-modified'])
+  const unmodifiedSince = parseHttpDate(req['if-modified-since'])
+  if (!isNaN(unmodifiedSince) && !isNaN(lastModified))
+    return lastModified <= unmodifiedSince
+
+
+  return false
+}
+
+// Check freshness of the response using request and response headers.
+function isCacheFresh (req, res) {
+  const CACHE_CONTROL_NO_CACHE_REGEXP = /(?:^|,)\s*?no-cache\s*?(?:,|$)/
+  // fields
+  var modifiedSince = req['if-modified-since']
+  var noneMatch = req['if-none-match']
+
+  // unconditional request
+  if (!modifiedSince && !noneMatch) {
+    return false
+  }
+
+  // Always return stale when Cache-Control: no-cache
+  // to support end-to-end reload requests
+  // https://tools.ietf.org/html/rfc2616#section-14.9.4
+  var cacheControl = req['cache-control']
+  if (cacheControl && CACHE_CONTROL_NO_CACHE_REGEXP.test(cacheControl)) {
+    return false
+  }
+
+  // if-none-match
+  if (noneMatch && noneMatch !== '*') {
+    var etag = res['etag']
+
+    if (!etag) {
+      return false
+    }
+
+    var etagStale = true
+    var matches = parseTokenList(noneMatch)
+    for (var i = 0; i < matches.length; i++) {
+      var match = matches[i]
+      if (match === etag || match === 'W/' + etag || 'W/' + match === etag) {
+        etagStale = false
+        break
+      }
+    }
+
+    if (etagStale) {
+      return false
+    }
+  }
+
+  // if-modified-since
+  if (modifiedSince) {
+    var lastModified = res['last-modified']
+    var modifiedStale = !lastModified || !(parseHttpDate(lastModified) <= parseHttpDate(modifiedSince))
+
+    if (modifiedStale) {
+      return false
+    }
+  }
+
+  return true
+}
+
+function sendFile(req, res, pathname, stat, opts) {
+  const len = stat.size
+  const etag = createETag(stat)
+
+  if (opts.setHeaders)
+    opts.setHeaders(res);
+
+  // set cache-control
+  if (!res.getHeader('Cache-Control') && opts.maxage) {
+    var cacheControl = 'public, max-age=' + Math.floor(opts.maxage / 1000)
+    if (opts.immutable === true)
+      cacheControl += ', immutable'
+    res.setHeader('Cache-Control', cacheControl)
+  }
+
+  if (!res.getHeader('Last-Modified') && opts.lastModified !== false)
+    res.setHeader('Last-Modified', stat.mtime.toUTCString())
+
+  if (!res.getHeader('ETag') && opts.etag !== false)
+    res.setHeader('ETag', etag)
+
+  // set content-type
+  if (!res.getHeader('Content-Type')) {
+    if (opts.contentType) {
+      res.setHeader('Content-Type', opts.contentType)
+    } else {
+      var type = mime.lookup(pathname)
+      if (type) {
+        var charset = mime.charsets.lookup(type)
+        if (charset)
+          res.setHeader('Content-Type', type + '; charset=' + charset)
+        else
+          res.setHeader('Content-Type', type)
+      }
+    }
+  }
+
+  // Conditionnal GET
+  if (hasCondition(req.headers)) {
+    if (!conditionMatch(req.headers, res.getHeaders())) {
+      return HTTP.PRECONDITION_FAILS(res)
+    }
+
+    if (isCacheFresh(req.headers, res.getHeaders())) {
+      removeContentHeaders(res);
+      return HTTP.NOT_MODIFIED(res);
+    }
+  }
+
+
+  // Send data
+  res.setHeader('Content-Length', len)
+  if (req.method === 'HEAD')
+    return res.end()
+
+  let finished = false
+  const stream = fs.createReadStream(pathname);
+  res.on('finish', _ => {
+    finished = true;
+    destroyReadStream(stream);
+  });
+  stream.on('error', err => {
+    if (finished) return;
+    console.log('ERROR', pathname, err)
+    HTTP.INTERNAL_ERROR(res, err.code);
+    finished = true;
+    destroyReadStream(stream);
+  });
+  stream.on('end', _ => {
+    res.end();
+  });
+  stream.pipe(res);
+}
+
+function sendIndex(req, res, pathname, stat, opts) {
+
+  var p = path.join(pathname, 'index.html')
+  fs.stat(p, function (err, stat) {
+    if (err) {
+      if (err.code == 'ENOENT' || err.code == 'ENAMETOOLONG' || err.code == 'ENOTDIR') {
+        if (opts.fallthrough)
+          return next();
+        return HTTP.NOT_FOUND(res)
+      }
+      return HTTP.INTERNAL_ERROR(res, err.code);
+    }
+
+    // index file support
+    if (stat.isDirectory()) {
+      return HTTP.NOT_FOUND(res);
+    }
+
+    sendFile(req, res, p, stat, opts)
+  })
+}
+
+function serveStatic (root, options) {
+
+  if (!root)
+    throw new TypeError('root path required')
+  else if (typeof root !== 'string')
+    throw new TypeError('root path must be a string')
+
+  // copy options
+  var opts = options || {
+    fallthrough: false,
+    redirect: false,
+  };
+  opts.fallthrough = opts.fallthrough !== false
+  opts.redirect = opts.redirect !== false
+  opts.maxage = opts.maxage || opts.maxAge || 0
+  opts.root = path.resolve(root)
+  if (opts.setHeaders && typeof opts.setHeaders !== 'function')
+    throw new TypeError('option setHeaders must be function')
+
+
+  return function serveStatic (req, res, next) {
+
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      if (opts.fallthrough)
+        return next()
+      return HTTP.NOT_ALLOWED(res);
+    }
+
+    var originalUrl = decodeURIComponent(req.originalUrl || req.path || req.url)
+    var pathname = originalUrl
+
+    // make sure redirect occurs at mount
+    if (pathname === '/' && originalUrl.substr(-1) !== '/') {
+      pathname = ''
+    }
+
+    if (UP_PATH_REGEXP.test(pathname))
+      return HTTP.FORBIDDEN(res);
+
+    // resolve the path
+    pathname = path.resolve(path.normalize(opts.root + '/' + pathname));
+
+    // dotfile handling
+    if (opts.dotfiles != 'allow' && pathname.indexOf('/.') >= 0) {
+      if (opts.dotfiles == 'deny')
+        return HTTP.FORBIDDEN(res);
+      return HTTP.NOT_FOUND(res);
+    }
+
+    fs.stat(pathname, function onstat (err, stat) {
+      if (err) {
+        // console.log('DBG', pathname, err.code, req.originalUrl, req.url, req.path)
+        if (err.code == 'ENOENT' || err.code == 'ENAMETOOLONG' || err.code == 'ENOTDIR') {
+          if (opts.fallthrough)
+            return next();
+          return HTTP.NOT_FOUND(res)
+        }
+        return HTTP.INTERNAL_ERROR(res, err.code);
+      }
+
+      // index file support
+      if (stat.isDirectory()) {
+        // if (!opts.redirect)
+        //   return HTTP.NOT_FOUND(res);
+        return sendIndex(req, res, pathname, stat, opts)
+      }
+
+
+      sendFile(req, res, pathname, stat, opts)
+    });
+  }
+}
+
+
+
+module.exports = serveStatic;