     public init(){}
     
     /**
-     Associates a closure to a string pattern. A Routing instance will execute the closure in the event of a matching URL using #open.
-     Routing will only execute the first matching mapped route. This will be the last routed added with #map.
+     Associates a closure to a string pattern. A Routing instance will execute the closure in the
+     event of a matching URL using #open. Routing will only execute the first matching mapped route.
+     This will be the last routed added with #map.
      
      ```code
      let router = Routing()
      router.map("routing://route") { parameters, completed in
-        completed() // Must call completed or the router will halt!
+     completed() // Must call completed or the router will halt!
      }
      ```
      

        return false
    }
    
    private func prepare<H>(var pattern: String, queue: dispatch_queue_t, handler: H) -> ((String) -> (dispatch_queue_t, H?, Parameters)) {
        var dynamicSegments = [String]()
        while let range = pattern.rangeOfString(":[a-zA-Z0-9-_]+", options: [.RegularExpressionSearch, .CaseInsensitiveSearch]) {
            dynamicSegments.append(pattern.substringWithRange(range).stringByReplacingOccurrencesOfString(":", withString: ""))
            pattern.replaceRange(range, with: "([^/]+)")
        }
        
        return { (route: String) -> (dispatch_queue_t, H?, Parameters) in
            guard let matches = (try? NSRegularExpression(pattern: pattern, options: .CaseInsensitive))
                .flatMap({ $0.matchesInString(route, options: [], range: NSMakeRange(0, route.characters.count)) })?
                .first
                else {
                    return (queue, nil, [:])
            }
            
            var parameters = Parameters()
            if dynamicSegments.count > 0 && dynamicSegments.count == matches.numberOfRanges - 1 {
                [Int](1 ..< matches.numberOfRanges).forEach { (index) in
                    parameters[dynamicSegments[index-1]] = (route as NSString).substringWithRange(matches.rangeAtIndex(index))
                }
            }
            return (queue, handler, parameters)
        }
    }
    
    private func filterRoute<H>(route: String, routes: [(String) -> (dispatch_queue_t, H?, Parameters)]) -> [(dispatch_queue_t, H, Parameters)] {
        return routes
            .map { $0(route) }
            .filter { $0.1 != nil }
            .map { ($0, $1!, $2) }
    }
    
}

            proxies = self.proxies
        }
        
        if maps.count == 0 {
            return false
        }
        
        guard let components = NSURLComponents(URL: URL, resolvingAgainstBaseURL: false) else {
            return false
        }
        
        var queryParameters: [String: String] = [:]
        components.queryItems?.forEach() {
            queryParameters.updateValue(($0.value ?? ""), forKey: $0.name)
        }
        components.query = nil
        var URLString = components.string ?? ""
        
