StaticFileHandler weird behaviour on old browsers about perfect-http HOT 9 OPEN

let server = HTTPServer()
let sessionDriver = SessionMemoryDriver()

let routes = [
    Route(method: .get, uri: "/**", handler: try! HTTPHandler.staticFiles(data: [
        "documentRoot": "./webroot",
        "allowResponseFilters": true
    ])),
    Route(method: .get, uri: "/", handler:homeController.indexAction),
     // more non-static files routes...
]

server.setRequestFilters([sessionDriver.requestFilter])
server.setResponseFilters([sessionDriver.responseFilter, (Finalizer(), .high)])
/*
    With compression:
    server.setResponseFilters([sessionDriver.responseFilter, (Finalizer(), .high), (try PerfectHTTPServer.HTTPFilter.contentCompression(data: [:]), HTTPFilterPriority.high)])
*/
server.serverPort = 8181
server.addRoutes(routes)
server.serverName = "localhost"
try! server.start()

class Finalizer: HTTPResponseFilter {
    
    public func filterHeaders(response: HTTPResponse, callback: (HTTPResponseFilterResult) -> ()) {
        if 400...500 ~= response.status.code {
            let pageContent = "An error occured"
            response.setBody(string: pageContent)
            response.setHeader(.contentLength, value: String(pageContent.count))
            callback(.done)
        }
        else {
            callback(.continue)
        }
    }
    
    public func filterBody(response: HTTPResponse, callback: (HTTPResponseFilterResult) -> ()) {
        callback(.continue)
    }
}

// swift-tools-version:4.2

import PackageDescription

let package = Package(
    name: "RunnifySwift",
    dependencies: [
        .package(url: "https://github.com/PerfectlySoft/Perfect-HTTPServer.git", from: "3.0.23"),
        .package(url: "https://github.com/PerfectlySoft/Perfect-Mustache.git", from: "3.0.2")
    ],
    targets: [
        .target(
            name: "RunnifySwift",
            dependencies: ["PerfectHTTPServer", "PerfectMustache"]),
        .testTarget(
            name: "RunnifySwiftTests",
            dependencies: ["RunnifySwift"]),
    ]
)

import PerfectHTTP
import PerfectHTTPServer
import PerfectMustache
import Foundation

    
let server = HTTPServer()
let WEBROOT = "[path-to-webroot]"

func handlePage(_ controller: @escaping (HTTPRequest) throws -> (String, [String: Any])) -> (HTTPRequest, HTTPResponse) -> Void {
    return { req, res in
        do {
            let (view, data) = try controller(req)
            mustacheRequest(request: req, response: res, handler: PageHandler(values: data, sessionData: [:]), templatePath: WEBROOT + view)
        }
        catch(let error) {
            res.setBody(string: error.localizedDescription)
            res.completed(status: .internalServerError)
        }
    }
}

func indexAction(request: HTTPRequest) throws -> (String, [String: Any]) {
    return ("pages/Index/index.html.mustache", ["listRaces": []])
}

let routes = Routes([
    Route(method: .get, uri: "/**", handler: try! HTTPHandler.staticFiles(data: [
        "documentRoot": WEBROOT,
        "allowResponseFilters": true
        ])),
    Route(method: .get, uri: "/", handler: handlePage(indexAction))
])

server.serverPort = 80
server.addRoutes(routes)
server.serverName = "localhost"
try! server.start()

import Foundation
import PerfectMustache
import PerfectHTTP

struct PageHandler: MustachePageHandler {
    let values: MustacheEvaluationContext.MapType
    let sessionData: [String: Any]
    
    func extendValuesForResponse(context contxt: MustacheWebEvaluationContext, collector: MustacheEvaluationOutputCollector) {
        contxt.extendValues(with: values)
        contxt.extendValues(with: sessionData)
        do{ try contxt.requestCompleted(withCollector: collector) }
        catch {
            let response = contxt.webResponse
            response.status = .internalServerError
            response.setBody(string: "\(error)")
            response.completed()
        }
    }
}