         if step.finalHeading != nil { bearing = Int(step.finalHeading! as Double) }
 
         // Replace tokens
-        let result = instruction.replacingTokens { (tokenType) -> String in
+        let result = NSAttributedString(string: instruction, attributes: attrs).replacingTokens { (tokenType) -> NSAttributedString in
             var replacement: String
             switch tokenType {
             case .code: replacement = step.codes?.first ?? ""
-            case .wayName: replacement = wayName
+            case .wayName: replacement = "" // ignored
             case .destination: replacement = destination
             case .exitCode: replacement = exitCode
             case .exitIndex: replacement = exitOrdinal

// Will automatically read localized Instructions.plist
let OSRMTextInstructionsStrings = NSDictionary(contentsOfFile: Bundle(for: OSRMInstructionFormatter.self).path(forResource: "Instructions", ofType: "plist")!)!

extension String {
    public var sentenceCased: String {
        return String(characters.prefix(1)).uppercased() + String(characters.dropFirst())
    }
    
    /**
     Replaces `{tokens}` in the receiver using the given closure.
     */
    public func replacingTokens(using interpolator: ((TokenType) -> String)) -> String {
        let scanner = Scanner(string: self)
        scanner.charactersToBeSkipped = nil

            result = result.sentenceCased
        }
        return result
    }
}

extension NSAttributedString: Tokenized {
    public func replacingTokens(using interpolator: ((TokenType) -> NSAttributedString)) -> NSAttributedString {
        let scanner = Scanner(string: string)
        scanner.charactersToBeSkipped = nil
        let result = NSMutableAttributedString()
        while !scanner.isAtEnd {
            var buffer: NSString?
            
            if scanner.scanUpTo("{", into: &buffer) {
                result.append(NSAttributedString(string: buffer! as String))
            }
            guard scanner.scanString("{", into: nil) else {
                continue
            }
            
            var token: NSString?
            guard scanner.scanUpTo("}", into: &token) else {
                continue
            }
            
            if scanner.scanString("}", into: nil) {
                if let tokenType = TokenType(description: token! as String) {
                    result.append(interpolator(tokenType))
                }
            } else {
                result.append(NSAttributedString(string: token! as String))
            }
        }
        
        // remove excess spaces
        let wholeRange = NSRange(location: 0, length: result.mutableString.length)
        result.mutableString.replaceOccurrences(of: "\\s\\s", with: " ", options: .regularExpression, range: wholeRange)
        
        // capitalize
        let meta = OSRMTextInstructionsStrings["meta"] as! [String: Any]
        if meta["capitalizeFirstLetter"] as? Bool ?? false {
            result.replaceCharacters(in: NSRange(location: 0, length: 1), with: String(result.string.characters.first!).uppercased())
        }
        return result as NSAttributedString
    }
}

