         self = .ObjectValue(object)
     }
 }
+
+// MARK: HELPERS
+
+
+// TODO: Break Out
+extension Bool {
+    /**
+     This function seeks to replicate the expected behavior of `var boolValue: Bool` on `NSString`.  Any variant of `yes`, `y`, `true`, `t`, or any numerical value greater than 0 will be considered `true`
+     */
+    public init(_ string: String) {
+        let cleaned = string
+            .lowercased()
+            .characters
+            .first ?? "n"
+        
+        switch cleaned {
+        case "t", "y", "1":
+            self = true
+        default:
+            if let int = Int(String(cleaned)) where int > 0 {
+                self = true
+            } else {
+                self = false
+            }
+            
+        }
+    }
+}
+
+//extension String {
+//    /**
+//     Parses `key=value` pair data separated by `&`.
+//     
+//     - returns: String dictionary of parsed data
+//     */
+//    internal func keyValuePairs() -> [String: String]? {
+//        var data: [String: String] = [:]
+//        
+//        for pair in self.split("&") {
+//            let tokens = pair.split("=", maxSplits: 1)
+//            
+//            if
+//                let name = tokens.first,
+//                let value = tokens.last,
+//                let parsedName = try? String(percentEncoded: name) {
+//                data[parsedName] = try? String(percentEncoded: value)
+//            }
+//        }
+//        
+//        return data.isEmpty ? nil : data
+//    }
+//}
+//
+//// FROM: Zewo - String
+//
+//extension String {
+//    public func split(separator: Character, maxSplits: Int = .max, omittingEmptySubsequences: Bool = true) -> [String] {
+//        return characters.split(separator: separator, maxSplits: maxSplits, omittingEmptySubsequences: omittingEmptySubsequences).map(String.init)
+//    }
+//    
+//    public init(percentEncoded: String) throws {
+//        struct Error: ErrorProtocol, CustomStringConvertible {
+//            let description: String
+//        }
+//        
+//        let spaceCharacter: UInt8 = 32
+//        let percentCharacter: UInt8 = 37
+//        let plusCharacter: UInt8 = 43
+//        
+//        var encodedBytes: [UInt8] = [] + percentEncoded.utf8
+//        var decodedBytes: [UInt8] = []
+//        var i = 0
+//        
+//        while i < encodedBytes.count {
+//            let currentCharacter = encodedBytes[i]
+//            
+//            switch currentCharacter {
+//            case percentCharacter:
+//                let unicodeA = UnicodeScalar(encodedBytes[i + 1])
+//                let unicodeB = UnicodeScalar(encodedBytes[i + 2])
+//                
+//                let hexString = "\(unicodeA)\(unicodeB)"
+//                
+//                
+//                
+//                guard let character = Int(hexString, radix: 16) else {
+//                    throw Error(description: "Invalid string")
+//                }
+//                
+//                decodedBytes.append(UInt8(character))
+//                i += 3
+//                
+//            case plusCharacter:
+//                decodedBytes.append(spaceCharacter)
+//                i += 1
+//                
+//            default:
+//                decodedBytes.append(currentCharacter)
+//                i += 1
+//            }
+//        }
+//        
+//        var string = ""
+//        var decoder = UTF8()
+//        var iterator = decodedBytes.makeIterator()
+//        var finished = false
+//        
+//        while !finished {
+//            let decodingResult = decoder.decode(&iterator)
+//            switch decodingResult {
+//            case .scalarValue(let char): string.append(char)
+//            case .emptyInput: finished = true
+//            case .error:
+//                throw Error(description: "UTF-8 decoding failed")
+//            }
+//        }
+//        
+//        self.init(string)
+//    }
+//}
        return number
    }
    
    public var floatValue: Float? {
        return numberValue.flatMap(Float.init)
    }

//  Copyright (c) 2014 Fuji Goro. All rights reserved.
//

public enum TypeEnforcing {
    case strict
    case fuzzy
    
    public var isStrict: Bool {
        return self == .strict
    }
    
    public var isFuzzy: Bool {
        return self == .fuzzy
    }
}

public var TypeEnforcingLevel: TypeEnforcing = .strict

public enum Node {
    case NullValue
    case BooleanValue(Bool)
