         switch typec {
           case sStart: // #
             let s = String.fromCString(marker + 1, length: len - 1)!
-            return .SectionStart(s)
+            return .sectionStart(s)
   
           case isStart: // ^
             let s = String.fromCString(marker + 1, length: len - 1)!
-            return .InvertedSectionStart(s)
+            return .invertedSectionStart(s)
   
           case sEnd: // /
             let s = String.fromCString(marker + 1, length: len - 1)!
-            return .SectionEnd(s)
+            return .sectionEnd(s)
             
           case pStart: // >
             var n = marker + 1 // skip >
             while n.pointee == 32 { n += 1 } // skip spaces
             let len = p! - n - 2
             let s = String.fromCString(n, length: len)!
-            return .Partial(s)
+            return .partial(s)
 
           case ueStart /* & */:
             if (marker + 1).pointee == 32 {
               let s = String.fromCString(marker + 2, length: len - 2)!
-              return .UnescapedTag(s)
+              return .unescapedTag(s)
             }
             fallthrough
           
           default:
             let s = String.fromCString(marker, length: len)!
-            return .Tag(s)
+            return .tag(s)
         }
       }
       
       p = p! + 1
     }
     
-    return .Text(String(cString: start))
+    return .text(String(cString: start))
   }
   
   mutating private func parseText() -> String {

    guard let token = parseTagOrText() else { return nil }
    
    switch token {
      case .Text        (let s): return .text(s)
      case .Tag         (let s): return .tag(s)
      case .UnescapedTag(let s): return .unescapedTag(s)
      case .Partial     (let s): return .partial(s)
      
      case .SectionStart(let s):
        guard let children = parseNodes(section: s) else { return .empty }
        return .section(s, children)
      
      case .InvertedSectionStart(let s):
        guard let children = parseNodes(section: s) else { return .empty }
        return .invertedSection(s, children)
      
      case .SectionEnd(let s):
        if !s.isEmpty && s != se {
          print("section tags not balanced: \(s) expected \(se as Optional)")
        }

        if isUnescaped {
          p = p! + 3 // skip }}}
          let s = String.fromCString(marker, length: len)!
          return .unescapedTag(s)
        }
        
        p = p! + 2 // skip }}
