0001    import Foundation
0002    
0003    enum TokenType
Parser.swift:31
      >>=- expect(TokenType.End, message: "expected end")
Parser.swift:57
func peekType (context: Context) -> TokenType {
Parser.swift:85
func expect (type: TokenType, message: String) -> Context -> Result<Context> {
Parser.swift:132
          >>=- expect(TokenType.Space, message: "expected space")
Parser.swift:229
        >>=- expect(TokenType.Dedent, message: "expected dedent")
Parser.swift:294
      >>=- expect(TokenType.OpenSB, message: "expected [")
Parser.swift:305
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Parser.swift:319
      >>=- expect(TokenType.OpenCB, message: "expected {")
Parser.swift:330
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Parser.swift:337
        >>=- expect(TokenType.Colon, message: "expected colon")
Parser.swift:359
        >>=- expect(TokenType.Indent, message: "expected indent after dash")
Parser.swift:366
        >>=- expect(TokenType.Dedent, message: "expected dedent after dash indent")
Parser.swift:396
        >>=- expect(TokenType.QuestionMark, message: "expected ?")
Parser.swift:422
      >>=- expect(TokenType.Colon, message: "expected colon")
Parser.swift:505
      >>=- expect(TokenType.String, message: "expected scalar block")
Tokenizer.swift:53
typealias TokenPattern = (type: TokenType, pattern: NSRegularExpression)
Tokenizer.swift:54
typealias TokenMatch = (type: TokenType, match: String)
: Swift.String, CustomStringConvertible {
0004      case YamlDirective
Parser.swift:127
    case .YamlDirective:
Tokenizer.swift:72
  (.YamlDirective, regex("^%YAML(?= )")),
 = "%YAML"
0005      case DocStart
Parser.swift:136
    case .DocStart:
Tokenizer.swift:73
  (.DocStart, regex("^---")),
 = "doc-start"
0006      case DocEnd
Parser.swift:79
  if ![.Comment, .Space, .NewLine, .DocEnd].contains(peekType(context)) {
Tokenizer.swift:74
  (.DocEnd, regex("^\\.\\.\\.")),
 = "doc-end"
0007      case Comment
Parser.swift:72
  if ![.Comment, .Space, .NewLine].contains(peekType(context)) {
Parser.swift:79
  if ![.Comment, .Space, .NewLine, .DocEnd].contains(peekType(context)) {
Parser.swift:122
    case .Comment, .Space, .NewLine:
Parser.swift:149
  case .Comment, .Space, .NewLine:
Tokenizer.swift:75
  (.Comment, regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")),
 = "comment"
0008      case Space
Parser.swift:72
  if ![.Comment, .Space, .NewLine].contains(peekType(context)) {
Parser.swift:79
  if ![.Comment, .Space, .NewLine, .DocEnd].contains(peekType(context)) {
Parser.swift:122
    case .Comment, .Space, .NewLine:
Parser.swift:132
          >>=- expect(TokenType.Space, message: "expected space")
Parser.swift:149
  case .Comment, .Space, .NewLine:
Tokenizer.swift:76
  (.Space, regex("^ +")),
 = "space"
0009      case NewLine
Parser.swift:72
  if ![.Comment, .Space, .NewLine].contains(peekType(context)) {
Parser.swift:79
  if ![.Comment, .Space, .NewLine, .DocEnd].contains(peekType(context)) {
Parser.swift:122
    case .Comment, .Space, .NewLine:
Parser.swift:149
  case .Comment, .Space, .NewLine:
Tokenizer.swift:77
  (.NewLine, regex("^\(bBreak) *")),
Tokenizer.swift:131
        case .NewLine:
Tokenizer.swift:139
            matchList.append(TokenMatch(.NewLine, match))
Tokenizer.swift:152
            matchList.append(TokenMatch(.NewLine, match))
Tokenizer.swift:159
            matchList.append(TokenMatch(.NewLine, match))
 = "newline"
0010      case Indent
Parser.swift:223
  case .Indent:
Parser.swift:359
        >>=- expect(TokenType.Indent, message: "expected indent after dash")
Tokenizer.swift:143
                  matchList[matchList.endIndex - 1].type == .Indent {
Tokenizer.swift:145
                matchList[matchList.endIndex - 1] = TokenMatch(.Indent, match)
Tokenizer.swift:148
                matchList.append(TokenMatch(.Indent, match))
Tokenizer.swift:169
          matchList.append(TokenMatch(.Indent, match.substringFromIndex(index)))
Tokenizer.swift:182
            matchList.append(TokenMatch(.Indent, ""))
 = "indent"
0011      case Dedent
Parser.swift:229
        >>=- expect(TokenType.Dedent, message: "expected dedent")
Parser.swift:248
  case .End, .Dedent:
Parser.swift:366
        >>=- expect(TokenType.Dedent, message: "expected dedent after dash indent")
Tokenizer.swift:157
              matchList.append(TokenMatch(.Dedent, ""))
Tokenizer.swift:255
    matchList.append((.Dedent, ""))
 = "dedent"
0012      case Null
Parser.swift:152
  case .Null:
Tokenizer.swift:79
  (.Null, regex("^(null|Null|NULL|~)\(finish)")),
 = "null"
0013      case True
Parser.swift:155
  case .True:
Tokenizer.swift:80
  (.True, regex("^(true|True|TRUE)\(finish)")),
 = "true"
0014      case False
Parser.swift:158
  case .False:
Tokenizer.swift:81
  (.False, regex("^(false|False|FALSE)\(finish)")),
 = "false"
0015      case InfinityP
Parser.swift:184
  case .InfinityP:
Tokenizer.swift:82
  (.InfinityP, regex("^\\+?\\.(inf|Inf|INF)\(finish)")),
 = "+infinity"
0016      case InfinityN
Parser.swift:187
  case .InfinityN:
Tokenizer.swift:83
  (.InfinityN, regex("^-\\.(inf|Inf|INF)\(finish)")),
 = "-infinity"
0017      case NaN
Parser.swift:190
  case .NaN:
Tokenizer.swift:84
  (.NaN, regex("^\\.(nan|NaN|NAN)\(finish)")),
 = "nan"
0018      case Double
Parser.swift:193
  case .Double:
Tokenizer.swift:89
  (.Double, regex("^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?\(finish)")),
 = "double"
0019      case Int
Parser.swift:161
  case .Int:
Tokenizer.swift:85
  (.Int, regex("^[-+]?[0-9]+\(finish)")),
 = "int"
0020      case IntOct
Parser.swift:167
  case .IntOct:
Tokenizer.swift:86
  (.IntOct, regex("^0o[0-7]+\(finish)")),
 = "int-oct"
0021      case IntHex
Parser.swift:173
  case .IntHex:
Tokenizer.swift:87
  (.IntHex, regex("^0x[0-9a-fA-F]+\(finish)")),
 = "int-hex"
0022      case IntSex
Parser.swift:179
  case .IntSex:
Tokenizer.swift:88
  (.IntSex, regex("^[0-9]{2}(:[0-9]{2})+\(finish)")),
 = "int-sex"
0023      case Anchor
Parser.swift:232
  case .Anchor:
Tokenizer.swift:90
  (.Anchor, regex("^&\\w+")),
 = "&"
0024      case Alias
Parser.swift:240
  case .Alias:
Tokenizer.swift:91
  (.Alias, regex("^\\*\\w+")),
 = "*"
0025      case Comma
Parser.swift:305
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Parser.swift:330
        >>=- (acc.count == 0 ? lift : expect(TokenType.Comma, message: "expected comma"))
Tokenizer.swift:92
  (.Comma, regex("^,")),
 = ","
0026      case OpenSB
Parser.swift:200
  case .OpenSB:
Parser.swift:294
      >>=- expect(TokenType.OpenSB, message: "expected [")
Tokenizer.swift:93
  (.OpenSB, regex("^\\[")),
Tokenizer.swift:185
        case .OpenSB, .OpenCB:
 = "["
0027      case CloseSB
Parser.swift:300
    if peekType(context) == .CloseSB {
Tokenizer.swift:94
  (.CloseSB, regex("^\\]")),
Tokenizer.swift:189
        case .CloseSB, .CloseCB:
 = "]"
0028      case Dash
Parser.swift:197
  case .Dash:
Parser.swift:354
    if peekType(context) != .Dash {
Tokenizer.swift:78
  (.Dash, dashPattern),
Tokenizer.swift:162
        case .Dash, .QuestionMark:
 = "-"
0029      case OpenCB
Parser.swift:203
  case .OpenCB:
Parser.swift:319
      >>=- expect(TokenType.OpenCB, message: "expected {")
Tokenizer.swift:95
  (.OpenCB, regex("^\\{")),
Tokenizer.swift:185
        case .OpenSB, .OpenCB:
 = "{"
0030      case CloseCB
Parser.swift:325
    if peekType(context) == .CloseCB {
Tokenizer.swift:96
  (.CloseCB, regex("^\\}")),
Tokenizer.swift:189
        case .CloseSB, .CloseCB:
 = "}"
0031      case Key = "key"
0032      case KeyDQ = "key-dq"
0033      case KeySQ = "key-sq"
0034      case QuestionMark
Parser.swift:206
  case .QuestionMark:
Parser.swift:381
    case .QuestionMark:
Parser.swift:396
        >>=- expect(TokenType.QuestionMark, message: "expected ?")
Tokenizer.swift:97
  (.QuestionMark, regex("^\\?( +|(?=\(bBreak)))")),
Tokenizer.swift:162
        case .Dash, .QuestionMark:
 = "?"
0035      case ColonFO
Tokenizer.swift:98
  (.ColonFO, regex("^:(?!:)")),
Tokenizer.swift:171
        case .ColonFO:
 = ":-flow-out"
0036      case ColonFI
Tokenizer.swift:99
  (.ColonFI, regex("^:(?!:)")),
Tokenizer.swift:177
        case .ColonFI:
 = ":-flow-in"
0037      case Colon
Parser.swift:337
        >>=- expect(TokenType.Colon, message: "expected colon")
Parser.swift:414
  if peekType(context) != .Colon {
Parser.swift:422
      >>=- expect(TokenType.Colon, message: "expected colon")
Parser.swift:470
  return context.tokens[1].type != .Colon || matches(match, regex: regex("\n"))
Tokenizer.swift:179
          matchList.append(TokenMatch(.Colon, match))
 = ":"
0038      case Literal
Parser.swift:212
  case .Literal:
Tokenizer.swift:100
  (.Literal, regex("^\\|.*")),
Tokenizer.swift:193
        case .Literal, .Folded:
 = "|"
0039      case Folded
Parser.swift:215
  case .Folded:
Tokenizer.swift:101
  (.Folded, regex("^>.*")),
Tokenizer.swift:193
        case .Literal, .Folded:
 = ">"
0040      case Reserved
Tokenizer.swift:102
  (.Reserved, regex("^[@`]")),
Tokenizer.swift:241
        case .Reserved:
 = "reserved"
0041      case StringDQ
Parser.swift:209
  case .StringDQ, .StringSQ, .String:
Parser.swift:384
    case .String, .StringDQ, .StringSQ:
Parser.swift:454
  case .StringDQ:
Tokenizer.swift:103
  (.StringDQ, regex("^\"([^\\\\\"]|\\\\(.|\(bBreak)))*\"")),
 = "string-dq"
0042      case StringSQ
Parser.swift:209
  case .StringDQ, .StringSQ, .String:
Parser.swift:384
    case .String, .StringDQ, .StringSQ:
Parser.swift:458
  case .StringSQ:
Tokenizer.swift:104
  (.StringSQ, regex("^'([^']|'')*'")),
 = "string-sq"
0043      case StringFI
Tokenizer.swift:106
  (.StringFI, regex("^\(plainInPattern)")),
Tokenizer.swift:235
        case .StringFI:
 = "string-flow-in"
0044      case StringFO
Tokenizer.swift:105
  (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
Tokenizer.swift:211
        case .StringFO:
 = "string-flow-out"
0045      case String
Parser.swift:209
  case .StringDQ, .StringSQ, .String:
Parser.swift:384
    case .String, .StringDQ, .StringSQ:
Parser.swift:449
  case .String:
Parser.swift:505
      >>=- expect(TokenType.String, message: "expected scalar block")
Tokenizer.swift:208
          matchList.append(TokenMatch(.String, block))
Tokenizer.swift:232
          matchList.append(TokenMatch(.String, block))
Tokenizer.swift:239
          matchList.append(TokenMatch(.String, match))
 = "string"
0046      case End
Parser.swift:31
      >>=- expect(TokenType.End, message: "expected end")
Parser.swift:41
    if peekType(context) == .End {
Parser.swift:108
  if string.characters.count >= 50 || peekType(context) == .End {
Parser.swift:248
  case .End, .Dedent:
Tokenizer.swift:257
  matchList.append((.End, ""))
 = "end"
0047    
0048      var description: Swift.String {
0049        return self.rawValue
0050      }
0051    }
0052    
0053    typealias TokenPattern
Tokenizer.swift:71
let tokenPatterns: [TokenPattern] = [
 = (type: TokenType, pattern: NSRegularExpression)
0054    typealias TokenMatch
Parser.swift:4
  let tokens: [TokenMatch]
Parser.swift:7
  init (_ tokens: [TokenMatch], _ aliases: [String: Yaml] = [:]) {
Parser.swift:24
func parseDoc (tokens: [TokenMatch]) -> Result<Yaml> {
Parser.swift:35
func parseDocs (tokens: [TokenMatch]) -> Result<[Yaml]> {
Tokenizer.swift:118
func tokenize (text: String) -> Result<[TokenMatch]> {
Tokenizer.swift:120
  var matchList: [TokenMatch] = []
 = (type: TokenType, match: String)
0055    
0056    let bBreak
Tokenizer.swift:66
    "([\(safeOut)]#|:(?![ \\t]|\(bBreak))|[\(safeOut)]|[ \\t])+"
Tokenizer.swift:68
    "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+"
Tokenizer.swift:68
    "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+"
Tokenizer.swift:69
let dashPattern = regex("^-([ \\t]+(?!#|\(bBreak))|(?=[ \\t\\n]))")
Tokenizer.swift:70
let finish = "(?= *(,|\\]|\\}|( #.*)?(\(bBreak)|$)))"
Tokenizer.swift:75
  (.Comment, regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")),
Tokenizer.swift:75
  (.Comment, regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")),
Tokenizer.swift:77
  (.NewLine, regex("^\(bBreak) *")),
Tokenizer.swift:97
  (.QuestionMark, regex("^\\?( +|(?=\(bBreak)))")),
Tokenizer.swift:103
  (.StringDQ, regex("^\"([^\\\\\"]|\\\\(.|\(bBreak)))*\"")),
Tokenizer.swift:105
  (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
Tokenizer.swift:105
  (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
Tokenizer.swift:198
          let blockPattern = regex(("^(\(bBreak) *)*(\(bBreak)" +
Tokenizer.swift:198
          let blockPattern = regex(("^(\(bBreak) *)*(\(bBreak)" +
Tokenizer.swift:199
              "( {\(minIndent),})[^ ].*(\(bBreak)( *|\\3.*))*)(?=\(bBreak)|$)"))
Tokenizer.swift:199
              "( {\(minIndent),})[^ ].*(\(bBreak)( *|\\3.*))*)(?=\(bBreak)|$)"))
Tokenizer.swift:203
              |> replace(regex("^\(bBreak)"), template: "")
Tokenizer.swift:205
              |> replace(regex("\(bBreak) {0,\(lastIndent)}"), template: "\n")
Tokenizer.swift:206
            ) + (matches(text, regex: regex("^\(bBreak)")) && lead.endIndex > lead.startIndex
Tokenizer.swift:216
          let blockPattern = regex(("^\(bBreak)( *| {\(indent),}" +
Tokenizer.swift:217
              "\(plainOutPattern))(?=\(bBreak)|$)"))
Tokenizer.swift:229
                replace(regex("^\(bBreak)[ \\t]*|[ \\t]+$"), template: "")(s)
 = "(?:\\r\\n|\\r|\\n)"
0057    
0058    // printable non-space chars,
0059    // except `:`(3a), `#`(23), `,`(2c), `[`(5b), `]`(5d), `{`(7b), `}`(7d)
0060    let safeIn
Tokenizer.swift:64
let safeOut = "\\x2c\\x5b\\x5d\\x7b\\x7d" + safeIn
Tokenizer.swift:68
    "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+"
Tokenizer.swift:68
    "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+"
 = "\\x21\\x22\\x24-\\x2b\\x2d-\\x39\\x3b-\\x5a\\x5c\\x5e-\\x7a" +
0061        "\\x7c\\x7e\\x85\\xa0-\\ud7ff\\ue000-\\ufefe\\uff00\\ufffd" +
0062        "\\U00010000-\\U0010ffff"
0063    // with flow indicators: `,`, `[`, `]`, `{`, `}`
0064    let safeOut
Tokenizer.swift:66
    "([\(safeOut)]#|:(?![ \\t]|\(bBreak))|[\(safeOut)]|[ \\t])+"
Tokenizer.swift:66
    "([\(safeOut)]#|:(?![ \\t]|\(bBreak))|[\(safeOut)]|[ \\t])+"
 = "\\x2c\\x5b\\x5d\\x7b\\x7d" + safeIn
0065    let plainOutPattern
Tokenizer.swift:105
  (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
Tokenizer.swift:217
              "\(plainOutPattern))(?=\(bBreak)|$)"))
 =
0066        "([\(safeOut)]#|:(?![ \\t]|\(bBreak))|[\(safeOut)]|[ \\t])+"
0067    let plainInPattern
Tokenizer.swift:106
  (.StringFI, regex("^\(plainInPattern)")),
 =
0068        "([\(safeIn)]#|:(?![ \\t]|\(bBreak))|[\(safeIn)]|[ \\t]|\(bBreak))+"
0069    let dashPattern
Tokenizer.swift:78
  (.Dash, dashPattern),
Tokenizer.swift:137
                matches(text |> substringFromIndex(rangeEnd), regex: dashPattern)
 = regex("^-([ \\t]+(?!#|\(bBreak))|(?=[ \\t\\n]))")
0070    let finish
Tokenizer.swift:79
  (.Null, regex("^(null|Null|NULL|~)\(finish)")),
Tokenizer.swift:80
  (.True, regex("^(true|True|TRUE)\(finish)")),
Tokenizer.swift:81
  (.False, regex("^(false|False|FALSE)\(finish)")),
Tokenizer.swift:82
  (.InfinityP, regex("^\\+?\\.(inf|Inf|INF)\(finish)")),
Tokenizer.swift:83
  (.InfinityN, regex("^-\\.(inf|Inf|INF)\(finish)")),
Tokenizer.swift:84
  (.NaN, regex("^\\.(nan|NaN|NAN)\(finish)")),
Tokenizer.swift:85
  (.Int, regex("^[-+]?[0-9]+\(finish)")),
Tokenizer.swift:86
  (.IntOct, regex("^0o[0-7]+\(finish)")),
Tokenizer.swift:87
  (.IntHex, regex("^0x[0-9a-fA-F]+\(finish)")),
Tokenizer.swift:88
  (.IntSex, regex("^[0-9]{2}(:[0-9]{2})+\(finish)")),
Tokenizer.swift:89
  (.Double, regex("^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?\(finish)")),
 = "(?= *(,|\\]|\\}|( #.*)?(\(bBreak)|$)))"
0071    let tokenPatterns
Tokenizer.swift:125
    for tokenPattern in tokenPatterns {
: [TokenPattern] = [
0072      (.YamlDirective, regex("^%YAML(?= )")),
0073      (.DocStart, regex("^---")),
0074      (.DocEnd, regex("^\\.\\.\\.")),
0075      (.Comment, regex("^#.*|^\(bBreak) *(#.*)?(?=\(bBreak)|$)")),
0076      (.Space, regex("^ +")),
0077      (.NewLine, regex("^\(bBreak) *")),
0078      (.Dash, dashPattern),
0079      (.Null, regex("^(null|Null|NULL|~)\(finish)")),
0080      (.True, regex("^(true|True|TRUE)\(finish)")),
0081      (.False, regex("^(false|False|FALSE)\(finish)")),
0082      (.InfinityP, regex("^\\+?\\.(inf|Inf|INF)\(finish)")),
0083      (.InfinityN, regex("^-\\.(inf|Inf|INF)\(finish)")),
0084      (.NaN, regex("^\\.(nan|NaN|NAN)\(finish)")),
0085      (.Int, regex("^[-+]?[0-9]+\(finish)")),
0086      (.IntOct, regex("^0o[0-7]+\(finish)")),
0087      (.IntHex, regex("^0x[0-9a-fA-F]+\(finish)")),
0088      (.IntSex, regex("^[0-9]{2}(:[0-9]{2})+\(finish)")),
0089      (.Double, regex("^[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?\(finish)")),
0090      (.Anchor, regex("^&\\w+")),
0091      (.Alias, regex("^\\*\\w+")),
0092      (.Comma, regex("^,")),
0093      (.OpenSB, regex("^\\[")),
0094      (.CloseSB, regex("^\\]")),
0095      (.OpenCB, regex("^\\{")),
0096      (.CloseCB, regex("^\\}")),
0097      (.QuestionMark, regex("^\\?( +|(?=\(bBreak)))")),
0098      (.ColonFO, regex("^:(?!:)")),
0099      (.ColonFI, regex("^:(?!:)")),
0100      (.Literal, regex("^\\|.*")),
0101      (.Folded, regex("^>.*")),
0102      (.Reserved, regex("^[@`]")),
0103      (.StringDQ, regex("^\"([^\\\\\"]|\\\\(.|\(bBreak)))*\"")),
0104      (.StringSQ, regex("^'([^']|'')*'")),
0105      (.StringFO, regex("^\(plainOutPattern)(?=:([ \\t]|\(bBreak))|\(bBreak)|$)")),
0106      (.StringFI, regex("^\(plainInPattern)")),
0107    ]
0108    
0109    func escapeErrorContext
Parser.swift:102
    let text = recreateText("", context: context) |> escapeErrorContext
Tokenizer.swift:242
          return fail(escapeErrorContext(text))
Tokenizer.swift:251
    return fail(escapeErrorContext(text))
 (text: String) -> String {
0110      let endIndex = text.startIndex.advancedBy(50, limit: text.endIndex)
0111      let escaped = text.substringToIndex(endIndex)
0112          |> replace(regex("\\r"), template: "\\\\r")
0113          |> replace(regex("\\n"), template: "\\\\n")
0114          |> replace(regex("\""), template: "\\\\\"")
0115      return "near \"\(escaped)\""
0116    }
0117    
0118    func tokenize
Yaml.swift:99
    return tokenize(text) >>=- parseDoc
Yaml.swift:103
    return tokenize(text) >>=- parseDocs
Yaml.swift:107
    let result = tokenize(text)
Yaml.swift:118
    let result = tokenize(text)
 (text: String) -> Result<[TokenMatch]> {
0119      var text = text
0120      var matchList: [TokenMatch] = []
0121      var indents = [0]
0122      var insideFlow = 0
0123      next:
0124      while text.endIndex > text.startIndex {
0125        for tokenPattern in tokenPatterns {
0126          let range = matchRange(text, regex: tokenPattern.pattern)
0127          if range.location != NSNotFound {
0128            let rangeEnd = range.location + range.length
0129            switch tokenPattern.type {
0130    
0131            case .NewLine:
0132              let match = text |> substringWithRange(range)
0133              let lastIndent = indents.last ?? 0
0134              let rest = match.substringFromIndex(match.startIndex.successor())
0135              let spaces = rest.characters.count
0136              let nestedBlockSequence =
0137                    matches(text |> substringFromIndex(rangeEnd), regex: dashPattern)
0138              if spaces == lastIndent {
0139                matchList.append(TokenMatch(.NewLine, match))
0140              } else if spaces > lastIndent {
0141                if insideFlow == 0 {
0142                  if matchList.last != nil &&
0143                      matchList[matchList.endIndex - 1].type == .Indent {
0144                    indents[indents.endIndex - 1] = spaces
0145                    matchList[matchList.endIndex - 1] = TokenMatch(.Indent, match)
0146                  } else {
0147                    indents.append(spaces)
0148                    matchList.append(TokenMatch(.Indent, match))
0149                  }
0150                }
0151              } else if nestedBlockSequence && spaces == lastIndent - 1 {
0152                matchList.append(TokenMatch(.NewLine, match))
0153              } else {
0154                while nestedBlockSequence && spaces < (indents.last ?? 0) - 1
0155                    || !nestedBlockSequence && spaces < indents.last {
0156                  indents.removeLast()
0157                  matchList.append(TokenMatch(.Dedent, ""))
0158                }
0159                matchList.append(TokenMatch(.NewLine, match))
0160              }
0161    
0162            case .Dash, .QuestionMark:
0163              let match = text |> substringWithRange(range)
0164              let index = match.startIndex.successor()
0165              let indent = match.characters.count
0166              indents.append((indents.last ?? 0) + indent)
0167              matchList.append(
0168                  TokenMatch(tokenPattern.type, match.substringToIndex(index)))
0169              matchList.append(TokenMatch(.Indent, match.substringFromIndex(index)))
0170    
0171            case .ColonFO:
0172              if insideFlow > 0 {
0173                continue
0174              }
0175              fallthrough
0176    
0177            case .ColonFI:
0178              let match = text |> substringWithRange(range)
0179              matchList.append(TokenMatch(.Colon, match))
0180              if insideFlow == 0 {
0181                indents.append((indents.last ?? 0) + 1)
0182                matchList.append(TokenMatch(.Indent, ""))
0183              }
0184    
0185            case .OpenSB, .OpenCB:
0186              insideFlow += 1
0187              matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
0188    
0189            case .CloseSB, .CloseCB:
0190              insideFlow -= 1
0191              matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
0192    
0193            case .Literal, .Folded:
0194              matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
0195              text = text |> substringFromIndex(rangeEnd)
0196              let lastIndent = indents.last ?? 0
0197              let minIndent = 1 + lastIndent
0198              let blockPattern = regex(("^(\(bBreak) *)*(\(bBreak)" +
0199                  "( {\(minIndent),})[^ ].*(\(bBreak)( *|\\3.*))*)(?=\(bBreak)|$)"))
0200              let (lead, rest) = text |> splitLead(blockPattern)
0201              text = rest
0202              let block = (lead
0203                  |> replace(regex("^\(bBreak)"), template: "")
0204                  |> replace(regex("^ {0,\(lastIndent)}"), template: "")
0205                  |> replace(regex("\(bBreak) {0,\(lastIndent)}"), template: "\n")
0206                ) + (matches(text, regex: regex("^\(bBreak)")) && lead.endIndex > lead.startIndex
0207                  ? "\n" : "")
0208              matchList.append(TokenMatch(.String, block))
0209              continue next
0210    
0211            case .StringFO:
0212              if insideFlow > 0 {
0213                continue
0214              }
0215              let indent = (indents.last ?? 0)
0216              let blockPattern = regex(("^\(bBreak)( *| {\(indent),}" +
0217                  "\(plainOutPattern))(?=\(bBreak)|$)"))
0218              var block = text
0219                    |> substringWithRange(range)
0220                    |> replace(regex("^[ \\t]+|[ \\t]+$"), template: "")
0221              text = text |> substringFromIndex(rangeEnd)
0222              while true {
0223                let range = matchRange(text, regex: blockPattern)
0224                if range.location == NSNotFound {
0225                  break
0226                }
0227                let s = text |> substringWithRange(range)
0228                block += "\n" +
0229                    replace(regex("^\(bBreak)[ \\t]*|[ \\t]+$"), template: "")(s)
0230                text = text |> substringFromIndex(range.location + range.length)
0231              }
0232              matchList.append(TokenMatch(.String, block))
0233              continue next
0234    
0235            case .StringFI:
0236              let match = text
0237                    |> substringWithRange(range)
0238                    |> replace(regex("^[ \\t]|[ \\t]$"), template: "")
0239              matchList.append(TokenMatch(.String, match))
0240    
0241            case .Reserved:
0242              return fail(escapeErrorContext(text))
0243    
0244            default:
0245              matchList.append(TokenMatch(tokenPattern.type, text |> substringWithRange(range)))
0246            }
0247            text = text |> substringFromIndex(rangeEnd)
0248            continue next
0249          }
0250        }
0251        return fail(escapeErrorContext(text))
0252      }
0253      while indents.count > 1 {
0254        indents.removeLast()
0255        matchList.append((.Dedent, ""))
0256      }
0257      matchList.append((.End, ""))
0258      return lift(matchList)
0259    }
0260