     }
 
     // instance methods
-    func startOfLine(enabled: Bool = true) -> Self {
+    public func startOfLine(enabled: Bool = true) -> Self {
         prefixes = enabled ? "^" : ""
 
         return self
     }
 
-    func endOfLine(enabled: Bool = true) -> Self {
+    public func endOfLine(enabled: Bool = true) -> Self {
         suffixes = enabled ? "$" : ""
 
         return self
     }
 
-    func then(string: String) -> Self {
+    public func then(string: String) -> Self {
         return add("(?:\(sanitize(string)))")
     }
 
     // alias for then
-    func find(string: String) -> Self {
+    public func find(string: String) -> Self {
         return then(string)
     }
 
-    func maybe(string: String) -> Self {
+    public func maybe(string: String) -> Self {
         return add("(?:\(sanitize(string)))?")
     }
     
-    func anything() -> Self {
+    public func anything() -> Self {
         return add("(?:.*)")
     }
     
-    func anythingBut(string: String) -> Self {
+    public func anythingBut(string: String) -> Self {
         return add("(?:[^\(sanitize(string))]*)")
     }
 
-    func something() -> Self {
+    public func something() -> Self {
         return add("(?:.+)")
     }
 
-    func somethingBut(string: String) -> Self {
+    public func somethingBut(string: String) -> Self {
         return add("(?:[^\(sanitize(string))]+)")
     }
 
-    func lineBreak() -> Self {
+    public func lineBreak() -> Self {
         return add("(?:(?:\n)|(?:\r\n))")
     }
 
     // alias for lineBreak
-    func br() -> Self {
+    public func br() -> Self {
         return lineBreak()
     }
 
-    func tab() -> Self {
+    public func tab() -> Self {
         return add("\t")
     }
 
-    func word() -> Self {
+    public func word() -> Self {
         return add("\\w+")
     }
     
-    func anyOf(string: String) -> Self {
+    public func anyOf(string: String) -> Self {
         return add("(?:[\(sanitize(string))])")
     }
     
     // alias for anyOf
-    func any(string: String) -> Self {
+    public func any(string: String) -> Self {
         return anyOf(string)
     }
 
-    func withAnyCase(enabled: Bool = true) -> Self {
+    public func withAnyCase(enabled: Bool = true) -> Self {
         if enabled {
             return addModifier("i")
         }

        
        let regex = NSRegularExpression(pattern: pattern, options: options, error: &error)
        
        if error {
            return nil
        }
        

        }
    }
    
    public func beginCapture() -> Self {
        suffixes += ")"
        
        return add("(")
    }
    
    public func endCapture() -> Self {
        suffixes = suffixes[suffixes.startIndex..<suffixes.endIndex.predecessor()]
        
        return add(")")
    }
    
    public func replace(string: String, template: String) -> String {
        let range = NSRange(location: 0, length: count(string))
        
        return regularExpression.stringByReplacingMatchesInString(string, options: nil, range: range, withTemplate: template)
    }
    
    public func replace(string: String, with: String) -> String {
        let range = NSRange(location: 0, length: count(string))
        let template = NSRegularExpression.escapedTemplateForString(with)
        
        return regularExpression.stringByReplacingMatchesInString(string, options: nil, range: range, withTemplate: template)
    }
    
    public func test(string: String) -> Bool {
        let range = NSRange(location: 0, length: count(string))
        
        if let result = regularExpression.firstMatchInString(string, options: nil, range: range) {
            return result.range.location != NSNotFound
