     return out
 }
 
-private func vector (type: SVGCommand.Kind) -> SVGCommandBuilder {
-    func build (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
-        return take(numbers, 2, lastCommand) {
-            (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
-            return SVGCommand(pointAtIndex(nums, 0), type: type)
-        }
-    }
-    return build
-}
-
-private func scalar (direction: Direction) -> SVGCommandBuilder {
-    func build (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
-        return take(numbers, 1, lastCommand) {
-            (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
-
-            var point:CGPoint = CGPoint()
-            
-            if coords == .Absolute {
-                point = last?.point ?? point
-            }
-            
-            if direction == .Vertical {
-                point.y = nums[0]
-            } else {
-                point.x = nums[0]
-            }
-            
-            return SVGCommand(point, type: .Line)
-        }
-    }
-    return build
-}
+// MARK: Mm - Move
+
+private func moveTo (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
+    return take(numbers, 2, lastCommand) {
+        (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
+        return SVGCommand(pointAtIndex(nums, 0), type: .Move)
+    }
+}
+
+// MARK: Ll - Line
+
+private func lineTo (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
+    return take(numbers, 2, lastCommand) {
+        (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
+        return SVGCommand(pointAtIndex(nums, 0), type: .Line)
+    }
+}
+
+// MARK: Vv - Vertical Line
+
+private func lineToVertical (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
+    return take(numbers, 1, lastCommand) {
+        (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
+        var point:CGPoint = CGPoint(x: 0, y: nums[0])
+        
+        if coords == .Absolute {
+            point.x = last?.point.x ?? 0
+        }
+        
+        return SVGCommand(point, type: .Line)
+    }
+}
+
+// MARK: Hh - Horizontal Line
+
+private func lineToHorizontal (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
+    return take(numbers, 1, lastCommand) {
+        (nums:Slice<CGFloat>, last: SVGCommand?) -> SVGCommand in
+        var point:CGPoint = CGPoint(x: nums[0], y: 0)
+        
+        if coords == .Absolute {
+            point.y = last?.point.y ?? 0
+        }
+        
+        return SVGCommand(point, type: .Line)
+    }
+}
+
+// MARK: Qq - Quadratic Curve To
 
 private func quadBroken (numbers: [CGFloat], lastCommand: SVGCommand?, coords: Coordinates) -> [SVGCommand] {
     return take(numbers, 4, lastCommand) {

    public init (_ string: String) {
        for char in string {
            switch char {
            case "M": use(vector(.Move), .Absolute)
            case "m": use(vector(.Move), .Relative)
            case "L": use(vector(.Line), .Absolute)
            case "l": use(vector(.Line), .Relative)
            case "V": use(scalar(.Vertical), .Absolute)
            case "v": use(scalar(.Vertical), .Relative)
            case "H": use(scalar(.Horizontal), .Absolute)
            case "h": use(scalar(.Horizontal), .Relative)
            case "Q": use(quadBroken, .Absolute)
            case "q": use(quadBroken, .Relative)
            case "T": use(quadSmooth, .Absolute)
            case "t": use(quadSmooth, .Relative)
            default: numbers.append(char)
            }
        }
        finishLastCommand()
    }
    
    private func use (builder: SVGCommandBuilder, _ coords: Coordinates) {
        finishLastCommand()
        self.builder = builder
        self.coords = coords

    case Relative
}

// MARK: Class

public class SVGPath {
