fix crash with realloc call being incorrect

- concat gradients and applying a single one does not work for some reason, however, applying each one individually into the context works

.gitignore

@@ -0,0 +1 @@
+.DS_Store

Framework/IJSVG/IJSVG.modulemap

@@ -0,0 +1,5 @@
+framework module IJSVG {
+    umbrella header "IJSVGUmbrella.h"
+    export *
+    module * { export * } 
+}

Framework/IJSVG/IJSVG.xcodeproj/xcshareddata/xcschemes/IJSVG.xcscheme

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Scheme
-   LastUpgradeVersion = "1120"
+   LastUpgradeVersion = "1600"
    version = "1.3">
    <BuildAction
       parallelizeBuildables = "YES"

Framework/IJSVG/IJSVG.xcodeproj/xcuserdata/curtishard.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -7,7 +7,7 @@
 		<key>IJSVG.xcscheme_^#shared#^_</key>
 		<dict>
 			<key>orderHint</key>
-			<integer>1</integer>
+			<integer>2</integer>
 		</dict>
 	</dict>
 	<key>SuppressBuildableAutocreation</key>
@@ -15,7 +15,7 @@
 		<key>594CF46E238FF38E009B251B</key>
 		<dict>
 			<key>primary</key>
-			<true/>
+			<true />
 		</dict>
 	</dict>
 </dict>

Framework/IJSVG/IJSVG/Info.plist

@@ -19,6 +19,6 @@
 	<key>CFBundleVersion</key>
 	<string>$(CURRENT_PROJECT_VERSION)</string>
 	<key>NSHumanReadableCopyright</key>
-	<string>Copyright © 2019 Curtis Hard. All rights reserved.</string>
+	<string>Copyright © 2020 Curtis Hard. All rights reserved.</string>
 </dict>
 </plist>

Framework/IJSVG/IJSVG/Source/Additions/IJSVGStringAdditions.h

@@ -10,9 +10,10 @@
 
 @interface NSString (IJSVGAdditions)
 
-- (NSArray<NSString *> *)ijsvg_componentsSeparatedByChars:(char *)aChar;
+- (NSArray<NSString*>*)ijsvg_componentsSeparatedByChars:(const char*)aChar;
 - (BOOL)ijsvg_isNumeric;
 - (BOOL)ijsvg_containsAlpha;
 - (NSArray*)ijsvg_componentsSplitByWhiteSpace;
+- (BOOL)ijsvg_isHexString;
 
 @end

Framework/IJSVG/IJSVG/Source/Additions/IJSVGStringAdditions.m

@@ -0,0 +1,71 @@
+//
+//  IJSVGStringAdditions.m
+//  IconJar
+//
+//  Created by Curtis Hard on 07/06/2019.
+//  Copyright © 2019 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGStringAdditions.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation NSString (IJSVGAdditions)
+
+- (NSArray<NSString*>*)ijsvg_componentsSeparatedByChars:(const char*)aChar
+{
+    char* chars = (char*)self.UTF8String;
+    if(chars == NULL || strlen(chars) == 0) {
+        return @[];
+    }
+    NSMutableArray<NSString*>* strings = nil;
+    strings = [[NSMutableArray alloc] init];
+    char* copy = strdup(chars);
+    char* spt = NULL;
+    char* ptr = strtok_r(copy, aChar, &spt);
+    while(ptr != NULL) {
+        NSString* possibleString = nil;
+        if((possibleString = [NSString stringWithUTF8String:ptr]) != nil) {
+            [strings addObject:possibleString];
+        }
+        ptr = strtok_r(NULL, aChar, &spt);
+    }
+    (void)free(copy), copy = NULL;
+    return strings;
+}
+
+- (BOOL)ijsvg_containsAlpha
+{
+    const char* buffer = self.UTF8String;
+    char currentChar;
+    while((currentChar = *buffer++) ) {
+        if(isalpha(currentChar)) {
+            return YES;
+        }
+    }
+    return NO;
+}
+
+- (BOOL)ijsvg_isNumeric
+{
+    const char* buffer = self.UTF8String;
+    char currentChar;
+    while((currentChar = *buffer++) ) {
+        if(!isnumber(currentChar)) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+- (NSArray*)ijsvg_componentsSplitByWhiteSpace
+{
+    return [self ijsvg_componentsSeparatedByChars:"\t\n\r "];
+}
+
+- (BOOL)ijsvg_isHexString
+{
+    const char* chars = self.UTF8String;
+    return IJSVGCharBufferIsHEX((char*)chars);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Additions/NSImage+IJSVGAdditions.h

@@ -0,0 +1,18 @@
+//
+//  NSImage+IJSVGAdditions.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 07/06/2020.
+//  Copyright © 2020 Curtis Hard. All rights reserved.
+//
+
+#import <AppKit/AppKit.h>
+#import <Cocoa/Cocoa.h>
+
+IJSVG* IJSVGGetFromNSImage(NSImage* image);
+
+@interface NSImage (IJSVGAdditions)
+
++ (NSImage*)SVGImageNamed:(NSString*)imageName;
+
+@end

Framework/IJSVG/IJSVG/Source/Additions/NSImage+IJSVGAdditions.m

@@ -0,0 +1,53 @@
+//
+//  NSImage+IJSVGAdditions.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 07/06/2020.
+//  Copyright © 2020 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGImageRep.h>
+#import <IJSVG/NSImage+IJSVGAdditions.h>
+
+IJSVG* IJSVGGetFromNSImage(NSImage* image)
+{
+    for (NSImageRep* rep in image.representations) {
+        if([rep isKindOfClass:IJSVGImageRep.class]) {
+            return ((IJSVGImageRep*)rep).SVG;
+        }
+    }
+    return nil;
+}
+
+@implementation NSImage (IJSVGAdditions)
+
++ (NSImage*)SVGImageNamed:(NSString*)imageName
+{
+    // find the image
+    NSBundle* bundle = NSBundle.mainBundle;
+    NSString* str = nil;
+    NSString* ext = imageName.pathExtension;
+    if(ext == nil || ext.length == 0) {
+        ext = @"svg";
+    }
+
+    if((str = [bundle pathForResource:imageName.stringByDeletingPathExtension
+                                ofType:ext])
+        != nil) {
+
+        // work out if we can get the data
+        NSData* data = [[NSData alloc] initWithContentsOfFile:str];
+        if(data == nil) {
+            return nil;
+        }
+
+        // grab the image rep
+        IJSVGImageRep* rep = [[IJSVGImageRep alloc] initWithData:data];
+        NSImage* image = [[NSImage alloc] init];
+        [image addRepresentation:rep];
+        return image;
+    }
+    return nil;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Colors/IJSVGColor.h

@@ -167,6 +167,8 @@ typedef NS_ENUM(NSInteger, IJSVGPredefinedColor) {
     IJSVGColorYellowgreen
 };
 
+extern NSString* const IJSVGColorCurrentColorName;
+
 @interface IJSVGColor : NSObject
 
 CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightness);
@@ -179,6 +181,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 + (NSString*)colorStringFromColor:(NSColor*)color;
 + (NSColor*)colorFromHEXInteger:(NSInteger)hex;
 + (NSColor*)computeColor:(id)colour;
++ (BOOL)isNoneOrTransparent:(NSString*)string;
 + (NSColor*)colorFromString:(NSString*)string;
 + (NSColor*)colorFromHEXString:(NSString*)string;
 + (NSColor*)colorFromHEXString:(NSString*)string

Framework/IJSVG/IJSVG/Source/Colors/IJSVGColor.m

@@ -6,13 +6,19 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGColor.h"
-#import "IJSVGUtils.h"
+#import <IJSVG/IJSVGColor.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <IJSVG/IJSVGStringAdditions.h>
+#import <IJSVG/IJSVGParsing.h>
+#import <IJSVG/IJSVGParser.h>
+
+NSString* const IJSVGColorCurrentColorName = @"currentColor";
 
 @implementation IJSVGColor
 
 static NSDictionary* _colorTree = nil;
 
+
 CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightness)
 {
     hue *= (1.f / 360.f);
@@ -23,7 +29,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 
     CGFloat s = saturation * ((lightness < 1.f) ? lightness : (2.f - lightness));
     CGFloat brightness = (lightness + s) * .5f;
-    if (s != 0.f) {
+    if(s != 0.f) {
         s = (2.f * s) / (lightness + s);
     }
     CGFloat* floats = (CGFloat*)malloc(3 * sizeof(CGFloat));
@@ -46,7 +52,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 + (NSColor*)computeColorSpace:(NSColor*)color
 {
     NSColorSpace* space = [self defaultColorSpace];
-    if (color.colorSpace != space) {
+    if(color.colorSpace != space) {
         color = [color colorUsingColorSpace:space];
     }
     return color;
@@ -56,7 +62,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 {
     static dispatch_once_t onceToken;
     dispatch_once(&onceToken, ^{
-        _colorTree = [@{
+        _colorTree = @{
             @"aliceblue" : @(0xf0f8ff),
             @"antiquewhite" : @(0xfaebd7),
             @"aqua" : @(0x00ffff),
@@ -202,13 +208,13 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
             @"whitesmoke" : @(0xf5f5f5),
             @"yellow" : @(0xffff00),
             @"yellowgreen" : @(0x9acd32)
-        } retain];
+        };
     });
 }
 
 + (NSColor*)computeColor:(id)colour
 {
-    if ([colour isKindOfClass:[NSColor class]])
+    if([colour isKindOfClass:[NSColor class]])
         return colour;
     return nil;
 }
@@ -239,38 +245,71 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
                                                          alpha:a]];
 }
 
++ (BOOL)isNoneOrTransparent:(NSString*)string
+{
+    const char* str = string.UTF8String;
+    return IJSVGCharBufferCaseInsensitiveCompare(str, "none") == YES ||
+        IJSVGCharBufferCaseInsensitiveCompare(str, "transparent") == YES;
+}
+
 + (NSColor*)colorFromString:(NSString*)string
 {
-    NSCharacterSet* set = NSCharacterSet.whitespaceAndNewlineCharacterSet;
-    string = [string stringByTrimmingCharactersInSet:set];
-
-    if ([string length] < 3) {
+    // swap over to C for performance
+    if(string == nil) {
         return nil;
     }
-
-    NSColor* color = nil;
-    string = [string lowercaseString];
-    if ([self.class isHex:string] == NO) {
-        color = [self.class colorFromPredefinedColorName:string];
-        if (color != nil) {
-            return color;
-        }
+    
+    const char* oString = string.UTF8String;
+    if(strlen(oString) == 0) {
+        return nil;
     }
-
-    // is simply a clear color, dont fill
-    if ([[string lowercaseString] isEqualToString:@"none"]) {
-        return [self computeColorSpace:NSColor.clearColor];
+    
+    char* str = IJSVGTimmedCharBufferCreate(oString);
+    if(IJSVGCharBufferIsHEX(str) == YES) {
+        string = [NSString stringWithUTF8String:str];
+        (void)free(str), str = NULL;
+        return [self.class colorFromHEXString:string];
     }
 
     // is it RGB?
-    if ([[string substringToIndex:3] isEqualToString:@"rgb"]) {
-        NSRange range = [IJSVGUtils rangeOfParentheses:string];
-        NSString* rgbString = [string substringWithRange:range];
-        NSArray* parts = [rgbString ijsvg_componentsSeparatedByChars:","];
+    if(IJSVGCharBufferHasPrefix(str, "rgb") == YES) {
+        NSUInteger count = 0;
+        IJSVGParsingStringMethod** methods = NULL;
+        methods = IJSVGParsingMethodParseString(str, &count);
+        IJSVGParsingStringMethod* method = methods[0];
+        
+        // memory clean for the string
+        (void)free(str), str = NULL;
+        
+        // nothing to return, just mem clean and get out of here
+        if(count == 0 || methods == NULL) {
+            if(methods != NULL) {
+                IJSVGParsingStringMethodsRelease(methods, count);
+                methods = NULL;
+            }
+            return nil;
+        }
+        
+        // Make sure we have actual floats within the parameters
+        NSInteger floatCount = 0;
+        CGFloat *params = [IJSVGUtils scanFloatsFromCString:method->parameters
+                                                       size:&floatCount];
+        (void)free(params), params = NULL;
+        if(floatCount < 3) {
+            return [self computeColorSpace:NSColor.blackColor];
+        }
+        
+        // Make sure the floats are not negative
+        // parse the parameters
+        NSString* parameters = [NSString stringWithUTF8String:method->parameters];
+        NSArray* parts = [parameters ijsvg_componentsSeparatedByChars:","];
         NSString* alpha = @"100%";
-        if (parts.count == 4) {
+        if(parts.count == 4) {
             alpha = parts[3];
         }
+        
+        IJSVGParsingStringMethodsRelease(methods, count);
+        methods = NULL;
         return [self colorFromRString:parts[0]
                               gString:parts[1]
                               bString:parts[2]
@@ -278,39 +317,48 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
     }
 
     // is it HSL?
-    if ([[string substringToIndex:3] isEqualToString:@"hsl"]) {
+    if(IJSVGCharBufferHasPrefix(str, "hsl")) {
         NSInteger count = 0;
-        CGFloat* params = [IJSVGUtils commandParameters:string
-                                                  count:&count];
+        CGFloat* params = [IJSVGUtils scanFloatsFromCString:str
+                                                       size:&count];
         CGFloat alpha = 1;
-        if (count == 4) {
+        if(count == 4) {
             alpha = params[3];
         }
 
         // convert HSL to HSB
         CGFloat* hsb = IJSVGColorCSSHSLToHSB(params[0], params[1], params[2]);
-        color = [NSColor colorWithDeviceHue:hsb[0]
-                                 saturation:hsb[1]
-                                 brightness:hsb[2]
-                                      alpha:alpha];
+        NSColor* color = [NSColor colorWithDeviceHue:hsb[0]
+                                          saturation:hsb[1]
+                                          brightness:hsb[2]
+                                               alpha:alpha];
 
         color = [self computeColorSpace:color];
 
         // memory clean!
-        free(hsb);
-        free(params);
+        (void)free(str), str = NULL;
+        (void)free(hsb), hsb = NULL;
+        (void)free(params), params = NULL;
         return color;
     }
-
-    color = [self.class colorFromHEXString:string];
-    return color;
+    
+    // is simply a clear color, dont fill
+    if(IJSVGCharBufferCompare(str, "none") == YES ||
+        IJSVGCharBufferCompare(str, "transparent") == YES) {
+        (void)free(str), str = NULL;
+        return nil;
+    }
+    
+    // could return nil
+    (void)free(str), str = NULL;
+    return [self.class colorFromPredefinedColorName:string];
 }
 
 + (NSColor*)colorFromPredefinedColorName:(NSString*)name
 {
     NSNumber* hex = nil;
-    name = [name.lowercaseString stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]];
-    if ((hex = _colorTree[name]) == nil) {
+    name = [name.lowercaseString stringByTrimmingCharactersInSet:NSCharacterSet.whitespaceAndNewlineCharacterSet];
+    if((hex = _colorTree[name]) == nil) {
         return nil;
     }
     return [self.class colorFromHEXInteger:hex.integerValue];
@@ -339,33 +387,33 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
     BOOL allowRRGGBBAA = (options & IJSVGColorStringOptionAllowRRGGBBAA) != 0;
 
     // jsut return none
-    if (alpha == 0 && forceHex == NO) {
-        return @"none";
+    if(alpha == 0 && forceHex == NO) {
+        return IJSVGStringNone;
     }
 
     // always return hex unless criteria is met
-    if (forceHex == YES || allowRRGGBBAA == YES || alpha == 100 || (red == 0 && green == 0 && blue == 0 && alpha == 0) || (red == 255 && green == 255 && blue == 255 && alpha == 100)) {
+    if(forceHex == YES || allowRRGGBBAA == YES || alpha == 100 || (red == 0 && green == 0 && blue == 0 && alpha == 0) || (red == 255 && green == 255 && blue == 255 && alpha == 100)) {
 
         // we need to make sure the last 2 chars
         // are the same or we cant enable shorthand
-        if (allowRRGGBBAA == YES) {
+        if(allowRRGGBBAA == YES) {
             NSString* alphaHexString = [NSString stringWithFormat:@"%02X",
                                                  (int)(color.alphaComponent * 0xFF)];
-            if ([alphaHexString characterAtIndex:0] !=
+            if([alphaHexString characterAtIndex:0] !=
                 [alphaHexString characterAtIndex:1]) {
                 allowShortHand = NO;
             }
         }
 
-        if (allowShortHand == YES) {
+        if(allowShortHand == YES) {
             NSString* r = [NSString stringWithFormat:@"%02X", red];
             NSString* g = [NSString stringWithFormat:@"%02X", green];
             NSString* b = [NSString stringWithFormat:@"%02X", blue];
-            if ([r characterAtIndex:0] == [r characterAtIndex:1] &&
+            if([r characterAtIndex:0] == [r characterAtIndex:1] &&
                 [g characterAtIndex:0] == [g characterAtIndex:1] &&
                 [b characterAtIndex:0] == [b characterAtIndex:1]) {
                 // allow shorthand alpha
-                if (allowRRGGBBAA == YES && alpha != 100) {
+                if(allowRRGGBBAA == YES && alpha != 100) {
                     NSString* a = [NSString stringWithFormat:@"%02X",
                                             (int)(color.alphaComponent * 0xFF)];
                     return [NSString stringWithFormat:@"#%c%c%c%c",
@@ -376,7 +424,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
                                  [g characterAtIndex:0], [b characterAtIndex:0]];
             }
         }
-        if (allowRRGGBBAA == YES && alpha != 100) {
+        if(allowRRGGBBAA == YES && alpha != 100) {
             return [NSString stringWithFormat:@"#%02X%02X%02X%02X", red, green,
                              blue, (int)(color.alphaComponent * 0xFF)];
         }
@@ -384,8 +432,8 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
     }
 
     // note the %g, CSS alpha is 0 to 1, not 0 - 100, my bad!
-    return [NSString stringWithFormat:@"rgba(%d,%d,%d,%g)", red, green, blue,
-                     ((float)alpha / 100.f)];
+    return [NSString stringWithFormat:@"rgba(%d,%d,%d,%@)", red, green, blue,
+                     IJSVGShortFloatString((float)alpha / 100.f)];
 }
 
 + (NSString*)colorNameFromPredefinedColor:(IJSVGPredefinedColor)color
@@ -701,20 +749,12 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 
 + (BOOL)isColor:(NSString*)string
 {
-    return [[string substringToIndex:1] isEqualToString:@"#"] ||
-        [[string substringToIndex:3] isEqualToString:@"rgb"];
+    return [string hasPrefix:@"#"] || [string hasPrefix:@"rgb"];
 }
 
 + (BOOL)isHex:(NSString*)string
 {
-    const char* validList = "0123456789ABCDEFabcdef#";
-    for (NSInteger i = 0; i < string.length; i++) {
-        char c = [string characterAtIndex:i];
-        if (strchr(validList, c) == NULL) {
-            return NO;
-        }
-    }
-    return YES;
+    return string.ijsvg_isHexString;
 }
 
 + (unsigned long)lengthOfHEXInteger:(NSUInteger)hex
@@ -734,7 +774,7 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
 + (NSColor*)colorFromHEXInteger:(NSInteger)hex
 {
     CGFloat alpha = 1.f;
-    if ([self HEXContainsAlphaComponent:hex] == YES) {
+    if([self HEXContainsAlphaComponent:hex] == YES) {
         alpha = (hex & 0xFF) / 255.f;
         hex = hex >> 8;
     }
@@ -760,29 +800,39 @@ CGFloat* IJSVGColorCSSHSLToHSB(CGFloat hue, CGFloat saturation, CGFloat lightnes
         containsAlphaComponent:(BOOL*)containsAlphaComponent
 {
     // absolutely no string
-    if (string == nil || string.length == 0 || ![self.class isHex:string]) {
+    if(string == nil) {
+        return nil;
+    }
+    
+    char* str = (char*)string.UTF8String;
+    size_t length = strlen(str);
+    if(length == 0 || IJSVGCharBufferIsHEX(str) == NO) {
         return nil;
     }
 
-    if ([[string substringToIndex:1] isEqualToString:@"#"]) {
-        string = [string substringFromIndex:1];
+    // remove the hash from the front of the string
+    if(str[0] == '#') {
+        length--;
+        str++;
     }
 
-    // whats the length?
-    NSUInteger length = string.length;
-    if (length == 3 || length == 4) {
-        // shorthand...
-        NSMutableString* str = [[[NSMutableString alloc] init] autorelease];
-        for (NSInteger i = 0; i < length; i++) {
-            NSString* sub = [string substringWithRange:NSMakeRange(i, 1)];
-            [str appendFormat:@"%@%@", sub, sub];
+    unsigned long hex;
+    // we need to work out if its shorthand
+    // if it is, the length needs to be length*2
+    if(length == 3 || length == 4) {
+        char* chars = NULL;
+        chars = (char*)calloc(sizeof(char),length*2+1);
+        for(int i = 0; i < length; i++) {
+            chars[i*2] = chars[i*2+1] = str[i];
         }
-        string = str;
+        hex = strtoul(chars, NULL, 16);
+        (void)free(chars), chars = NULL;
+    } else {
+        hex = strtoul(str, NULL, 16);
     }
-
+    
     // now convert rest to hex
-    unsigned long hex = [self HEXFromArbitraryHexString:string];
-    if (containsAlphaComponent != nil) {
+    if(containsAlphaComponent != nil) {
         *containsAlphaComponent = [self HEXContainsAlphaComponent:hex];
     }
     return [self colorFromHEXInteger:hex];

Framework/IJSVG/IJSVG/Source/Colors/IJSVGColorType.h

@@ -0,0 +1,32 @@
+//
+//  IJSVGColorType.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 20/04/2021.
+//  Copyright © 2021 Curtis Hard. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+
+typedef NS_OPTIONS(NSInteger, IJSVGColorUsageTraits) {
+    IJSVGColorUsageTraitNone = 0,
+    IJSVGColorUsageTraitUnknown = 1 << 0,
+    IJSVGColorUsageTraitFill = 1 << 1,
+    IJSVGColorUsageTraitStroke = 1 << 2,
+    IJSVGColorUsageTraitGradientStop = 1 << 3,
+    IJSVGColorUsageTraitAll = IJSVGColorUsageTraitFill | IJSVGColorUsageTraitGradientStop |
+        IJSVGColorUsageTraitStroke
+};
+
+@interface IJSVGTraitedColor : NSObject {
+    
+}
+
+@property (nonatomic, strong) NSColor* color;
+@property (nonatomic, assign) IJSVGColorUsageTraits traits;
+
++ (IJSVGTraitedColor*)typeWithColor:(NSColor*)color
+                          traits:(IJSVGColorUsageTraits)mask;
+
+@end

Framework/IJSVG/IJSVG/Source/Colors/IJSVGTraitedColor.h

@@ -0,0 +1,36 @@
+//
+//  IJSVGColorType.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 20/04/2021.
+//  Copyright © 2021 Curtis Hard. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <AppKit/AppKit.h>
+
+typedef NS_OPTIONS(NSInteger, IJSVGColorUsageTraits) {
+    IJSVGColorUsageTraitNone = 0,
+    IJSVGColorUsageTraitUnknown = 1 << 0,
+    IJSVGColorUsageTraitFill = 1 << 1,
+    IJSVGColorUsageTraitStroke = 1 << 2,
+    IJSVGColorUsageTraitGradientStop = 1 << 3,
+    IJSVGColorUsageTraitAll = IJSVGColorUsageTraitFill | IJSVGColorUsageTraitGradientStop |
+        IJSVGColorUsageTraitStroke
+};
+
+@interface IJSVGTraitedColor : NSObject {
+    
+}
+
+@property (nonatomic, strong) NSColor* color;
+@property (nonatomic, assign) IJSVGColorUsageTraits traits;
+
++ (IJSVGTraitedColor*)colorWithColor:(NSColor*)color
+                              traits:(IJSVGColorUsageTraits)mask;
+
+- (void)addTraits:(IJSVGColorUsageTraits)traits;
+- (void)removeTraits:(IJSVGColorUsageTraits)traits;
+- (BOOL)matchesTraits:(IJSVGColorUsageTraits)traits;
+
+@end

Framework/IJSVG/IJSVG/Source/Colors/IJSVGTraitedColor.m

@@ -0,0 +1,64 @@
+//
+//  IJSVGColorType.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 20/04/2021.
+//  Copyright © 2021 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGTraitedColor.h>
+#import <IJSVG/IJSVGColor.h>
+
+@implementation IJSVGTraitedColor
+
++ (IJSVGTraitedColor*)colorWithColor:(NSColor*)color
+                              traits:(IJSVGColorUsageTraits)traits
+{
+    IJSVGTraitedColor* type = [[self alloc] init];
+    type.color = color;
+    type.traits = traits;
+    return type;
+}
+
+- (instancetype)init
+{
+    if((self = [super init]) != nil) {
+        _traits = IJSVGColorUsageTraitNone;
+    }
+    return self;
+}
+
+- (BOOL)isEqual:(id)object
+{
+    if([object isKindOfClass:IJSVGTraitedColor.class] == NO) {
+        return NO;
+    }
+    return [self.color isEqual:((IJSVGTraitedColor*)object).color];
+}
+
+- (void)setColor:(NSColor *)color
+{
+    _color = [IJSVGColor computeColorSpace:color];
+}
+
+- (NSUInteger)hash
+{
+    return self.color.hash;
+}
+
+- (void)addTraits:(IJSVGColorUsageTraits)traits
+{
+    _traits |= traits;
+}
+
+- (void)removeTraits:(IJSVGColorUsageTraits)traits
+{
+    _traits = _traits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGColorUsageTraits)traits
+{
+    return (self.traits & traits) == traits;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Colors/IJSVGTraitedColorStorage.h

@@ -0,0 +1,43 @@
+//
+//  IJSVGColorList.h
+//  IconJar
+//
+//  Created by Curtis Hard on 07/07/2019.
+//  Copyright © 2019 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGColor.h>
+#import <IJSVG/IJSVGTraitedColor.h>
+#import <Foundation/Foundation.h>
+
+@interface IJSVGReplacementColor : IJSVGTraitedColor
+
+@property (nonatomic, strong) NSColor* replacementColor;
+
+@end
+
+@interface IJSVGTraitedColorStorage : NSObject {
+
+@private
+    NSMutableArray<IJSVGReplacementColor*>* _replacementColors;
+    NSMutableSet<IJSVGTraitedColor*>* _colors;
+    IJSVGColorUsageTraits _traits;
+    IJSVGColorUsageTraits _replacementTraits;
+}
+
+@property (nonatomic, readonly) NSUInteger count;
+@property (nonatomic, readonly) NSSet<IJSVGTraitedColor*>* colors;
+@property (nonatomic, readonly) NSUInteger replacedColorCount;
+
+- (void)addTraits:(IJSVGColorUsageTraits)traits;
+- (void)addColor:(IJSVGTraitedColor*)color;
+- (void)replaceColor:(NSColor*)replaceColor
+           withColor:(NSColor*)withColor
+              traits:(IJSVGColorUsageTraits)traits;
+- (void)unionColorStorage:(IJSVGTraitedColorStorage*)colorList;
+- (NSColor*)colorForColor:(NSColor*)color
+           matchingTraits:(IJSVGColorUsageTraits)traits;
+- (BOOL)matchesReplacementTraits:(IJSVGColorUsageTraits)traits;
+- (BOOL)matchesTraits:(IJSVGColorUsageTraits)traits;
+
+@end

Framework/IJSVG/IJSVG/Source/Colors/IJSVGTraitedColorStorage.m

@@ -0,0 +1,146 @@
+//
+//  IJSVGColorList.m
+//  IconJar
+//
+//  Created by Curtis Hard on 07/07/2019.
+//  Copyright © 2019 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGTraitedColorStorage.h>
+
+@implementation IJSVGReplacementColor
+
+- (void)setReplacementColor:(NSColor*)replacementColor
+{
+    _replacementColor = [IJSVGColor computeColorSpace:replacementColor];
+}
+
+@end
+
+@implementation IJSVGTraitedColorStorage
+
+- (instancetype)init
+{
+    if((self = [super init]) != nil) {
+        _replacementColors = [[NSMutableArray alloc] init];
+        _colors = [[NSMutableSet alloc] init];
+        _replacementTraits = IJSVGColorUsageTraitNone;
+        _traits = IJSVGColorUsageTraitNone;
+    }
+    return self;
+}
+
+- (void)addColor:(IJSVGTraitedColor*)color
+{
+    if([_colors containsObject:color] == YES) {
+        void (^handler)(IJSVGTraitedColor * _Nonnull obj, BOOL * _Nonnull stop) =
+        ^(IJSVGTraitedColor * _Nonnull obj, BOOL * _Nonnull stop) {
+            if([obj isEqual:color] == YES) {
+                [obj addTraits:color.traits];
+                *stop = YES;
+            }
+        };
+        [_colors enumerateObjectsUsingBlock:handler];
+        return;
+    }
+    _traits |= color.traits;
+    [_colors addObject:color];
+}
+
+- (void)addTraits:(IJSVGColorUsageTraits)traits
+{
+    for(IJSVGTraitedColor* color in _colors) {
+        [color addTraits:traits];
+    }
+}
+
+- (void)replaceColor:(NSColor*)replaceColor
+           withColor:(NSColor*)withColor
+              traits:(IJSVGColorUsageTraits)traits
+{
+    replaceColor = [IJSVGColor computeColorSpace:replaceColor];
+    withColor = [IJSVGColor computeColorSpace:withColor];
+    IJSVGReplacementColor* repColor = [self replacementColorForColor:replaceColor
+                                                           withColor:withColor];
+    if(repColor == nil) {
+        repColor = [[IJSVGReplacementColor alloc] init];
+        repColor.color = replaceColor;
+        repColor.replacementColor = withColor;
+        [_replacementColors addObject:repColor];
+    }
+    _replacementTraits |= traits;
+    [repColor addTraits:traits];
+}
+
+- (IJSVGReplacementColor*)replacementColorForColor:(NSColor*)replacementColor
+                                         withColor:(NSColor*)withColor
+{
+    for(IJSVGReplacementColor* color in _replacementColors) {
+        if([color.color isEqual:color] == YES &&
+           [color.replacementColor isEqual:withColor] == YES) {
+            return color;
+        }
+    }
+    return nil;
+}
+
+- (IJSVGReplacementColor*)replacementColorForColor:(NSColor*)color
+                                    matchingTraits:(IJSVGColorUsageTraits)traits
+{
+    for(IJSVGReplacementColor* replacementColor in _replacementColors) {
+        if([replacementColor.color isEqual:color] &&
+           [replacementColor matchesTraits:traits] == YES) {
+            return replacementColor;
+        }
+    }
+    return nil;
+}
+
+- (NSColor*)colorForColor:(NSColor*)color
+           matchingTraits:(IJSVGColorUsageTraits)traits
+{
+    if([self matchesReplacementTraits:traits] == NO) {
+        return nil;
+    }
+    color = [IJSVGColor computeColorSpace:color];
+    IJSVGReplacementColor* repColor = nil;
+    if((repColor = [self replacementColorForColor:color
+                                   matchingTraits:traits]) != nil) {
+        return repColor.replacementColor;
+    }
+    return nil;
+}
+
+- (void)unionColorStorage:(IJSVGTraitedColorStorage*)colorList
+{
+    for(IJSVGTraitedColor* traitedColor in colorList.colors) {
+        [self addColor:traitedColor];
+    }
+}
+
+- (BOOL)matchesTraits:(IJSVGColorUsageTraits)traits
+{
+    return (_traits & traits) == traits;
+}
+
+- (BOOL)matchesReplacementTraits:(IJSVGColorUsageTraits)traits
+{
+    return (_replacementTraits & traits) == traits;
+}
+
+- (NSUInteger)replacedColorCount
+{
+    return _replacementColors.count;
+}
+
+- (NSUInteger)count
+{
+    return _colors.count;
+}
+
+- (NSSet<IJSVGTraitedColor*>*)colors
+{
+    return _colors;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommand.h

@@ -6,36 +6,27 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGPath.h"
+#import <IJSVG/IJSVGCommandParser.h>
+#import <IJSVG/IJSVGPath.h>
 #import <Foundation/Foundation.h>
 
 static const NSInteger IJSVGCustomVariableParameterCount = NSNotFound;
 
 typedef NS_ENUM(NSInteger, IJSVGCommandType) {
-    IJSVGCommandTypeAbsolute,
-    IJSVGCommandTypeRelative
+    kIJSVGCommandTypeAbsolute,
+    kIJSVGCommandTypeRelative
 };
 
-@interface IJSVGCommand : NSObject {
-    NSString* commandString;
-    NSString* command;
-    CGFloat* parameters;
-    NSInteger parameterCount;
-    NSMutableArray* subCommands;
-    NSInteger requiredParameters;
-    IJSVGCommandType type;
-    IJSVGCommand* previousCommand;
+@interface IJSVGCommand : NSObject <NSCopying> {
+@private
     NSInteger _currentIndex;
-    BOOL isSubCommand;
 }
 
-@property (nonatomic, copy) NSString* commandString;
-@property (nonatomic, copy) NSString* command;
+@property (nonatomic, assign) char command;
 @property (nonatomic, assign) CGFloat* parameters;
 @property (nonatomic, assign) NSInteger parameterCount;
-@property (nonatomic, assign) NSInteger requiredParameters;
 @property (nonatomic, assign) IJSVGCommandType type;
-@property (nonatomic, retain) NSMutableArray<IJSVGCommand*>* subCommands;
+@property (nonatomic, strong) NSArray<IJSVGCommand*>* subCommands;
 @property (nonatomic, assign) IJSVGCommand* previousCommand;
 @property (nonatomic, assign) BOOL isSubCommand;
 
@@ -43,20 +34,36 @@ typedef NS_ENUM(NSInteger, IJSVGCommandType) {
 + (NSInteger)requiredParameterCount;
 + (NSPoint)readCoordinatePair:(CGFloat*)pairs
                         index:(NSInteger)index;
++ (IJSVGPathDataSequence*)pathDataSequence;
 + (void)runWithParams:(CGFloat*)params
            paramCount:(NSInteger)count
               command:(IJSVGCommand*)currentCommand
       previousCommand:(IJSVGCommand*)command
                  type:(IJSVGCommandType)type
-                 path:(IJSVGPath*)path;
+                 path:(CGMutablePathRef)path;
 + (void)parseParams:(CGFloat*)params
          paramCount:(NSInteger)paramCount
           intoArray:(NSMutableArray<IJSVGCommand*>*)commands
       parentCommand:(IJSVGCommand*)parentCommand;
 
-- (id)initWithCommandString:(NSString*)commandString;
++ (NSArray<IJSVGCommand*>*)commandsForDataCharacters:(const char*)buffer;
++ (NSArray<IJSVGCommand*>*)commandsForDataCharacters:(const char*)buffer
+                                          dataStream:(IJSVGPathDataStream*)dataStream;
++ (CGMutablePathRef)newPathForCommandsArray:(NSArray<IJSVGCommand*>*)commands;
+
++ (NSArray<IJSVGCommand*>*)convertCommands:(NSArray<IJSVGCommand*>*)commands
+                                   toUnits:(IJSVGUnitType)unitType
+                                    bounds:(CGRect)bounds;
+
+- (id)initWithCommandStringBuffer:(const char*)str
+                       dataStream:(IJSVGPathDataStream*)dataStream;
 - (IJSVGCommand*)subcommandWithParameters:(CGFloat*)subParams
+                               paramCount:(NSInteger)paramCount
                           previousCommand:(IJSVGCommand*)command;
+- (void)convertToUnits:(IJSVGUnitType)units
+           boundingBox:(CGRect)boundingBox;
+- (IJSVGCommand*)commandByConvertingToUnits:(IJSVGUnitType)unitType
+                                boundingBox:(CGRect)boundingBox;
 
 - (CGFloat)readFloat;
 - (NSPoint)readPoint;

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommand.m

@@ -0,0 +1,365 @@
+//
+//  IJSVGCommand.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommand.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <IJSVG/IJSVGCommandClose.h>
+#import <IJSVG/IJSVGCommandCurve.h>
+#import <IJSVG/IJSVGCommandEllipticalArc.h>
+#import <IJSVG/IJSVGCommandHorizontalLine.h>
+#import <IJSVG/IJSVGCommandLineTo.h>
+#import <IJSVG/IJSVGCommandMove.h>
+#import <IJSVG/IJSVGCommandQuadraticCurve.h>
+#import <IJSVG/IJSVGCommandSmoothCurve.h>
+#import <IJSVG/IJSVGCommandSmoothQuadraticCurve.h>
+#import <IJSVG/IJSVGCommandVerticalLine.h>
+#import <IJSVG/IJSVGThreadManager.h>
+
+@implementation IJSVGCommand
+
++ (BOOL)requiresCustomParameterParsing
+{
+    return NO;
+}
+
++ (NSInteger)requiredParameterCount
+{
+    return 1;
+}
+
++ (IJSVGPathDataSequence*)pathDataSequence
+{
+    return NULL;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+}
+
++ (void)parseParams:(CGFloat*)params
+         paramCount:(NSInteger)paramCount
+          intoArray:(NSMutableArray<IJSVGCommand*>*)commands
+      parentCommand:(IJSVGCommand*)parentCommand
+{
+}
+
++ (NSPoint)readCoordinatePair:(CGFloat*)pairs
+                        index:(NSInteger)index
+{
+    return NSMakePoint(pairs[index * 2], pairs[index * 2 + 1]);
+}
+
++ (void)load
+{
+    // register here...
+}
+
++ (Class)commandClassForCommandChar:(char)aChar
+{
+    aChar = tolower(aChar);
+    switch (aChar) {
+    case 'a':
+        return IJSVGCommandEllipticalArc.class;
+    case 'c':
+        return IJSVGCommandCurve.class;
+    case 'h':
+        return IJSVGCommandHorizontalLine.class;
+    case 'l':
+        return IJSVGCommandLineTo.class;
+    case 'm':
+        return IJSVGCommandMove.class;
+    case 'q':
+        return IJSVGCommandQuadraticCurve.class;
+    case 's':
+        return IJSVGCommandSmoothCurve.class;
+    case 't':
+        return IJSVGCommandSmoothQuadraticCurve.class;
+    case 'v':
+        return IJSVGCommandVerticalLine.class;
+    case 'z':
+        return IJSVGCommandClose.class;
+    }
+    return nil;
+}
+
++ (CGMutablePathRef)newPathForCommandsArray:(NSArray<IJSVGCommand*>*)commands
+{
+    CGMutablePathRef path = CGPathCreateMutable();
+    IJSVGCommand* preCommand = nil;
+    for(IJSVGCommand* command in commands) {
+        for (IJSVGCommand* subCommand in command.subCommands) {
+            [command.class runWithParams:subCommand.parameters
+                              paramCount:subCommand.parameterCount
+                                 command:subCommand
+                         previousCommand:preCommand
+                                    type:subCommand.type
+                                    path:path];
+            preCommand = subCommand;
+        }
+    }
+    return path;
+}
+
++ (NSArray<IJSVGCommand*>*)commandsForDataCharacters:(const char*)buffer
+{
+    IJSVGThreadManager* manager = IJSVGThreadManager.currentManager;
+    NSArray<IJSVGCommand*>* commands = [self commandsForDataCharacters:buffer
+                                                            dataStream:manager.pathDataStream];
+    return commands;
+}
+
++ (NSArray<IJSVGCommand*>*)commandsForDataCharacters:(const char*)unsafeBuffer
+                                          dataStream:(IJSVGPathDataStream*)dataStream
+{
+    NSMutableArray<IJSVGCommand*>* commands = [[NSMutableArray alloc] init];
+    NSUInteger len = strlen(unsafeBuffer);
+    NSUInteger lastIndex = len - 1;
+    
+    // we need to trim the buffer first as any given string given to us
+    // could be unsafe and have random whitespace at the extremes.
+    size_t bufferLength = sizeof(char)*(len + 1);
+    char* buffer = (char*)malloc(bufferLength);
+    memcpy(buffer, unsafeBuffer, bufferLength);
+    IJSVGTrimCharBuffer(buffer);
+
+    // make sure we plus 1 for the null byte
+    char* charBuffer = (char*)malloc(bufferLength);
+    NSInteger start = 0;
+    for (NSInteger i = start; i < len; i++) {
+        char nextChar = buffer[i + 1];
+        BOOL atEnd = i == lastIndex;
+        BOOL isStartCommand = IJSVGIsLegalCommandCharacter(nextChar);
+        if(isStartCommand == YES || atEnd == YES) {
+
+            // copy memory from current buffer
+            NSInteger index = ((i + 1) - start);
+            memcpy(&charBuffer[0], &buffer[start], sizeof(char)*index);
+            charBuffer[index] = '\0';
+
+            // create the command from the substring
+            unsigned long length = index + 1;
+            size_t mlength = sizeof(char)*length;
+            char* commandString = (char*)malloc(mlength);
+            memcpy(commandString, &charBuffer[0], mlength);
+
+            // reset start position
+            start = (i + 1);
+
+            // previous command is actual subcommand
+            Class commandClass = [IJSVGCommand commandClassForCommandChar:commandString[0]];
+            if(commandClass != nil) {
+                IJSVGCommand* command = nil;
+                command = (IJSVGCommand*)[[commandClass alloc] initWithCommandStringBuffer:commandString
+                                                                                dataStream:dataStream];
+                
+                [commands addObject:command];
+            }
+#if DEBUG
+            else {
+                // if we get here then the command buffer is invalid, nothing we can
+                // do about it, just invalid data.
+                NSLog(@"\"%s\" is not a valid command instruction set", commandString);
+            }
+#endif
+            
+            // free the memory as at this point, we are done with it
+            (void)free(commandString), commandString = NULL;
+        }
+    }
+    (void)free(charBuffer), charBuffer = NULL;
+    (void)free(buffer), buffer = NULL;
+    return commands;
+}
+
++ (NSArray<IJSVGCommand*>*)convertCommands:(NSArray<IJSVGCommand*>*)commands
+                                   toUnits:(IJSVGUnitType)unitType
+                                    bounds:(CGRect)bounds
+{
+    NSMutableArray<IJSVGCommand*>* newCommands = nil;
+    newCommands = [[NSMutableArray alloc] initWithCapacity:commands.count];
+    for(IJSVGCommand* command in commands) {
+        IJSVGCommand* nCommand = [command commandByConvertingToUnits:unitType
+                                                         boundingBox:bounds];
+        [newCommands addObject:nCommand];
+    }
+    return newCommands;
+}
+
+- (void)dealloc
+{
+    if(_parameters) {
+        (void)(free(_parameters)), _parameters = nil;
+    }
+}
+
+- (id)initWithCommandStringBuffer:(const char*)str
+                       dataStream:(IJSVGPathDataStream*)dataStream
+{
+    if((self = [super init]) != nil) {
+        // work out the basics
+        _currentIndex = 0;
+        _command = str[0];
+        _type = [IJSVGUtils typeForCommandChar:_command];
+        NSInteger sets = 0;
+        NSInteger paramCount = [self.class requiredParameterCount];
+        IJSVGPathDataSequence* sequence = [self.class pathDataSequence];
+        _parameters = IJSVGParsePathDataStreamSequence(str, strlen(str),
+            dataStream, sequence, paramCount, &sets);
+
+        if(sets <= 1) {
+            CGFloat* subParams = [self parametersFromIndexOffset:0];
+            IJSVGCommand* command = [self subcommandWithParameters:subParams
+                                                        paramCount:paramCount
+                                                   previousCommand:nil];
+            _subCommands = @[ command ];
+        } else {
+            NSMutableArray<IJSVGCommand*>* subCommandArray = nil;
+            subCommandArray = [[NSMutableArray alloc] initWithCapacity:sets];
+
+            // interate over the sets
+            IJSVGCommand* lastCommand = nil;
+            for (NSInteger i = 0; i < sets; i++) {
+                // memory for this will be handled by the created subcommand
+                CGFloat* subParams = [self parametersFromIndexOffset:i];
+
+                // generate the subcommand
+                IJSVGCommand* command = [self subcommandWithParameters:subParams
+                                                            paramCount:paramCount
+                                                       previousCommand:lastCommand];
+
+                // make sure we assign the last command or hell breaks
+                // lose and the firey demons will run wild, namely, commands will break
+                // if they are multiples of a set
+                lastCommand = command;
+                [subCommandArray addObject:command];
+            }
+
+            // store the retained value
+            _subCommands = subCommandArray.copy;
+        }
+    }
+    return self;
+}
+
+- (void)setSubCommands:(NSArray<IJSVGCommand*>*)subCommands
+{
+    _subCommands = subCommands;
+}
+
+- (id)copyWithZone:(NSZone *)zone
+{
+    IJSVGCommand* command = [[self.class alloc] init];
+    command.type = self.type;
+    command.command = self.command;
+    command.isSubCommand = self.isSubCommand;
+    command.parameterCount = self.parameterCount;
+    size_t memsize = sizeof(CGFloat)*self.parameterCount;
+    command.parameters = (CGFloat*)malloc(memsize);
+    memcpy(command.parameters, self.parameters, memsize);
+    
+    
+    IJSVGCommand* lastCommand = nil;
+    NSMutableArray<IJSVGCommand*>* subcommands = nil;
+    subcommands = [[NSMutableArray alloc] initWithCapacity:self.subCommands.count];
+    for(IJSVGCommand* subcommand in self.subCommands) {
+        IJSVGCommand* subCopy = subcommand.copy;
+        subCopy.previousCommand = lastCommand;
+        subCopy.isSubCommand = lastCommand != nil;
+        [subcommands addObject:subCopy];
+    }
+    command.subCommands = subcommands;
+    return command;
+}
+
+- (CGFloat*)parametersFromIndexOffset:(NSInteger)index
+{
+    CGFloat* subParams = 0;
+    NSInteger req = [self.class requiredParameterCount];
+    if(req != 0) {
+        subParams = (CGFloat*)malloc(req * sizeof(CGFloat));
+        memcpy(subParams, &self.parameters[index * req], sizeof(CGFloat) * req);
+    }
+    return subParams;
+}
+
+- (IJSVGCommand*)subcommandWithParameters:(CGFloat*)subParams
+                               paramCount:(NSInteger)paramCount
+                          previousCommand:(IJSVGCommand*)aPreviousCommand
+{
+    // create a subcommand per set
+    IJSVGCommand* c = [[self.class alloc] init];
+    c.parameterCount = paramCount;
+    c.parameters = subParams;
+    c.type = self.type;
+    c.command = self.command;
+    c.previousCommand = aPreviousCommand;
+    c.isSubCommand = aPreviousCommand != nil;
+    return c;
+}
+
+- (CGFloat)readFloat
+{
+    CGFloat f = _parameters[_currentIndex];
+    _currentIndex++;
+    return f;
+}
+
+- (NSPoint)readPoint
+{
+    CGFloat x = _parameters[_currentIndex];
+    CGFloat y = _parameters[_currentIndex + 1];
+    _currentIndex += 2;
+    return NSMakePoint(x, y);
+}
+
+- (BOOL)readBOOL
+{
+    return [self readFloat] == 1;
+}
+
+- (void)resetRead
+{
+    _currentIndex = 0;
+}
+
+- (void)convertToUnits:(IJSVGUnitType)units
+           boundingBox:(CGRect)boundingBox
+{
+    for(IJSVGCommand* command in _subCommands) {
+        [command convertToUnits:units
+                    boundingBox:boundingBox];
+    }
+}
+
+- (NSString *)description
+{
+    NSMutableString* str = [[NSMutableString alloc] init];
+    [str appendFormat:@"%c ",_command];
+    NSMutableArray* args = [[NSMutableArray alloc] initWithCapacity:_parameterCount];
+    for(int i = 0; i < _parameterCount; i++) {
+        [args addObject:[NSString stringWithFormat:@"%f",_parameters[i]]];
+    }
+    [str appendString:[args componentsJoinedByString:@", "]];
+    return str;
+}
+
+- (IJSVGCommand*)commandByConvertingToUnits:(IJSVGUnitType)unitType
+                                boundingBox:(CGRect)boundingBox
+{
+    IJSVGCommand* copy = self.copy;
+    [copy convertToUnits:unitType
+             boundingBox:boundingBox];
+    return copy;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandClose.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandClose : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandClose.m

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommandClose.h"
+#import <IJSVG/IJSVGCommandClose.h>
 
 @implementation IJSVGCommandClose
 
@@ -20,9 +20,9 @@
               command:(IJSVGCommand*)currentCommand
       previousCommand:(IJSVGCommand*)command
                  type:(IJSVGCommandType)type
-                 path:(IJSVGPath*)path
+                 path:(CGMutablePathRef)path
 {
-    [path close];
+    CGPathCloseSubpath(path);
 }
 
 @end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandCurve.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandCurve : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandCurve.m

@@ -0,0 +1,38 @@
+//
+//  IJSVGCommandCurve.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandCurve.h>
+
+@implementation IJSVGCommandCurve
+
++ (NSInteger)requiredParameterCount
+{
+    return 6;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddCurveToPoint(path, NULL, params[0], params[1],
+                              params[2], params[3],
+                              params[4], params[5]);
+        return;
+    }
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathAddCurveToPoint(path, NULL,
+                          currentPoint.x + params[0], currentPoint.y + params[1],
+                          currentPoint.x + params[2], currentPoint.y + params[3],
+                          currentPoint.x + params[4], currentPoint.y + params[5]);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandEllipticalArc.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandEllipticalArc : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandEllipticalArc.m

@@ -0,0 +1,139 @@
+//
+//  IJSVGCommandArc.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 03/09/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandEllipticalArc.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation IJSVGCommandEllipticalArc
+
+static IJSVGPathDataSequence* _sequence;
+
++ (NSInteger)requiredParameterCount
+{
+    return 7;
+}
+
++ (IJSVGPathDataSequence*)pathDataSequence
+{
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        _sequence = (IJSVGPathDataSequence*)malloc(sizeof(IJSVGPathDataSequence) * 7);
+        _sequence[0] = kIJSVGPathDataSequenceTypeFloat;
+        _sequence[1] = kIJSVGPathDataSequenceTypeFloat;
+        _sequence[2] = kIJSVGPathDataSequenceTypeFloat;
+        _sequence[3] = kIJSVGPathDataSequenceTypeFlag;
+        _sequence[4] = kIJSVGPathDataSequenceTypeFlag;
+        _sequence[5] = kIJSVGPathDataSequenceTypeFloat;
+        _sequence[6] = kIJSVGPathDataSequenceTypeFloat;
+    });
+    return _sequence;
+}
+
+// modified from https://github.com/SVGKit/SVGKit/blob/880c94a5b77b6f22beb491a7a7e02ace220c32af/Source/Parsers/SVGKPointsAndPathsParser.m
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    CGPoint radii = CGPointZero;
+    CGPoint arcEndPoint = CGPointZero;
+    CGPoint pathCurrentPoint = CGPathGetCurrentPoint(path);
+    CGFloat xAxisRotation = 0.f;
+    BOOL largeArcFlag = NO;
+    BOOL sweepFlag = NO;
+    
+    radii = currentCommand.readPoint;
+    xAxisRotation = currentCommand.readFloat;
+    largeArcFlag = currentCommand.readBOOL;
+    sweepFlag = currentCommand.readBOOL;
+    arcEndPoint = currentCommand.readPoint;
+    
+    CGFloat rx = fabs(radii.x);
+    CGFloat ry = fabs(radii.y);
+    
+    xAxisRotation *= M_PI / 180.f;
+    xAxisRotation = fmod(xAxisRotation, 2.f * M_PI);
+
+    if(type == kIJSVGCommandTypeRelative) {
+        arcEndPoint.x += pathCurrentPoint.x;
+        arcEndPoint.y += pathCurrentPoint.y;
+    }
+    
+    CGFloat x1 = pathCurrentPoint.x;
+    CGFloat y1 = pathCurrentPoint.y;
+    
+    CGFloat x2 = arcEndPoint.x;
+    CGFloat y2 = arcEndPoint.y;
+    
+    if(rx == 0.f || ry == 0.f) {
+        CGPathAddLineToPoint(path, NULL, x2, y2);
+        return;
+    }
+    
+    CGFloat cosPhi = cos(xAxisRotation);
+    CGFloat sinPhi = sin(xAxisRotation);
+    
+    CGFloat x1p = cosPhi * (x1 - x2) / 2.f + sinPhi * (y1 - y2) / 2.f;
+    CGFloat y1p = -sinPhi * (x1 - x2) / 2.f + cosPhi * (y1 - y2) / 2.f;
+    
+    CGFloat rx_2 = rx * rx;
+    CGFloat ry_2 = ry * ry;
+    CGFloat xp_2 = x1p * x1p;
+    CGFloat yp_2 = y1p * y1p;
+
+    CGFloat delta = xp_2 / rx_2 + yp_2 / ry_2;
+    
+    if(delta > 1.f) {
+        rx *= sqrt(delta);
+        ry *= sqrt(delta);
+        rx_2 = rx * rx;
+        ry_2 = ry * ry;
+    }
+    
+    CGFloat sign = (largeArcFlag == sweepFlag) ? -1.f : 1.f;
+    CGFloat numerator = MAX(0.f, rx_2 * ry_2 - rx_2 * yp_2 - ry_2 * xp_2);
+    CGFloat denom = rx_2 * yp_2 + ry_2 * xp_2;
+    CGFloat lhs = denom == 0.f ? 0.f : sign * sqrt(numerator / denom);
+    
+    CGFloat cxp = lhs * (rx * y1p) / ry;
+    CGFloat cyp = lhs * -((ry * x1p) / rx);
+    
+    CGFloat cx = cosPhi * cxp + -sinPhi * cyp + (x1 + x2) / 2.f;
+    CGFloat cy = cxp * sinPhi + cyp * cosPhi + (y1 + y2) / 2.f;
+
+    CGAffineTransform transform = CGAffineTransformMakeScale(1.f / rx, 1.f / ry);
+    transform = CGAffineTransformRotate(transform, -xAxisRotation);
+    transform = CGAffineTransformTranslate(transform, -cx, -cy);
+    
+    CGPoint arcPt1 = CGPointApplyAffineTransform(CGPointMake(x1, y1), transform);
+    CGPoint arcPt2 = CGPointApplyAffineTransform(CGPointMake(x2, y2), transform);
+        
+    CGFloat startAngle = atan2(arcPt1.y, arcPt1.x);
+    CGFloat endAngle = atan2(arcPt2.y, arcPt2.x);
+    
+    CGFloat angleDelta = endAngle - startAngle;;
+    
+    if(sweepFlag == YES) {
+        if(angleDelta < 0.f) {
+            angleDelta += 2.f * M_PI;
+        }
+    } else if(angleDelta > 0.f) {
+        angleDelta = angleDelta - 2.f * M_PI;
+    }
+    
+    transform = CGAffineTransformMakeTranslation(cx, cy);
+    transform = CGAffineTransformRotate(transform, xAxisRotation);
+    transform = CGAffineTransformScale(transform, rx, ry);
+
+    CGPathAddRelativeArc(path, &transform, 0.f, 0.f, 1.f,
+                         startAngle, angleDelta);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandHorizontalLine.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandHorizontalLine : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandHorizontalLine.m

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommandHorizontalLine.h"
+#import <IJSVG/IJSVGCommandHorizontalLine.h>
 
 @implementation IJSVGCommandHorizontalLine
 
@@ -20,13 +20,15 @@
               command:(IJSVGCommand*)currentCommand
       previousCommand:(IJSVGCommand*)command
                  type:(IJSVGCommandType)type
-                 path:(IJSVGPath*)path
+                 path:(CGMutablePathRef)path
 {
-    if (type == IJSVGCommandTypeAbsolute) {
-        [[path currentSubpath] lineToPoint:NSMakePoint(params[0], [path currentSubpath].currentPoint.y)];
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddLineToPoint(path, NULL, params[0], CGPathGetCurrentPoint(path).y);
         return;
     }
-    [[path currentSubpath] relativeLineToPoint:NSMakePoint(params[0], 0.f)];
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathAddLineToPoint(path, NULL, currentPoint.x + params[0],
+                         currentPoint.y);
 }
 
 @end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandLineTo.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandLineTo : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandLineTo.m

@@ -0,0 +1,45 @@
+//
+//  IJSVGCommandLineTo.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandLineTo.h>
+
+@implementation IJSVGCommandLineTo
+
++ (NSInteger)requiredParameterCount
+{
+    return 2;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddLineToPoint(path, NULL, params[0], params[1]);
+        return;
+    }
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathAddLineToPoint(path, NULL, currentPoint.x + params[0],
+                         currentPoint.y + params[1]);
+}
+
+- (void)convertToUnits:(IJSVGUnitType)units
+           boundingBox:(CGRect)boundingBox
+{
+    if(units == IJSVGUnitObjectBoundingBox) {
+        self.parameters[0] = [[IJSVGUnitLength unitWithPercentageFloat:self.parameters[0]] computeValue:boundingBox.size.width];
+        self.parameters[1] = [[IJSVGUnitLength unitWithPercentageFloat:self.parameters[1]] computeValue:boundingBox.size.height];
+    }
+    [super convertToUnits:units
+              boundingBox:boundingBox];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandMove.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandMove : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandMove.m

@@ -0,0 +1,65 @@
+//
+//  IJSVGCommandMove.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandLineTo.h>
+#import <IJSVG/IJSVGCommandMove.h>
+
+@implementation IJSVGCommandMove
+
++ (NSInteger)requiredParameterCount
+{
+    return 2;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    // move to's allow more then one move to, but if there are more then one,
+    // we need to run the line to instead...who knew!
+    if(command.class == self.class && currentCommand.isSubCommand == YES) {
+        [IJSVGCommandLineTo runWithParams:params
+                               paramCount:count
+                                  command:currentCommand
+                          previousCommand:command
+                                     type:type
+                                     path:path];
+        return;
+    }
+
+    // actual move to command - do a moveToPoint only
+    // if the type is absolute, or its possible the type is
+    // relative but there is no previous command which means
+    // there is no current point. Asking for current point on an empty
+    // path will result in an exception being thrown
+    if(type == kIJSVGCommandTypeAbsolute || command == nil) {
+        CGPathMoveToPoint(path, NULL,
+                          params[0], params[1]);
+        return;
+    }
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathMoveToPoint(path, NULL,
+                      currentPoint.x + params[0],
+                      currentPoint.y + params[1]);
+}
+
+- (void)convertToUnits:(IJSVGUnitType)units
+           boundingBox:(CGRect)boundingBox
+{
+    if(units == IJSVGUnitObjectBoundingBox) {
+        self.parameters[0] = [[IJSVGUnitLength unitWithPercentageFloat:self.parameters[0]] computeValue:boundingBox.size.width];
+        self.parameters[1] = [[IJSVGUnitLength unitWithPercentageFloat:self.parameters[1]] computeValue:boundingBox.size.height];
+    }
+    [super convertToUnits:units
+              boundingBox:boundingBox];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandQuadraticCurve.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandQuadraticCurve : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandQuadraticCurve.m

@@ -0,0 +1,37 @@
+//
+//  IJSVGCommandQuadraticCurve.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandQuadraticCurve.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation IJSVGCommandQuadraticCurve
+
++ (NSInteger)requiredParameterCount
+{
+    return 4;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddQuadCurveToPoint(path, NULL, params[0], params[1],
+                                  params[2], params[3]);
+        return;
+    }
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathAddQuadCurveToPoint(path, NULL,
+                              currentPoint.x + params[0], currentPoint.y + params[1],
+                              currentPoint.x + params[2], currentPoint.y + params[3]);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandSmoothCurve.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandSmoothCurve : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandSmoothCurve.m

@@ -0,0 +1,64 @@
+//
+//  IJSVGCommandSmoothCurve.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandCurve.h>
+#import <IJSVG/IJSVGCommandSmoothCurve.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation IJSVGCommandSmoothCurve
+
++ (NSInteger)requiredParameterCount
+{
+    return 4;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPoint firstControl = CGPointMake(currentPoint.x, currentPoint.y);
+    if(command != nil) {
+        if(command.class == [IJSVGCommandCurve class] || command.class == self.class) {
+            if(command.class == [IJSVGCommandCurve class]) {
+                if(command.type == kIJSVGCommandTypeAbsolute) {
+                    firstControl = CGPointMake(-1 * command.parameters[2] + 2 * currentPoint.x,
+                        -1 * command.parameters[3] + 2 * currentPoint.y);
+                } else {
+                    NSPoint oldPoint = CGPointMake(currentPoint.x - command.parameters[4],
+                        currentPoint.y - command.parameters[5]);
+                    firstControl = CGPointMake(-1 * (command.parameters[2] + oldPoint.x) + 2 * currentPoint.x,
+                        -1 * (command.parameters[3] + oldPoint.y) + 2 * currentPoint.y);
+                }
+            } else {
+                if(command.type == kIJSVGCommandTypeAbsolute) {
+                    firstControl = CGPointMake(-1 * command.parameters[0] + 2 * currentPoint.x,
+                        -1 * command.parameters[1] + 2 * currentPoint.y);
+                } else {
+                    NSPoint oldPoint = CGPointMake(currentPoint.x - command.parameters[2],
+                        currentPoint.y - command.parameters[3]);
+                    firstControl = CGPointMake(-1 * (command.parameters[0] + oldPoint.x) + 2 * currentPoint.x,
+                        -1 * (command.parameters[1] + oldPoint.y) + 2 * currentPoint.y);
+                }
+            }
+        }
+    }
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddCurveToPoint(path, NULL, firstControl.x, firstControl.y,
+                              params[0], params[1], params[2], params[3]);
+        return;
+    }
+    CGPathAddCurveToPoint(path, NULL, firstControl.x, firstControl.y,
+                          currentPoint.x + params[0], currentPoint.y + params[1],
+                          currentPoint.x + params[2], currentPoint.y + params[3]);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandSmoothQuadraticCurve.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandSmoothQuadraticCurve : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandSmoothQuadraticCurve.m

@@ -0,0 +1,58 @@
+//
+//  IJSVGCommandCommandQuadraticCurve.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGCommandQuadraticCurve.h>
+#import <IJSVG/IJSVGCommandSmoothQuadraticCurve.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation IJSVGCommandSmoothQuadraticCurve
+
++ (NSInteger)requiredParameterCount
+{
+    return 2;
+}
+
++ (void)runWithParams:(CGFloat*)params
+           paramCount:(NSInteger)count
+              command:(IJSVGCommand*)currentCommand
+      previousCommand:(IJSVGCommand*)command
+                 type:(IJSVGCommandType)type
+                 path:(CGMutablePathRef)path
+{
+    CGPoint lastControlPoint = IJSVGPathGetLastQuadraticCommandPoint(path);
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPoint commandPoint = CGPointMake(currentPoint.x, currentPoint.y);
+    if(command != nil) {
+        if(command.class == IJSVGCommandQuadraticCurve.class) {
+            // quadratic curve
+            if(command.type == kIJSVGCommandTypeAbsolute) {
+                commandPoint = NSMakePoint(-1 * command.parameters[0] + 2 * currentPoint.x,
+                    -1 * command.parameters[1] + 2 * currentPoint.y);
+            } else {
+                CGPoint oldPoint = CGPointMake(currentPoint.x - command.parameters[2],
+                    currentPoint.y - command.parameters[3]);
+                commandPoint = CGPointMake(-1 * (command.parameters[0] + oldPoint.x) + 2 * (currentPoint.x),
+                    -1 * (command.parameters[1] + oldPoint.y) + 2 * currentPoint.y);
+            }
+        } else if(command.class == self.class) {
+            // smooth quadratic curve
+            commandPoint = CGPointMake(-1 * (lastControlPoint.x) + 2 * (currentPoint.x),
+                -1 * (lastControlPoint.y) + 2 * currentPoint.y);
+        }
+    }
+//    path.lastControlPoint = commandPoint;
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddQuadCurveToPoint(path, NULL, commandPoint.x, commandPoint.y,
+                                  params[0], params[1]);
+        return;
+    }
+    CGPathAddQuadCurveToPoint(path, NULL, commandPoint.x, commandPoint.y,
+                              currentPoint.x + params[0], currentPoint.y + params[1]);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandVerticalLine.h

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommand.h"
+#import <IJSVG/IJSVGCommand.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGCommandVerticalLine : IJSVGCommand

Framework/IJSVG/IJSVG/Source/Commands/IJSVGCommandVerticalLine.m

@@ -6,7 +6,7 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGCommandVerticalLine.h"
+#import <IJSVG/IJSVGCommandVerticalLine.h>
 
 @implementation IJSVGCommandVerticalLine
 
@@ -20,13 +20,14 @@
               command:(IJSVGCommand*)currentCommand
       previousCommand:(IJSVGCommand*)command
                  type:(IJSVGCommandType)type
-                 path:(IJSVGPath*)path
+                 path:(CGMutablePathRef)path
 {
-    if (type == IJSVGCommandTypeAbsolute) {
-        [[path currentSubpath] lineToPoint:NSMakePoint([path currentSubpath].currentPoint.x, params[0])];
+    if(type == kIJSVGCommandTypeAbsolute) {
+        CGPathAddLineToPoint(path, NULL, CGPathGetCurrentPoint(path).x, params[0]);
         return;
     }
-    [[path currentSubpath] relativeLineToPoint:NSMakePoint(0.f, params[0])];
+    CGPoint currentPoint = CGPathGetCurrentPoint(path);
+    CGPathAddLineToPoint(path, NULL, currentPoint.x, currentPoint.y + params[0]);
 }
 
 @end

Framework/IJSVG/IJSVG/Source/Core/IJSVG.h

@@ -0,0 +1,162 @@
+//
+//  IJSVGImage.h
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGTraitedColorStorage.h>
+#import <IJSVG/IJSVGRootNode.h>
+#import <IJSVG/IJSVGExporter.h>
+#import <IJSVG/IJSVGGradientLayer.h>
+#import <IJSVG/IJSVGGroupLayer.h>
+#import <IJSVG/IJSVGRootLayer.h>
+#import <IJSVG/IJSVGImageLayer.h>
+#import <IJSVG/IJSVGLayerTree.h>
+#import <IJSVG/IJSVGParser.h>
+#import <IJSVG/IJSVGRendering.h>
+#import <IJSVG/IJSVGStyle.h>
+#import <IJSVG/IJSVGTransaction.h>
+#import <Foundation/Foundation.h>
+
+@class IJSVG;
+@class IJSVGParser;
+
+@interface IJSVG : NSObject <NSPasteboardWriting> {
+
+@private
+    IJSVGRootNode* _rootNode;
+    IJSVGLayerTree* _layerTree;
+    CGRect _viewBox;
+    CGFloat _backingScale;
+    IJSVGUnitSize* _intrinsicSize;
+    IJSVGParser* _parser;
+}
+
+// set this to be called when the layer is about to draw, it will call this
+// and ask for the scale of the backing store where its going to be drawn
+// and apply the scale to each layer that has custom drawing against it, mainly
+// pattern and gradient layers
+@property (nonatomic, copy) IJSVGRenderingBackingScaleFactorHelper renderingBackingScaleHelper;
+
+// global overwriting rules for when rendering an SVG, this will overide any
+// fillColor, strokeColor, pattern and gradient fill
+@property (nonatomic, assign) IJSVGRenderQuality renderQuality;
+@property (nonatomic, strong) IJSVGStyle* style;
+
+@property (nonatomic, copy) NSString* title;
+@property (nonatomic, copy) NSString* desc;
+@property (nonatomic, strong) IJSVGLayerTree* layerTree;
+@property (nonatomic, strong) IJSVGRootLayer* rootLayer;
+@property (nonatomic, assign) BOOL ignoreIntrinsicSize;
+
+@property (nonatomic, readonly) IJSVGTraitedColorStorage* colors;
+
+// The size of the SVG either computed by its intrinsicSize of its viewBox
+// If the size if % values, it will use the defaultSize
+@property (nonatomic, readonly) CGSize size;
+
+// Will return true if the intrinsic size is a % value
+@property (nonatomic, readonly) BOOL hasDynamicSize;
+
+// This is used when the intrinsic size is a % value, e.g. 100% x 100%
+@property (nonatomic, assign) CGSize defaultSize;
+
+// bitmask of which dimentions were implicitly set on the SVG
+@property (nonatomic, readonly) IJSVGIntrinsicDimensions intrinsicDimensions;
+
+- (void)prepForDrawingInView:(NSView*)view;
+- (IJSVGRootNode*)rootNode;
+- (CGRect)viewBox;
+- (CGSize)sizeWithDefaultSize:(CGSize)size;
+- (CGSize)sizeByMaintainingAspectRatioWithSize:(CGSize)aSize;
+- (NSString*)identifier;
+- (NSSet<IJSVG*>*)directDescendSVGs;
+- (IJSVGExporter*)exporterWithSize:(CGSize)size
+                           options:(IJSVGExporterOptions)options
+              floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+- (NSString*)SVGStringWithSize:(CGSize)size
+                       options:(IJSVGExporterOptions)options;
+- (NSString*)SVGStringWithSize:(CGSize)size
+                       options:(IJSVGExporterOptions)options
+          floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+- (NSString*)SVGStringWithOptions:(IJSVGExporterOptions)options;
+- (NSString*)SVGStringWithOptions:(IJSVGExporterOptions)options
+             floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+
++ (id)SVGNamed:(NSString*)string;
+
++ (IJSVG*)SVGFromCGPathRef:(CGPathRef)path;
++ (IJSVG*)SVGFromCGPathRef:(CGPathRef)path
+                   flipped:(BOOL)flipped;
+
+
+- (id)initWithImage:(NSImage*)image;
+- (id)initWithRootNode:(IJSVGRootNode*)rootNode;
+
+- (id)initWithSVGLayer:(IJSVGGroupLayer*)group
+               viewBox:(CGRect)viewBox;
+
+- (id)initWithSVGString:(NSString*)string;
+- (id)initWithSVGString:(NSString*)string
+                  error:(NSError**)error;
+
+- (id)initWithSVGData:(NSData*)data;
+- (id)initWithSVGData:(NSData*)data
+                error:(NSError**)error;
+
+- (id)initWithFile:(NSString*)file;
+- (id)initWithFile:(NSString*)file
+             error:(NSError**)error;
+- (id)initWithFilePathURL:(NSURL*)aURL;
+- (id)initWithFilePathURL:(NSURL*)aURL
+                    error:(NSError**)error;
+
+- (id)initWithDataAssetNamed:(NSDataAssetName)name
+                       error:(NSError**)error;
+- (id)initWithDataAssetNamed:(NSDataAssetName)name
+                      bundle:(NSBundle*)bundle
+                       error:(NSError**)error;
+
+- (NSImage*)imageWithSize:(CGSize)aSize;
+- (NSImage*)imageWithSize:(CGSize)aSize
+                    error:(NSError**)error;
+- (NSImage*)imageWithSize:(CGSize)aSize
+                  flipped:(BOOL)flipped;
+- (NSImage*)imageWithSize:(CGSize)aSize
+                  flipped:(BOOL)flipped
+                    error:(NSError**)error;
+- (NSImage*)imageByMaintainingAspectRatioWithSize:(CGSize)aSize
+                                          flipped:(BOOL)flipped
+                                            error:(NSError**)error;
+- (CGImageRef)newCGImageRefWithSize:(CGSize)size
+                            flipped:(BOOL)flipped
+                              error:(NSError**)error;
+
+- (BOOL)drawAtPoint:(CGPoint)point
+               size:(CGSize)size;
+- (BOOL)drawAtPoint:(CGPoint)point
+               size:(CGSize)aSize
+              error:(NSError**)error;
+- (BOOL)drawInRect:(CGRect)rect;
+- (BOOL)drawInRect:(CGRect)rect
+             error:(NSError**)error;
+- (void)drawInRect:(CGRect)rect
+           context:(CGContextRef)context;
+
+- (NSData*)PDFData;
+- (NSData*)PDFData:(NSError**)error;
+- (NSData*)PDFDataWithRect:(CGRect)rect;
+- (NSData*)PDFDataWithRect:(CGRect)rect
+                     error:(NSError**)error;
+
+// call this to invalidate the render tree when you change the style
+- (void)setNeedsDisplay;
+
+// colors
+- (void)performBlock:(dispatch_block_t)block;
+
+// matching
+- (BOOL)containsNodesMatchingTraits:(IJSVGNodeTraits)mask;
+@end

Framework/IJSVG/IJSVG/Source/Core/IJSVG.m

@@ -0,0 +1,747 @@
+//
+//  IJSVGImage.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVG.h>
+#import <IJSVG/IJSVGExporter.h>
+#import <IJSVG/IJSVGTransaction.h>
+#import <IJSVG/IJSVGThreadManager.h>
+
+@interface IJSVG (private)
+@property (nonatomic, strong) IJSVGParser* parser;
+@end
+
+@implementation IJSVG
+
+// these are explicitly implemented
+@synthesize title = _title;
+@synthesize desc = _desc;
+
+- (void)dealloc
+{
+    // thread manager will deal with this for us, but if we are main thread,
+    // we want to kick this off as soon as possible, or if the memory is set
+    // to quick.
+    IJSVGThreadManager* threadManager = IJSVGThreadManager.currentManager;
+    BOOL flag = IJSVGBeginTransaction();
+    _layerTree = nil;
+    _rootLayer = nil;
+    if(flag == YES) {
+        IJSVGEndTransaction();
+    }
+    
+    // tell the thread manager we are done with
+    [threadManager remove:self];
+}
+
++ (id)SVGNamed:(NSString*)string
+{
+    return [self.class SVGNamed:string
+                          error:nil];
+}
+
++ (id)SVGNamed:(NSString*)string
+         error:(NSError**)error
+{
+    NSBundle* bundle = NSBundle.mainBundle;
+    NSString* str = nil;
+    NSString* ext = [string pathExtension];
+    if(ext == nil || ext.length == 0) {
+        ext = @"svg";
+    }
+    if((str = [bundle pathForResource:[string stringByDeletingPathExtension]
+                                ofType:ext]) != nil) {
+        return [[self alloc] initWithFile:str
+                                    error:error];
+    }
+    
+    // check the asset catalogues
+    return [[self alloc] initWithDataAssetNamed:string
+                                           error:error];
+}
+
++ (IJSVG*)SVGFromCGPathRef:(CGPathRef)path
+{
+    return [self SVGFromCGPathRef:path
+                          flipped:NO];
+}
+
++ (IJSVG*)SVGFromCGPathRef:(CGPathRef)path
+                   flipped:(BOOL)flipped
+{
+    CGRect box = CGPathGetPathBoundingBox(path);
+    IJSVGRootNode* rootNode = [[IJSVGRootNode alloc] init];
+    rootNode.viewBox = [IJSVGUnitRect rectWithCGRect:box];
+    CGMutablePathRef nPath = NULL;
+    if(flipped) {
+        CGPathRef transformedPath = [IJSVGUtils newFlippedCGPath:path];
+        nPath = CGPathCreateMutableCopy(transformedPath);
+        CGPathRelease(transformedPath);
+    } else {
+        nPath = CGPathCreateMutableCopy(path);
+    }
+    IJSVGPath* childPath = [[IJSVGPath alloc] init];
+    childPath.path = nPath;
+    [rootNode addChild:childPath];
+    CGPathRelease(nPath);
+    return [[self.class alloc] initWithRootNode:rootNode];
+}
+
+- (id)initWithDataAssetNamed:(NSDataAssetName)name
+                       error:(NSError**)error
+{
+    return [self initWithDataAssetNamed:name
+                                 bundle:NSBundle.mainBundle
+                                  error:error];
+}
+
+- (id)initWithDataAssetNamed:(NSDataAssetName)name
+                      bundle:(NSBundle*)bundle
+                       error:(NSError**)error
+{
+    NSDataAsset* dataAsset = [[NSDataAsset alloc] initWithName:name
+                                                         bundle:bundle];
+    if(dataAsset != nil) {
+        return [self initWithSVGData:dataAsset.data
+                                error:error];
+    }
+    return nil;
+}
+
+- (id)initWithImage:(NSImage*)image
+{
+    IJSVGRootNode* rootNode = [[IJSVGRootNode alloc] init];
+    IJSVGImage* imageNode = [[IJSVGImage alloc] init];
+    imageNode.image = image;
+    IJSVGUnitSize* size = [IJSVGUnitSize sizeWithCGSize:imageNode.intrinsicSize];
+    IJSVGUnitRect* viewBox = [IJSVGUnitRect rectWithOrigin:IJSVGUnitPoint.zeroPoint
+                                                      size:size];
+    imageNode.width = size.width.copy;
+    imageNode.height = size.height.copy;
+    rootNode.viewBox = viewBox;
+    [rootNode addChild:imageNode];
+    return [self initWithRootNode:rootNode];
+}
+
+- (id)initWithSVGLayer:(IJSVGGroupLayer*)group
+               viewBox:(CGRect)viewBox
+{
+    // this completely bypasses passing of files
+    if((self = [super init]) != nil) {
+        // keep the layer tree
+        _viewBox = viewBox;
+
+        // any setups
+        [self _setupBasicsFromAnyInitializer];
+    }
+    return self;
+}
+
+- (id)initWithRootNode:(IJSVGRootNode*)rootNode
+{
+    if((self = [super init]) != nil) {
+        _rootNode = rootNode;
+        [self _setupBasicInfoFromGroup];
+        [self _setupBasicsFromAnyInitializer];
+    }
+    return self;
+}
+
+- (id)initWithFile:(NSString*)file
+{
+    return [self initWithFile:file
+                        error:nil];
+}
+
+- (id)initWithFile:(NSString*)file
+             error:(NSError**)error
+{
+    return [self initWithFilePathURL:[NSURL fileURLWithPath:file isDirectory:NO]
+                               error:error];
+}
+
+- (id)initWithFilePathURL:(NSURL*)aURL
+{
+    return [self initWithFilePathURL:aURL
+                               error:nil];
+}
+
+- (id)initWithFilePathURL:(NSURL*)aURL
+                    error:(NSError**)error
+{
+    // create the object
+    if((self = [super init]) != nil) {
+        NSError* anError = nil;
+
+        // create the group
+        IJSVGParser *parser = [IJSVGParser parserForFileURL:aURL
+                                                      error:&anError];
+        self.parser = parser;
+      
+        [self _setupBasicInfoFromGroup];
+        [self _setupBasicsFromAnyInitializer];
+
+        // something went wrong...
+        if(_rootNode == nil) {
+            if(error != NULL) {
+                *error = anError;
+            }
+            self = nil;
+            return nil;
+        }
+    }
+    return self;
+}
+
+- (id)initWithSVGData:(NSData*)data
+{
+    return [self initWithSVGData:data
+                           error:nil];
+}
+
+- (void)setParser:(IJSVGParser*)parser {
+    _rootNode = [parser rootNodeWithSize:CGSizeZero];
+  
+    // if the rootNode has any form of relative units, we need to keep hold of
+    // the parser so when we render, we can ask for new values.
+    if(_rootNode.viewBoxContainsRelativeUnits) {
+      _parser = parser;
+    }
+}
+
+- (id)initWithSVGData:(NSData*)data
+                error:(NSError**)error
+{
+    NSString* svgString = [[NSString alloc] initWithData:data
+                                                encoding:NSUTF8StringEncoding];
+    return [self initWithSVGString:svgString
+                             error:error];
+}
+
+- (id)initWithSVGString:(NSString*)string
+{
+    return [self initWithSVGString:string
+                             error:nil];
+}
+
+- (id)initWithSVGString:(NSString*)string
+                  error:(NSError**)error
+{
+    if((self = [super init]) != nil) {
+        // this is basically the same as init with URL just
+        // bypasses the loading of a file
+        NSError* anError = nil;
+
+        // setup the parser
+        IJSVGParser* parser = [[IJSVGParser alloc] initWithSVGString:string
+                                                               error:&anError];
+        self.parser = parser;
+      
+        [self _setupBasicInfoFromGroup];
+        [self _setupBasicsFromAnyInitializer];
+
+        // something went wrong :(
+        if(_rootNode == nil) {
+            if(error != NULL) {
+                *error = anError;
+            }
+            self = nil;
+            return nil;
+        }
+    }
+    return self;
+}
+
+- (void)performBlock:(dispatch_block_t)block
+{
+    IJSVGPerformTransactionBlock(^{
+        block();
+    });
+}
+
+- (void)_setupBasicInfoFromGroup
+{
+    _viewBox = [_rootNode.viewBox computeValue:CGSizeZero];
+    _intrinsicSize = _rootNode.intrinsicSize;
+}
+
+- (CGSize)size
+{
+    return [_intrinsicSize computeValue:self.defaultSize];
+}
+
+- (CGSize)sizeWithDefaultSize:(CGSize)size
+{
+    return [_intrinsicSize computeValue:size];
+}
+
+- (void)_setupBasicsFromAnyInitializer
+{
+    self.style = [[IJSVGStyle alloc] init];
+    self.ignoreIntrinsicSize = YES;
+    self.renderQuality = kIJSVGRenderQualityFullResolution;
+    self.defaultSize = CGSizeMake(200.f, 200.f);
+    self.renderingBackingScaleHelper = ^CGFloat {
+        if(NSScreen.mainScreen != nil) {
+            return NSScreen.mainScreen.backingScaleFactor;
+        }
+        return 1.f;
+    };
+    
+    // tell the thread manager we exist
+    [IJSVGThreadManager.currentManager adopt:self];
+}
+
+- (BOOL)hasDynamicSize
+{
+    IJSVGUnitSize* size = _intrinsicSize;
+    return size.width.type == IJSVGUnitLengthTypePercentage ||
+        size.height.type == IJSVGUnitLengthTypePercentage;
+}
+
+- (IJSVGIntrinsicDimensions)intrinsicDimensions
+{
+    return self.rootNode.intrinsicDimensions;
+}
+
+- (void)setTitle:(NSString*)title
+{
+    _rootNode.title = title;
+}
+
+- (NSString*)title
+{
+    return _rootNode.title;
+}
+
+- (void)setDesc:(NSString*)description
+{
+    _rootNode.desc = description;
+}
+
+- (NSString*)desc
+{
+    return _rootNode.desc;
+}
+
+- (NSString*)identifier
+{
+    return _rootNode.identifier;
+}
+
+
+- (CGRect)viewBox
+{
+    return _viewBox;
+}
+
+- (IJSVGRootNode*)rootNode
+{
+    return _rootNode;
+}
+
+- (NSSet<IJSVG*>*)directDescendSVGs
+{
+    NSMutableSet<IJSVG*>* svgs = [[NSMutableSet alloc] init];
+    NSSet<IJSVGNode*>* nodes = [self.rootNode childrenOfType:IJSVGNodeTypeSVG];
+    for(IJSVGNode* node in nodes) {
+        IJSVG* newSVG = nil;
+        newSVG = [[self.class alloc] initWithRootNode:(IJSVGRootNode*)node];
+        [svgs addObject:newSVG];
+    }
+    return svgs;
+}
+
+- (IJSVGExporter*)exporterWithSize:(CGSize)size
+                           options:(IJSVGExporterOptions)options
+              floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    return [[IJSVGExporter alloc] initWithSVG:self
+                                         size:size
+                                      options:options
+                         floatingPointOptions:floatingPointOptions];
+}
+
+- (NSString*)SVGStringWithOptions:(IJSVGExporterOptions)options
+{
+    IJSVGFloatingPointOptions fpo = IJSVGFloatingPointOptionsDefault();
+    return [self exporterWithSize:_viewBox.size
+                          options:options
+                floatingPointOptions:fpo].SVGString;
+}
+
+- (NSString*)SVGStringWithOptions:(IJSVGExporterOptions)options
+             floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    return [self exporterWithSize:_viewBox.size
+                          options:options
+             floatingPointOptions:floatingPointOptions].SVGString;
+}
+
+- (NSString *)SVGStringWithSize:(CGSize)size
+                        options:(IJSVGExporterOptions)options
+{
+    IJSVGFloatingPointOptions fpo = IJSVGFloatingPointOptionsDefault();
+    return [self exporterWithSize:size
+                          options:options
+             floatingPointOptions:fpo].SVGString;
+}
+
+- (NSString *)SVGStringWithSize:(CGSize)size
+                        options:(IJSVGExporterOptions)options
+           floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    return [self exporterWithSize:size
+                          options:options
+             floatingPointOptions:floatingPointOptions].SVGString;
+}
+
+- (NSImage*)imageWithSize:(CGSize)aSize
+{
+    return [self imageWithSize:aSize
+                       flipped:NO
+                         error:nil];
+}
+
+- (NSImage*)imageWithSize:(CGSize)aSize
+                    error:(NSError**)error;
+{
+    return [self imageWithSize:aSize
+                       flipped:NO
+                         error:error];
+}
+
+- (NSImage*)imageWithSize:(CGSize)aSize
+                  flipped:(BOOL)flipped
+{
+    return [self imageWithSize:aSize
+                       flipped:flipped
+                         error:nil];
+}
+
+- (CGImageRef)newCGImageRefWithSize:(CGSize)size
+                            flipped:(BOOL)flipped
+                              error:(NSError**)error
+{
+    // setup the drawing rect, this is used for both the intial drawing
+    // and the backing scale helper block
+    CGRect rect = (CGRect) {
+        .origin = CGPointZero,
+        .size = (CGSize)size
+    };
+
+    // make sure we setup the scale based on the backing scale factor
+    CGFloat scale = [self backingScaleFactor];
+
+    // create the context and colorspace
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    CGContextRef ref = CGBitmapContextCreate(NULL, (int)size.width * scale,
+        (int)size.height * scale, 8, 0, colorSpace,
+        kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little);
+
+    // scale the context
+    CGContextScaleCTM(ref, scale, scale);
+
+    if(flipped == YES) {
+        CGContextTranslateCTM(ref, 0.f, size.height);
+        CGContextScaleCTM(ref, 1.f, -1.f);
+    }
+
+    // draw the SVG into the context
+    [self _drawInRect:rect
+              context:ref
+                error:error];
+
+    // create the image from the context
+    CGImageRef imageRef = CGBitmapContextCreateImage(ref);
+
+    // release all things!
+    CGColorSpaceRelease(colorSpace);
+    CGContextRelease(ref);
+    return imageRef;
+}
+
+- (NSImage*)imageWithSize:(CGSize)aSize
+                  flipped:(BOOL)flipped
+                    error:(NSError**)error
+{
+    CGImageRef ref = [self newCGImageRefWithSize:aSize
+                                         flipped:flipped
+                                           error:error];
+
+    NSImage* image = [[NSImage alloc] initWithCGImage:ref
+                                                 size:aSize];
+    CGImageRelease(ref);
+    return image;
+}
+
+- (CGSize)sizeByMaintainingAspectRatioWithSize:(CGSize)aSize
+{
+    CGSize ogSize = [_rootNode.intrinsicSize computeValue:aSize];
+    CGFloat ratio = 0.f;
+    CGFloat imageWidth = ogSize.width;
+    CGFloat imageHeight = ogSize.height;
+    CGFloat maxWidth = aSize.width;
+    CGFloat maxHeight = aSize.height;
+    if(imageWidth > imageHeight) {
+        ratio = maxWidth / imageWidth;
+    } else {
+        ratio = maxHeight / imageHeight;
+    }
+    ogSize.width = ceilf(imageWidth * ratio);
+    ogSize.height = ceilf(imageHeight * ratio);
+    return ogSize;
+}
+
+- (NSImage*)imageByMaintainingAspectRatioWithSize:(CGSize)aSize
+                                          flipped:(BOOL)flipped
+                                            error:(NSError**)error
+{
+    CGSize ogSize = [self sizeByMaintainingAspectRatioWithSize:aSize];
+    return [self imageWithSize:ogSize
+                       flipped:flipped
+                         error:error];
+}
+
+- (NSData*)PDFData
+{
+    return [self PDFData:nil];
+}
+
+- (NSData*)PDFData:(NSError**)error
+{
+    return [self
+        PDFDataWithRect:(CGRect) { .origin = NSZeroPoint, .size = _viewBox.size }
+                  error:error];
+}
+
+- (NSData*)PDFDataWithRect:(CGRect)rect
+{
+    return [self PDFDataWithRect:rect error:nil];
+}
+
+- (NSData*)PDFDataWithRect:(CGRect)rect
+                     error:(NSError**)error
+{
+    // create the data for the PDF
+    NSMutableData* data = [[NSMutableData alloc] init];
+
+    // assign the data to the consumer
+    CGDataConsumerRef dataConsumer = CGDataConsumerCreateWithCFData((CFMutableDataRef)data);
+    const CGRect box = CGRectMake(rect.origin.x, rect.origin.y, rect.size.width,
+        rect.size.height);
+
+    // create the context
+    CGContextRef context = CGPDFContextCreate(dataConsumer, &box, NULL);
+
+    CGContextBeginPage(context, &box);
+
+    // the context is currently upside down, doh! flip it...
+    CGContextScaleCTM(context, 1, -1);
+    CGContextTranslateCTM(context, 0, -box.size.height);
+
+    // make sure we set the masks to path bits n bobs
+    // draw the icon
+    [self _drawInRect:(CGRect)box
+              context:context
+                error:error];
+
+    CGContextEndPage(context);
+
+    // clean up
+    CGPDFContextClose(context);
+    CGContextRelease(context);
+    CGDataConsumerRelease(dataConsumer);
+    return data;
+}
+
+- (void)prepForDrawingInView:(NSView*)view
+{
+    // kill the render
+    if(view == nil) {
+        self.renderingBackingScaleHelper = nil;
+        return;
+    }
+
+    // construct the layer before drawing
+    [self rootLayer];
+
+    // set the scale
+    __weak NSView* weakView = view;
+    self.renderingBackingScaleHelper = ^CGFloat {
+        return weakView.window.screen.backingScaleFactor;
+    };
+}
+
+- (BOOL)drawAtPoint:(CGPoint)point
+               size:(CGSize)aSize
+{
+    return [self drawAtPoint:point
+                        size:aSize
+                       error:nil];
+}
+
+- (BOOL)drawAtPoint:(CGPoint)point
+               size:(CGSize)aSize
+              error:(NSError**)error
+{
+    return [self drawInRect:NSMakeRect(point.x, point.y,
+                                       aSize.width, aSize.height)
+                      error:error];
+}
+
+- (BOOL)drawInRect:(CGRect)rect
+{
+    return [self drawInRect:rect error:nil];
+}
+
+- (BOOL)drawInRect:(CGRect)rect
+             error:(NSError**)error
+{
+    CGContextRef currentCGContext;
+    currentCGContext = NSGraphicsContext.currentContext.CGContext;
+    return [self _drawInRect:rect
+                     context:currentCGContext
+                       error:error];
+}
+
+- (void)drawInRect:(CGRect)rect
+           context:(CGContextRef)context
+{
+    [self _drawInRect:rect
+              context:context
+                error:nil];
+}
+
+- (BOOL)_drawInRect:(CGRect)rect
+            context:(CGContextRef)ctx
+              error:(NSError**)error
+{
+    BOOL transaction = IJSVGBeginTransaction();
+    CGContextSaveGState(ctx);
+    CGFloat backingScale = MAX([self backingScaleFactor], 1.f);
+    CGInterpolationQuality quality;
+    switch (_renderQuality) {
+        case kIJSVGRenderQualityLow: {
+            quality = kCGInterpolationLow;
+            break;
+        }
+        case kIJSVGRenderQualityOptimized: {
+            quality = kCGInterpolationMedium;
+            break;
+        }
+        default: {
+            quality = kCGInterpolationHigh;
+        }
+    }
+    CGContextSetInterpolationQuality(ctx, quality);
+    IJSVGRootLayer* rootLayer = [self rootLayerWithRect:rect];
+    [rootLayer renderInContext:ctx
+                      viewPort:rect
+                  backingScale:backingScale
+                       quality:_renderQuality
+           ignoreIntrinsicSize:_ignoreIntrinsicSize];
+    CGContextRestoreGState(ctx);
+    if(transaction == YES) {
+        IJSVGEndTransaction();
+    }
+    return YES;
+}
+
+- (IJSVGLayerTree*)layerTree
+{
+    if(_layerTree == nil) {
+        _layerTree = [[IJSVGLayerTree alloc] init];
+        _layerTree.style = _style;
+    }
+    return _layerTree;
+}
+
+- (IJSVGRootLayer*)rootLayerWithRect:(CGRect)rect {
+  // no parser, which means there is no need to recompute the value
+  if(_parser == nil || !_rootNode.viewBoxContainsRelativeUnits ||
+     CGSizeEqualToSize(_rootNode.clientSize, rect.size)) {
+    return self.rootLayer;
+  }
+  
+  // if we do have a parser, that means the node has relative values, lets recompute
+  __weak IJSVG* weakSelf = self;
+  [self performBlock:^{
+    IJSVG* strongSelf = weakSelf;
+    strongSelf->_rootNode = [strongSelf->_parser rootNodeWithSize:rect.size];
+    strongSelf->_rootLayer = [strongSelf.layerTree rootLayerForRootNode:strongSelf->_rootNode];
+  }];
+  return _rootLayer;
+}
+
+- (IJSVGRootLayer*)rootLayer
+{
+  if(_rootLayer != nil) {
+    return _rootLayer;
+  }
+  
+  __weak IJSVG* weakSelf = self;
+  [self performBlock:^{
+      IJSVG* strongSelf = weakSelf;
+      strongSelf->_rootLayer = [strongSelf.layerTree rootLayerForRootNode:strongSelf->_rootNode];
+  }];
+  return _rootLayer;
+}
+
+- (CGFloat)backingScaleFactor
+{
+    __block CGFloat scale = 1.f;
+    if(self.renderingBackingScaleHelper != nil) {
+        scale = (self.renderingBackingScaleHelper)();
+    }
+    scale = MAX(1.f, scale);
+    return _backingScale = scale;
+}
+
+- (void)setNeedsDisplay
+{
+    [self invalidateLayerTree];
+}
+
+- (void)invalidateLayerTree
+{
+    __weak IJSVG* weakSelf = self;
+    [self performBlock:^{
+        IJSVG* strongSelf = weakSelf;
+        strongSelf->_rootLayer = nil;
+        strongSelf->_layerTree = nil;
+    }];
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    return self.rootLayer.colors;
+}
+
+#pragma mark NSPasteboard
+
+- (NSArray*)writableTypesForPasteboard:(NSPasteboard*)pasteboard
+{
+    return @[ NSPasteboardTypePDF ];
+}
+
+- (id)pasteboardPropertyListForType:(NSString*)type
+{
+    if([type isEqualToString:NSPasteboardTypePDF]) {
+        return [self PDFData];
+    }
+    return nil;
+}
+
+#pragma mark matching
+
+- (BOOL)containsNodesMatchingTraits:(IJSVGNodeTraits)traits
+{
+    return [_rootNode containsNodesMatchingTraits:traits];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Core/IJSVGImageRep.h

@@ -6,7 +6,7 @@
 //  Copyright © 2019 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGParser.h"
+#import <IJSVG/IJSVGParser.h>
 #import <Cocoa/Cocoa.h>
 
 @class IJSVG;
@@ -17,6 +17,9 @@
     IJSVG* _svg;
 }
 
+- (instancetype)initWithData:(NSData*)data;
+
 @property (nonatomic, readonly) CGRect viewBox;
+@property (nonatomic, readonly) IJSVG* SVG;
 
 @end

Framework/IJSVG/IJSVG/Source/Core/IJSVGImageRep.m

@@ -6,13 +6,11 @@
 //  Copyright © 2019 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVG.h"
-#import "IJSVGImageRep.h"
+#import <IJSVG/IJSVG.h>
+#import <IJSVG/IJSVGImageRep.h>
 
 @implementation IJSVGImageRep
 
-@synthesize viewBox = _viewBox;
-
 + (void)load
 {
     [NSBitmapImageRep registerImageRepClass:self];
@@ -25,18 +23,26 @@
 
 + (NSArray<NSString*>*)imageTypes
 {
-    return @[ (NSString*)kUTTypeScalableVectorGraphics, @"svg" ];
+    if(@available(macOS 10.10, *)) {
+        return @[ (NSString*)kUTTypeScalableVectorGraphics, @"svg" ];
+    } else {
+        return @[ @"public.svg-image", @"svg" ];
+    }
 }
 
 + (NSArray<NSString*>*)imageUnfilteredTypes
 {
-    return @[ (NSString*)kUTTypeScalableVectorGraphics, @"svg" ];
+    if(@available(macOS 10.10, *)) {
+        return @[ (NSString*)kUTTypeScalableVectorGraphics, @"svg" ];
+    } else {
+        return @[ @"public.svg-image", @"svg" ];
+    }
 }
 
 + (NSArray<NSImageRep*>*)imageRepsWithData:(NSData*)data
 {
     IJSVGImageRep* instance = [self imageRepWithData:data];
-    if (instance == nil) {
+    if(instance == nil) {
         return @[];
     }
     return @[ instance ];
@@ -44,28 +50,21 @@
 
 + (instancetype)imageRepWithData:(NSData*)data
 {
-    return [[[self alloc] initWithData:data] autorelease];
-}
-
-- (void)dealloc
-{
-    (void)([_svg release]), _svg = nil;
-    [super dealloc];
+    return [[self alloc] initWithData:data];
 }
 
 - (instancetype)initWithData:(NSData*)data
 {
-    if ((self = [super init]) != nil) {
+    if((self = [super init]) != nil) {
         // grab the string from the data
         // its more then likely UTF-8...
-        NSString* string = [[[NSString alloc] initWithData:data
-                                                  encoding:NSUTF8StringEncoding] autorelease];
+        NSString* string = [[NSString alloc] initWithData:data
+                                                 encoding:NSUTF8StringEncoding];
 
         _svg = [[IJSVG alloc] initWithSVGString:string];
 
         // no valid SVG, just return nil;
-        if (_svg == nil) {
-            [self release];
+        if(_svg == nil) {
             return nil;
         }
 
@@ -101,4 +100,9 @@
     return _svg.viewBox;
 }
 
+- (IJSVG*)SVG
+{
+    return _svg;
+}
+
 @end

Framework/IJSVG/IJSVG/Source/Core/IJSVGUmbrella.h

@@ -0,0 +1,37 @@
+//
+//  IJSVGUmbrella.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 16/04/2023.
+//  Copyright © 2023 Curtis Hard. All rights reserved.
+//
+
+#ifndef IJSVGUmbrella_h
+#define IJSVGUmbrella_h
+
+#import <IJSVG/IJSVG.h>
+#import <IJSVG/IJSVGCommandClose.h>
+#import <IJSVG/IJSVGCommandCurve.h>
+#import <IJSVG/IJSVGCommandEllipticalArc.h>
+#import <IJSVG/IJSVGCommandHorizontalLine.h>
+#import <IJSVG/IJSVGCommandLineTo.h>
+#import <IJSVG/IJSVGCommandMove.h>
+#import <IJSVG/IJSVGCommandQuadraticCurve.h>
+#import <IJSVG/IJSVGCommandSmoothQuadraticCurve.h>
+#import <IJSVG/IJSVGCommandSmoothCurve.h>
+#import <IJSVG/IJSVGCommandVerticalLine.h>
+#import <IJSVG/IJSVGExporterPathInstruction.h>
+#import <IJSVG/IJSVGFeatureFlag.h>
+#import <IJSVG/IJSVGFeatureFlags.h>
+#import <IJSVG/IJSVGFilterEffectGaussianBlur.h>
+#import <IJSVG/IJSVGFilterLayer.h>
+#import <IJSVG/IJSVGImageRep.h>
+#import <IJSVG/IJSVGMath.h>
+#import <IJSVG/IJSVGParsing.h>
+#import <IJSVG/IJSVGPatternLayer.h>
+#import <IJSVG/IJSVGStrokeLayer.h>
+#import <IJSVG/IJSVGThreadManager.h>
+#import <IJSVG/IJSVGView.h>
+#import <IJSVG/NSImage+IJSVGAdditions.h>
+
+#endif /* IJSVGUmbrella_h */

Framework/IJSVG/IJSVG/Source/Core/IJSVGView.h

@@ -6,7 +6,7 @@
 //  Copyright © 2017 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVG.h"
+#import <IJSVG/IJSVG.h>
 #import <Cocoa/Cocoa.h>
 
 IB_DESIGNABLE
@@ -17,7 +17,7 @@ IB_DESIGNABLE
     IJSVG* SVG;
 }
 
-@property (nonatomic, retain) IJSVG* SVG;
+@property (nonatomic, strong) IJSVG* SVG;
 
 + (IJSVGView*)viewWithSVGNamed:(NSString*)name;
 - (id)initWithSVG:(IJSVG*)anSvg;

Framework/IJSVG/IJSVG/Source/Core/IJSVGView.m

@@ -6,7 +6,7 @@
 //  Copyright © 2017 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGView.h"
+#import <IJSVG/IJSVGView.h>
 
 @implementation IJSVGView
 
@@ -17,20 +17,17 @@
     // make sure we call this, or block may get called for a view
     // that doesnt exist
     [SVG prepForDrawingInView:nil];
-    (void)([imageName release]), imageName = nil;
-    (void)([SVG release]), SVG = nil;
-    [super dealloc];
 }
 
 + (IJSVGView*)viewWithSVGNamed:(NSString*)name
 {
-    IJSVG* anSVG = [IJSVG svgNamed:name];
-    return [[[self alloc] initWithSVG:anSVG] autorelease];
+    IJSVG* anSVG = [IJSVG SVGNamed:name];
+    return [[self alloc] initWithSVG:anSVG];
 }
 
 - (id)initWithSVG:(IJSVG*)anSvg
 {
-    if ((self = [super init]) != nil) {
+    if((self = [super init]) != nil) {
         self.SVG = anSvg;
     }
     return self;
@@ -39,9 +36,9 @@
 - (void)awakeFromNib
 {
     // image was set via IB
-    if (imageName != nil) {
-        IJSVG* anSVG = [IJSVG svgNamed:imageName];
-        if (tintColor != nil) {
+    if(imageName != nil) {
+        IJSVG* anSVG = [IJSVG SVGNamed:imageName];
+        if(tintColor != nil) {
             anSVG.style.fillColor = tintColor;
         }
         self.SVG = anSVG;
@@ -51,10 +48,7 @@
 - (void)setSVG:(IJSVG*)anSVG
 {
     // memory clean
-    if (SVG != nil) {
-        (void)([SVG release]), SVG = nil;
-    }
-    SVG = [anSVG retain];
+    SVG = anSVG;
 
     // redisplay ourself!
     [SVG prepForDrawingInView:self];
@@ -69,7 +63,7 @@
 - (void)drawRect:(NSRect)dirtyRect
 {
     // only draw if there is actually an SVG
-    if (self.SVG == nil) {
+    if(self.SVG == nil) {
         return;
     }
 

Framework/IJSVG/IJSVG/Source/Exporter/IJSVGExporter.h

@@ -0,0 +1,120 @@
+//
+//  IJSVGExporter.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 06/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <IJSVG/IJSVGTraitedColor.h>
+
+@class IJSVG;
+@class IJSVGExporter;
+@class IJSVGLayer;
+@class IJSVGNode;
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef void (^IJSVGCGPathHandler)(const CGPathElement* pathElement);
+typedef void (^IJSVGPathElementEnumerationBlock)(const CGPathElement* pathElement, CGPoint currentPoint);
+
+void IJSVGExporterPathCaller(void* info, const CGPathElement* pathElement);
+
+typedef NS_OPTIONS(NSInteger, IJSVGExporterOptions) {
+    IJSVGExporterOptionNone = 1 << 0,
+    IJSVGExporterOptionRemoveUselessGroups = 1 << 1,
+    IJSVGExporterOptionRemoveUselessDef = 1 << 2,
+    IJSVGExporterOptionMoveAttributesToGroup = 1 << 3,
+    IJSVGExporterOptionCreateUseForPaths = 1 << 4,
+    IJSVGExporterOptionSortAttributes = 1 << 5,
+    IJSVGExporterOptionCollapseGroups = 1 << 6,
+    IJSVGExporterOptionCleanupPaths = 1 << 7,
+    IJSVGExporterOptionRemoveHiddenElements = 1 << 8,
+    IJSVGExporterOptionScaleToSizeIfNecessary DEPRECATED_ATTRIBUTE = 1 << 9,
+    IJSVGExporterOptionCompressOutput = 1 << 10,
+    IJSVGExporterOptionCollapseGradients = 1 << 11,
+    IJSVGExporterOptionCreateClasses DEPRECATED_ATTRIBUTE = 1 << 12,
+    IJSVGExporterOptionRemoveWidthHeightAttributes = 1 << 13,
+    IJSVGExporterOptionColorAllowRRGGBBAA = 1 << 14,
+    IJSVGExporterOptionRemoveComments = 1 << 15,
+    IJSVGExporterOptionCenterWithinViewBox = 1 << 16,
+    IJSVGExporterOptionRemoveXMLDeclaration = 1 << 17,
+    IJSVGExporterOptionConvertArcs = 1 << 18,
+    IJSVGExporterOptionConvertShapesToPaths = 1 << 19,
+    IJSVGExporterOptionRoundTransforms = 1 << 20,
+    IJSVGExporterOptionRemoveDefaultValues = 1 << 21,
+    IJSVGExporterOptionConvertStrokesToPaths = 1 << 22,
+    IJSVGExporterOptionAll = IJSVGExporterOptionRemoveUselessDef | IJSVGExporterOptionRemoveUselessGroups |
+        IJSVGExporterOptionCreateUseForPaths | IJSVGExporterOptionMoveAttributesToGroup |
+        IJSVGExporterOptionSortAttributes | IJSVGExporterOptionCollapseGroups |
+        IJSVGExporterOptionCleanupPaths | IJSVGExporterOptionRemoveHiddenElements | IJSVGExporterOptionCompressOutput |
+        IJSVGExporterOptionCollapseGradients | IJSVGExporterOptionRemoveWidthHeightAttributes |
+        IJSVGExporterOptionColorAllowRRGGBBAA | IJSVGExporterOptionRemoveComments |
+        IJSVGExporterOptionCenterWithinViewBox | IJSVGExporterOptionRemoveXMLDeclaration |
+        IJSVGExporterOptionConvertArcs | IJSVGExporterOptionConvertShapesToPaths |
+        IJSVGExporterOptionRoundTransforms | IJSVGExporterOptionRemoveDefaultValues |
+        IJSVGExporterOptionConvertStrokesToPaths
+};
+
+BOOL IJSVGExporterHasOption(IJSVGExporterOptions options, NSInteger option);
+void IJSVGEnumerateCGPathElements(CGPathRef path, IJSVGPathElementEnumerationBlock enumBlock);
+const NSArray<NSString*>* IJSVGShortCharacterArray(void);
+const NSDictionary<NSString*, NSString*>* IJSVGDefaultAttributes(void);
+
+
+@protocol IJSVGExporterDelegate <NSObject>
+
+@optional
+- (NSString* _Nullable)svgExporter:(IJSVGExporter*)exporter
+              identifierForElement:(NSXMLElement* _Nullable)element
+                              type:(IJSVGNodeType)type
+                         defaultID:(NSString* (^)(void))defaultID;
+- (NSString* _Nullable)svgExporter:(IJSVGExporter*)exporter
+                    stringForColor:(NSColor*)color
+                             flags:(IJSVGColorUsageTraits)flag
+                           options:(IJSVGColorStringOptions)options;
+
+
+@end
+
+@interface IJSVGExporter : NSObject {
+
+@private
+    IJSVG* _svg;
+    CGSize _size;
+    IJSVGExporterOptions _options;
+    NSXMLDocument* _dom;
+    NSXMLElement* _defElement;
+    NSInteger _idCount;
+    NSInteger _shortIdCount;
+    BOOL _appliedXLink;
+    IJSVGThreadManager* _threadManager;
+    
+    struct {
+        unsigned int identifierForElement: 1;
+        unsigned int stringForColor: 1;
+    } _respondsTo;
+}
+
+@property (nonatomic, assign) id<IJSVGExporterDelegate> delegate;
+@property (nonatomic, assign) IJSVGFloatingPointOptions floatingPointOptions;
+@property (nonatomic, copy, nullable) NSString* title;
+@property (nonatomic, copy, nullable) NSString* desc;
+
+- (id)initWithSVG:(IJSVG*)svg
+             size:(CGSize)size
+          options:(IJSVGExporterOptions)options;
+- (id)initWithSVG:(IJSVG*)svg
+             size:(CGSize)size
+          options:(IJSVGExporterOptions)options
+floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+
+- (NSString*)SVGString;
+- (NSData*)SVGData;
+- (IJSVG*)SVG:(NSError**)error;
+
+@end
+
+NS_ASSUME_NONNULL_END

Framework/IJSVG/IJSVG/Source/Exporter/IJSVGExporterPathInstruction.h

@@ -0,0 +1,63 @@
+//
+//  IJSVGExporterPathInstruction.h
+//  IconJar
+//
+//  Created by Curtis Hard on 08/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface IJSVGExporterPathInstructionCommand : NSObject {
+}
+
+@property (nonatomic, assign) char instruction;
+@property (nonatomic, strong) NSArray<NSString*>* params;
+
+@end
+
+@interface IJSVGExporterPathInstruction : NSObject {
+
+@private
+    NSInteger _dataCount;
+    CGFloat* _data;
+    CGFloat* _base;
+    CGFloat* _coords;
+}
+
+@property (nonatomic, assign) char instruction;
+
+void IJSVGExporterPathInstructionRoundData(CGFloat* data, NSInteger length, IJSVGFloatingPointOptions options);
+CGFloat IJSVGExporterPathFloatToFixed(CGFloat number, int precision);
+
++ (NSArray<IJSVGExporterPathInstruction*>*)instructionsFromPath:(CGPathRef)path
+                                           floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+
+- (id)initWithInstruction:(char)instruction
+                dataCount:(NSInteger)floatCount;
+
+- (CGFloat*)data;
+- (NSInteger)dataLength;
+
++ (NSArray<IJSVGExporterPathInstruction*>*)convertInstructionsCurves:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                                                floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
++ (void)convertInstructionsToMixedAbsoluteRelative:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                              floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
++ (void)convertInstructionsDataToRounded:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                    floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
++ (void)convertInstructionsToRelativeCoordinates:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                            floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
++ (NSString*)pathStringFromInstructions:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                   floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
++ (NSString*)pathStringWithInstructionSet:(NSArray<NSValue*>*)instructionSets
+                     floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions;
+
+@end
+NS_ASSUME_NONNULL_END
+
+static NSInteger const kIJSVGExporterPathInstructionFloatPrecision = 3;
+static CGFloat const kIJSVGExporterPathInstructionErrorThreshold = 1e-2;
+
+#define IJ_SVG_EXPORT_ROUND(value) IJSVGExporterPathFloatToFixed(value, kIJSVGExporterPathInstructionFloatPrecision)

Framework/IJSVG/IJSVG/Source/Exporter/IJSVGExporterPathInstruction.m

@@ -0,0 +1,652 @@
+//
+//  IJSVGExporterPathInstruction.m
+//  IconJar
+//
+//  Created by Curtis Hard on 08/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGExporter.h>
+#import <IJSVG/IJSVGExporterPathInstruction.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <math.h>
+
+@implementation IJSVGExporterPathInstructionCommand
+@end
+
+@implementation IJSVGExporterPathInstruction
+
+@synthesize instruction = _instruction;
+
+- (void)dealloc
+{
+    if(_data != NULL) {
+        (void)free(_data), _data = NULL;
+    }
+    if(_base != NULL) {
+        (void)free(_base), _base = NULL;
+    }
+    if(_coords != NULL) {
+        (void)free(_coords), _coords = NULL;
+    }
+}
+
+- (id)initWithInstruction:(char)instruction
+                dataCount:(NSInteger)floatCount
+{
+    if((self = [super init]) != nil) {
+        _instruction = instruction;
+
+        // only allocate if not zero
+        if(floatCount != 0) {
+            _dataCount = floatCount;
+            _data = (CGFloat*)calloc(sizeof(CGFloat), floatCount);
+        }
+
+        // setup base and coords
+        _base = (CGFloat*)malloc(sizeof(CGFloat) * 2);
+        _coords = (CGFloat*)malloc(sizeof(CGFloat) * 2);
+    }
+    return self;
+}
+
+- (NSInteger)dataLength
+{
+    return _dataCount;
+}
+
+- (CGFloat*)data
+{
+    return _data;
+}
+
+- (CGFloat*)base
+{
+    return _base;
+}
+
+- (CGFloat*)coords
+{
+    return _coords;
+}
+
++ (NSString*)pathStringWithInstructionSet:(NSArray<IJSVGExporterPathInstructionCommand*>*)instructionSets
+                     floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    IJSVGExporterPathInstructionCommand* lastCommand = NULL;
+    NSMutableString* string = [[NSMutableString alloc] init];
+    for (IJSVGExporterPathInstructionCommand* command in instructionSets) {
+        // read back the bytes
+
+        // add on the instruction character only if there is no current command
+        // or the last command is not the same as the current command
+        // if they both are the same, we still need to seperate them via a space
+        if(lastCommand == nil || (lastCommand != nil && lastCommand.instruction != command.instruction)) {
+            [string appendFormat:@"%c", command.instruction];
+        } else {
+            [string appendString:@" "];
+        }
+
+        // compresses the floats
+        NSString* compressedFloats = IJSVGCompressFloatParameterArray(command.params);
+        [string appendString:compressedFloats];
+
+        // store last command
+        lastCommand = command;
+    }
+    return string;
+}
+
++ (NSString*)pathStringFromInstructions:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                   floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    NSMutableArray* pathInstructions = [[NSMutableArray alloc] init];
+    for (IJSVGExporterPathInstruction* instruction in instructions) {
+        CGFloat* data = instruction.data;
+        const char lowerInstruction = tolower(instruction.instruction);
+        NSArray<NSString*>* set = nil;
+        switch (lowerInstruction) {
+        case 't':
+        case 'm':
+        case 'l': {
+            set = @[
+                IJSVGShortFloatStringWithOptions(data[0], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[1], floatingPointOptions)
+            ];
+            break;
+        }
+
+        case 'v':
+        case 'h': {
+            set = @[
+                IJSVGShortFloatStringWithOptions(data[0], floatingPointOptions)
+            ];
+            break;
+        }
+
+        case 'c': {
+            set = @[
+                IJSVGShortFloatStringWithOptions(data[0], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[1], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[2], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[3], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[4], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[5], floatingPointOptions)
+            ];
+            break;
+        }
+
+        case 's':
+        case 'q': {
+            set = @[
+                IJSVGShortFloatStringWithOptions(data[0], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[1], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[2], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[3], floatingPointOptions)
+            ];
+            break;
+        }
+
+        case 'a': {
+            set = @[
+                IJSVGShortFloatStringWithOptions(data[0], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[1], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[2], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[3], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[4], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[5], floatingPointOptions),
+                IJSVGShortFloatStringWithOptions(data[6], floatingPointOptions),
+            ];
+            break;
+        }
+
+            // close path
+        case 'z': {
+            set = @[];
+        }
+        }
+
+        // wrap into the command and give to the array
+        IJSVGExporterPathInstructionCommand* wrapperCommand = nil;
+        wrapperCommand = [[IJSVGExporterPathInstructionCommand alloc] init];
+        wrapperCommand.instruction = instruction.instruction;
+        wrapperCommand.params = set ?: @[];
+        [pathInstructions addObject:wrapperCommand];
+    }
+    return [self pathStringWithInstructionSet:pathInstructions
+                         floatingPointOptions:floatingPointOptions];
+}
+
+CGFloat IJSVGExporterPathFloatToFixed(CGFloat number, int precision)
+{
+    return floorf(pow(10, precision) * number) / pow(10, precision);
+}
+
+void IJSVGExporterPathInstructionRoundData(CGFloat* data, NSInteger length,
+    IJSVGFloatingPointOptions options)
+{
+    for (NSInteger i = length; i-- > 0;) {
+        CGFloat d = data[i];
+        CGFloat proposed = IJSVGExporterPathFloatToFixed(d, options.precision);
+        if(proposed != d) {
+            CGFloat rounded = +IJSVGExporterPathFloatToFixed(d, options.precision - 1);
+            data[i] = IJSVGExporterPathFloatToFixed(+fabs(rounded - d), options.precision + 1)
+                    >= kIJSVGExporterPathInstructionErrorThreshold
+                ? +IJSVGExporterPathFloatToFixed(d, options.precision)
+                : rounded;
+        }
+    }
+}
+
++ (void)convertInstructionsToRoundRelativeCoordinates:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                                 floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    CGFloat relSubPoint[2] = { 0.f, 0.f };
+    for (IJSVGExporterPathInstruction* instruction in instructions) {
+        char instructionChar = instruction.instruction;
+        NSInteger length = instruction.dataLength;
+        CGFloat* data = instruction.data;
+        if(strchr("mltqsc", instructionChar) != NULL) {
+            for (NSInteger i = length; i--;) {
+                data[i] += instruction.base[i % 2] - relSubPoint[i % 2];
+            }
+        } else if(instructionChar == 'h') {
+            data[0] += instruction.base[0] - relSubPoint[0];
+        } else if(instructionChar == 'v') {
+            data[0] += instruction.base[1] - relSubPoint[1];
+        } else if(instructionChar == 'a') {
+            data[5] += instruction.base[0] - relSubPoint[0];
+            data[5] += instruction.base[1] - relSubPoint[1];
+        }
+        IJSVGExporterPathInstructionRoundData(data, length, floatingPointOptions);
+        if(instructionChar == 'h') {
+            relSubPoint[0] += data[0];
+        } else if(instructionChar == 'v') {
+            relSubPoint[1] += data[0];
+        } else {
+            relSubPoint[0] += data[length - 2];
+            relSubPoint[1] += data[length - 1];
+        }
+        IJSVGExporterPathInstructionRoundData(relSubPoint, 2, floatingPointOptions);
+    }
+}
+
++ (void)convertInstructionsToMixedAbsoluteRelative:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                              floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    IJSVGExporterPathInstruction* prevInstruction = nil;
+    for (IJSVGExporterPathInstruction* instruction in instructions) {
+        if(prevInstruction == nil || instruction.dataLength == 0) {
+            prevInstruction = instruction;
+            continue;
+        }
+
+        char instructionChar = instruction.instruction;
+        CGFloat* data = instruction.data;
+        NSInteger length = instruction.dataLength;
+        CGFloat* adata = (CGFloat*)malloc(sizeof(CGFloat) * length);
+        memcpy(adata, data, sizeof(CGFloat) * length);
+
+        if(strchr("mltqsc", instructionChar) != NULL) {
+            for (NSInteger i = length; i--;) {
+                adata[i] += instruction.base[i % 2];
+            }
+        } else if(instructionChar == 'h') {
+            adata[0] += instruction.base[0];
+        } else if(instructionChar == 'v') {
+            adata[0] += instruction.base[1];
+        } else if(instructionChar == 'a') {
+            adata[5] += instruction.base[0];
+            adata[6] += instruction.base[1];
+        }
+
+        IJSVGExporterPathInstructionRoundData(adata, length, floatingPointOptions);
+
+        IJSVGExporterPathInstruction* ainstruction = nil;
+        ainstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:instructionChar
+                                                                        dataCount:length];
+        memcpy(ainstruction.data, adata, sizeof(CGFloat) * length);
+
+        // run these through our default string runner
+        // to compare the outputs
+        NSString* orig = [self pathStringFromInstructions:@[ instruction ]
+                                     floatingPointOptions:floatingPointOptions];
+        NSString* comp = [self pathStringFromInstructions:@[ ainstruction ]
+                                     floatingPointOptions:floatingPointOptions];
+
+        if(comp.length < orig.length && !(instructionChar == prevInstruction.instruction &&
+                                           prevInstruction.instruction > 96 &&
+                                           comp.length == orig.length - 1 &&
+                                           data[0] < 0.f &&
+                                           fmod(prevInstruction.data[prevInstruction.dataLength - 1], 1) != 0.f)) {
+            instruction.instruction = toupper(instructionChar);
+            memcpy(data, adata, sizeof(CGFloat) * length);
+        }
+        (void)free(adata), adata = NULL;
+        prevInstruction = instruction;
+    }
+}
+
++ (void)convertInstructionsDataToRounded:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                    floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    for (IJSVGExporterPathInstruction* instruction in instructions) {
+        CGFloat* data = instruction.data;
+        IJSVGExporterPathInstructionRoundData(data, instruction.dataLength,
+            floatingPointOptions);
+    }
+}
+
++ (NSArray<IJSVGExporterPathInstruction*>*)convertInstructionsCurves:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                                                floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    NSMutableArray<IJSVGExporterPathInstruction*>* nInstructions = nil;
+    nInstructions = [[NSMutableArray alloc] initWithCapacity:instructions.count];
+    IJSVGExporterPathInstruction* lastInstruction = nil;
+    for (IJSVGExporterPathInstruction* instruction in instructions) {
+        lastInstruction = nInstructions.lastObject;
+        if(lastInstruction == nil) {
+            [nInstructions addObject:instruction];
+            continue;
+        }
+        if(instruction.instruction == 'c') {
+            if(lastInstruction.instruction == 'c' &&
+                instruction.data[0] == -(lastInstruction.data[2] - lastInstruction.data[4]) &&
+                instruction.data[1] == -(lastInstruction.data[3] - lastInstruction.data[5])) {
+                IJSVGExporterPathInstruction* nInstruction = nil;
+                nInstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'s'
+                                                                                dataCount:4];
+                nInstruction.data[0] = instruction.data[2];
+                nInstruction.data[1] = instruction.data[3];
+                nInstruction.data[2] = instruction.data[4];
+                nInstruction.data[3] = instruction.data[5];
+                [nInstructions addObject:nInstruction];
+                continue;
+            } else if(lastInstruction.instruction == 's' &&
+                       instruction.data[0] == -(lastInstruction.data[0] - lastInstruction.data[2]) &&
+                       instruction.data[1] == -(lastInstruction.data[1] - lastInstruction.data[3])) {
+                IJSVGExporterPathInstruction* nInstruction = nil;
+                nInstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'s'
+                                                                                dataCount:4];
+                nInstruction.data[0] = instruction.data[2];
+                nInstruction.data[1] = instruction.data[3];
+                nInstruction.data[2] = instruction.data[4];
+                nInstruction.data[3] = instruction.data[5];
+                [nInstructions addObject:nInstruction];
+                continue;
+            } else if(lastInstruction.instruction != 'c' &&
+                       lastInstruction.instruction != 's' &&
+                       instruction.data[0] == 0.f && instruction.data[1] == 0.f) {
+                IJSVGExporterPathInstruction* nInstruction = nil;
+                nInstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'s'
+                                                                                dataCount:4];
+                nInstruction.data[0] = instruction.data[2];
+                nInstruction.data[1] = instruction.data[3];
+                nInstruction.data[2] = instruction.data[4];
+                nInstruction.data[3] = instruction.data[5];
+                [nInstructions addObject:nInstruction];
+                continue;
+            }
+        } else if(instruction.instruction == 'q') {
+            if(lastInstruction.instruction == 'q' &&
+                instruction.data[0] == (lastInstruction.data[2] - lastInstruction.data[0]) &&
+                instruction.data[1] == (lastInstruction.data[3] - lastInstruction.data[1])) {
+                IJSVGExporterPathInstruction* nInstruction = nil;
+                nInstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'t'
+                                                                                dataCount:2];
+                nInstruction.data[0] = instruction.data[2];
+                nInstruction.data[1] = instruction.data[3];
+                [nInstructions addObject:nInstruction];
+                continue;
+            } else if(lastInstruction.instruction == 't' &&
+                       instruction.data[2] == lastInstruction.data[0] &&
+                       instruction.data[3] == lastInstruction.data[1]) {
+                IJSVGExporterPathInstruction* nInstruction = nil;
+                nInstruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'t'
+                                                                                dataCount:2];
+                nInstruction.data[0] = instruction.data[2];
+                nInstruction.data[1] = instruction.data[3];
+                [nInstructions addObject:nInstruction];
+                continue;
+            }
+        }
+        [nInstructions addObject:instruction];
+    }
+    return nInstructions;
+}
+
++ (void)convertInstructionsToRelativeCoordinates:(NSArray<IJSVGExporterPathInstruction*>*)instructions
+                            floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+    CGFloat start[2] = {0, 0};
+    CGFloat cursor[2] = {0, 0};
+    CGFloat prevCoords[2] = {0, 0};
+
+    NSInteger index = 0;
+    for (IJSVGExporterPathInstruction* anInstruction in instructions) {
+        char instruction = anInstruction.instruction;
+        CGFloat* data = anInstruction.data;
+        CGFloat* base = anInstruction.base;
+        CGFloat* coords = anInstruction.coords;
+        
+        switch(instruction) {
+            case 'm': {
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                start[0] = cursor[0];
+                start[1] = cursor[1];
+                break;
+            }
+            case 'M': {
+                if(index != 0) {
+                    instruction = 'm';
+                }
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                start[0] = cursor[0];
+                start[1] = cursor[1];
+                break;
+            }
+            case 'l': {
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                break;
+            }
+            case 'L': {
+                instruction = 'l';
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                break;
+            }
+            case 'h': {
+                cursor[0] += data[0];
+                break;
+            }
+            case 'H': {
+                instruction = 'h';
+                data[0] -= cursor[0];
+                cursor[0] += data[0];
+                break;
+            }
+            case 'v': {
+                cursor[1] += data[0];
+                break;
+            }
+            case 'V': {
+                instruction = 'v';
+                data[0] -= cursor[1];
+                cursor[1] += data[0];
+                break;
+            }
+            case 'c': {
+                cursor[0] += data[4];
+                cursor[1] += data[5];
+                break;
+            }
+            case 'C': {
+                instruction = 'c';
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                data[2] -= cursor[0];
+                data[3] -= cursor[1];
+                data[4] -= cursor[0];
+                data[5] -= cursor[1];
+                cursor[0] += data[4];
+                cursor[1] += data[5];
+                break;
+            }
+            case 's': {
+                cursor[0] += data[2];
+                cursor[1] += data[3];
+                break;
+            }
+            case 'S': {
+                instruction = 's';
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                data[2] -= cursor[0];
+                data[3] -= cursor[1];
+                cursor[0] += data[2];
+                cursor[1] += data[3];
+                break;
+            }
+            case 'q': {
+                cursor[0] += data[2];
+                cursor[1] += data[3];
+                break;
+            }
+            case 'Q': {
+                instruction = 'q';
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                data[2] -= cursor[0];
+                data[3] -= cursor[1];
+                cursor[0] += data[2];
+                cursor[1] += data[3];
+                break;
+            }
+            case 't': {
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                break;
+            }
+            case 'T': {
+                instruction = 't';
+                data[0] -= cursor[0];
+                data[1] -= cursor[1];
+                cursor[0] += data[0];
+                cursor[1] += data[1];
+                break;
+            }
+            case 'a': {
+                cursor[0] += data[5];
+                cursor[1] += data[6];
+                break;
+            }
+            case 'A': {
+                instruction = 'a';
+                data[5] -= cursor[0];
+                data[6] -= cursor[1];
+                cursor[0] += data[5];
+                cursor[1] += data[6];
+                break;
+            }
+            case 'Z':
+            case 'z': {
+                cursor[0] = start[0];
+                cursor[1] = start[1];
+                break;
+            }
+        }
+
+        // set the instruction back
+        anInstruction.instruction = instruction;
+        base[0] = prevCoords[0];
+        base[1] = prevCoords[1];
+        coords[0] = cursor[0];
+        coords[1] = cursor[1];
+        prevCoords[0] = cursor[0];
+        prevCoords[1] = cursor[1];
+        index++;
+    }
+}
+
++ (NSArray<IJSVGExporterPathInstruction*>*)instructionsFromPath:(CGPathRef)path
+                                           floatingPointOptions:(IJSVGFloatingPointOptions)floatingPointOptions
+{
+
+    // keep track of the current point
+    __block CGPoint currentPoint = CGPointZero;
+    NSMutableArray* instructions = [[NSMutableArray alloc] init];
+
+    // create the path callback
+    IJSVGCGPathHandler callback = ^(const CGPathElement* pathElement) {
+        IJSVGExporterPathInstruction* instruction = nil;
+        // work out what to do
+        switch (pathElement->type) {
+
+        case kCGPathElementMoveToPoint: {
+            // move to command
+            instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'M'
+                                                                           dataCount:2];
+            CGPoint point = pathElement->points[0];
+            instruction.data[0] = point.x;
+            instruction.data[1] = point.y;
+            currentPoint = point;
+
+            [instructions addObject:instruction];
+            break;
+        }
+
+        case kCGPathElementAddLineToPoint: {
+            // line to command
+            CGPoint point = pathElement->points[0];
+            if(point.x == currentPoint.x) {
+                instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'V'
+                                                                               dataCount:1];
+                instruction.data[0] = point.y;
+            } else if(point.y == currentPoint.y) {
+                instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'H'
+                                                                               dataCount:1];
+                instruction.data[0] = point.x;
+            } else {
+                instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'L'
+                                                                               dataCount:2];
+                instruction.data[0] = point.x;
+                instruction.data[1] = point.y;
+            }
+            currentPoint = point;
+
+            [instructions addObject:instruction];
+            break;
+        }
+
+        case kCGPathElementAddQuadCurveToPoint: {
+            // quad curve to command
+            CGPoint controlPoint = pathElement->points[0];
+            CGPoint point = pathElement->points[1];
+            instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'Q'
+                                                                           dataCount:4];
+            instruction.data[0] = controlPoint.x;
+            instruction.data[1] = controlPoint.y;
+            instruction.data[2] = point.x;
+            instruction.data[3] = point.y;
+            currentPoint = point;
+
+            [instructions addObject:instruction];
+            break;
+        }
+
+        case kCGPathElementAddCurveToPoint: {
+            // curve to command
+            CGPoint controlPoint1 = pathElement->points[0];
+            CGPoint controlPoint2 = pathElement->points[1];
+            CGPoint point = pathElement->points[2];
+
+            currentPoint = point;
+            instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'C'
+                                                                           dataCount:6];
+            instruction.data[0] = controlPoint1.x;
+            instruction.data[1] = controlPoint1.y;
+            instruction.data[2] = controlPoint2.x;
+            instruction.data[3] = controlPoint2.y;
+            instruction.data[4] = point.x;
+            instruction.data[5] = point.y;
+
+            [instructions addObject:instruction];
+            break;
+        }
+
+        case kCGPathElementCloseSubpath: {
+            // close command
+            instruction = [[IJSVGExporterPathInstruction alloc] initWithInstruction:'Z'
+                                                                           dataCount:0];
+            [instructions addObject:instruction];
+            break;
+        }
+        }
+    };
+
+    // apply the
+    CGPathApply(path, (__bridge void*)callback, IJSVGExporterPathCaller);
+
+    // remove last instruction if it was Z -> M
+    IJSVGExporterPathInstruction* lastInstruction = instructions.lastObject;
+    if(lastInstruction.instruction == 'M' || lastInstruction.instruction == 'm') {
+        if(instructions.count >= 2) {
+            NSInteger index = [instructions indexOfObject:lastInstruction] - 1;
+            IJSVGExporterPathInstruction* prevInstruction = instructions[index];
+            if(prevInstruction.instruction == 'z' || prevInstruction.instruction == 'Z') {
+                [instructions removeLastObject];
+            }
+        }
+    }
+
+    return instructions;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGBasicLayer.h

@@ -0,0 +1,14 @@
+//
+//  IJSVGBasicLayer.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 19/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <QuartzCore/QuartzCore.h>
+#import <IJSVG/IJSVGLayer.h>
+
+@interface IJSVGBasicLayer : CALayer <IJSVGBasicLayer>
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGBasicLayer.m

@@ -0,0 +1,30 @@
+//
+//  IJSVGBasicLayer.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 19/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGBasicLayer.h>
+
+@implementation IJSVGBasicLayer
+
+@synthesize backingScaleFactor;
+@synthesize requiresBackingScale;
+@synthesize renderQuality;
+@synthesize debugLayers;
+
+- (id<CAAction>)actionForKey:(NSString*)event
+{
+    return nil;
+}
+
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+}
+
+
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGFilterLayer.h

@@ -0,0 +1,23 @@
+//
+//  IJSVGFilterLayer.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 19/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGFilter.h>
+#import <IJSVG/IJSVGBasicLayer.h>
+
+@interface IJSVGFilterLayer : IJSVGLayer {
+    
+@private
+    IJSVGBasicLayer* _hostingLayer;
+    CGImageRef _image;
+    
+}
+
+@property (nonatomic, strong) CALayer<IJSVGDrawableLayer>* sublayer;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGFilterLayer.m

@@ -0,0 +1,69 @@
+//
+//  IJSVGFilterLayer.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 19/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGFilterLayer.h>
+#import <IJSVG/IJSVGTransform.h>
+
+@implementation IJSVGFilterLayer
+
+- (void)dealloc
+{
+    (void)CGImageRelease(_image), _image = nil;
+}
+
+- (instancetype)init
+{
+    if((self = [super init]) != nil) {
+        _hostingLayer = [IJSVGBasicLayer layer];
+        [self addSublayer:_hostingLayer];
+    }
+    return self;
+}
+
+- (BOOL)requiresBackingScale
+{
+    return YES;
+}
+
+- (void)setBackingScaleFactor:(CGFloat)backingScaleFactor
+{
+    // we are responsible for recursively calling the sublayer
+    // with the new backing scale factor
+    [IJSVGLayer setBackingScaleFactor:backingScaleFactor
+                        renderQuality:self.renderQuality
+                   recursivelyToLayer:_sublayer];
+    
+    BOOL needsChange = self.backingScaleFactor != backingScaleFactor;
+    [super setBackingScaleFactor:backingScaleFactor];
+    if(needsChange == YES) {
+        [self updateImage];
+    }
+}
+
+- (void)updateImage
+{
+    if(_image != nil) {
+        (void)CGImageRelease(_image), _image = nil;
+    }
+    _image = [self.filter newImageByApplyFilterToLayer:_sublayer
+                                                 scale:self.backingScaleFactor];
+}
+
+- (void)layoutSublayers
+{
+    CGRect frame = _sublayer.innerBoundingBox;
+    _hostingLayer.frame = frame;
+    _hostingLayer.contents = (__bridge id)_image;
+}
+
+- (NSArray<CALayer<IJSVGBasicLayer>*>*)debugLayers
+{
+    return @[_sublayer];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGGradientLayer.h

@@ -6,18 +6,16 @@
 //  Copyright © 2016 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGGradient.h"
-#import "IJSVGLayer.h"
-#import "IJSVGPath.h"
+#import <IJSVG/IJSVGGradient.h>
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGPath.h>
 #import <QuartzCore/QuartzCore.h>
 
 @interface IJSVGGradientLayer : IJSVGLayer {
 }
 
+@property (nonatomic, strong) IJSVGGradient* gradient;
 @property (nonatomic, assign) CGRect viewBox;
-@property (nonatomic, retain) IJSVGGradient* gradient;
-@property (nonatomic, assign) CGAffineTransform absoluteTransform;
-@property (nonatomic, assign) CGRect objectRect;
 
 @end
 

Framework/IJSVG/IJSVG/Source/Layers/IJSVGGradientLayer.m

@@ -0,0 +1,107 @@
+//
+//  IJSVGGradientLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 29/12/2016.
+//  Copyright © 2016 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGradientLayer.h>
+#import <IJSVG/IJSVGRootLayer.h>
+
+@implementation IJSVGGradientLayer
+
+- (BOOL)requiresBackingScale
+{
+    return YES;
+}
+
+- (void)setGradient:(IJSVGGradient*)newGradient
+{
+    _gradient = newGradient;
+
+    // lets check its alpha properties on the colors
+    BOOL hasAlphaChannel = NO;
+    for (NSColor* color in newGradient.colors) {
+        if(color.alphaComponent != 1.f) {
+            hasAlphaChannel = YES;
+            break;
+        }
+    }
+    self.opaque = hasAlphaChannel == NO;
+}
+
+- (void)setOpacity:(float)opacity
+{
+    if(opacity != 1.f) {
+        self.opaque = NO;
+    }
+    [super setOpacity:opacity];
+}
+
+- (void)setBackingScaleFactor:(CGFloat)backingScaleFactor
+{
+    switch (self.renderQuality) {
+        case kIJSVGRenderQualityOptimized: {
+            backingScaleFactor = (backingScaleFactor * .35f);
+            break;
+        }
+        case kIJSVGRenderQualityLow: {
+            backingScaleFactor = (backingScaleFactor * .05f);
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    [super setBackingScaleFactor:backingScaleFactor];
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencingLayer
+{
+    return [super referencingLayer] ?: self.superlayer;
+}
+
+- (void)drawInContext:(CGContextRef)ctx
+{
+    [super drawInContext:ctx];
+
+    // nothing to do :(
+    if(self.gradient == nil) {
+        return;
+    }
+
+    // perform the draw
+    CGRect bounds = CGRectZero;
+    CGAffineTransform transform = CGAffineTransformIdentity;
+    CALayer<IJSVGDrawableLayer>* layer = (CALayer<IJSVGDrawableLayer>*)self.referencingLayer;
+    if(self.gradient.units == IJSVGUnitUserSpaceOnUse) {
+        IJSVGRootLayer* rootNode = (IJSVGRootLayer*)[IJSVGLayer rootLayerForLayer:self];
+        bounds = [rootNode.viewBox computeValue:CGSizeZero];
+        transform = [IJSVGLayer userSpaceTransformForLayer:layer];
+    } else {
+        bounds = IJSVGLayerGetBoundingBoxBounds(layer);
+    }
+    
+    // its possible that this layer is shifted inwards due to a stroke on the
+    // parent layer
+    transform = CGAffineTransformConcat(transform, [IJSVGLayer userSpaceTransformForLayer:self]);
+    
+    [self.gradient drawInContextRef:ctx
+                             bounds:bounds
+                          transform:transform];
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    IJSVGTraitedColorStorage* list = [[IJSVGTraitedColorStorage alloc] init];
+    for(NSColor* color in self.gradient.colors) {
+        IJSVGTraitedColor* traited = nil;
+        traited = [IJSVGTraitedColor colorWithColor:color
+                                             traits:IJSVGColorUsageTraitNone];
+        [list addColor:traited];
+    }
+    return list;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGGroupLayer.h

@@ -0,0 +1,23 @@
+//
+//  IJSVGGroupLayer.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGShapeLayer.h>
+#import <IJSVG/IJSVGUnitRect.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface IJSVGGroupLayer : IJSVGLayer <IJSVGMaskingLayer> {
+    
+}
+
+@property (nonatomic, strong) IJSVGUnitSize* intrinsicSize;
+@property (nonatomic, strong) IJSVGUnitRect* viewBox;
+@property (nonatomic, assign) IJSVGViewBoxAlignment viewBoxAlignment;
+@property (nonatomic, assign) IJSVGViewBoxMeetOrSlice viewBoxMeetOrSlice;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGGroupLayer.m

@@ -0,0 +1,21 @@
+//
+//  IJSVGGroupLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroupLayer.h>
+#import <IJSVG/IJSVGViewBox.h>
+#import <IJSVG/IJSVGUnitRect.h>
+#import <IJSVG/IJSVGLayer.h>
+
+@implementation IJSVGGroupLayer
+
+- (CGRect)innerBoundingBox
+{
+    return self.outerBoundingBox;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGImageLayer.h

@@ -0,0 +1,24 @@
+//
+//  IJSVGImageLayer.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGImage.h>
+#import <IJSVG/IJSVGTransformLayer.h>
+#import <IJSVG/IJSVGTileLayer.h>
+#import <IJSVG/IJSVGBasicLayer.h>
+#import <AppKit/AppKit.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface IJSVGImageLayer : IJSVGTileLayer {
+}
+
+@property (nonatomic, strong) IJSVGImage* image;
+
+- (id)initWithImage:(IJSVGImage*)image;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGImageLayer.m

@@ -0,0 +1,48 @@
+//
+//  IJSVGImageLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGImageLayer.h>
+
+@implementation IJSVGImageLayer
+
+- (id)initWithImage:(IJSVGImage*)image
+{
+    if((self = [super init]) != nil) {
+        self.image = image;
+    }
+    return self;
+}
+
+- (BOOL)requiresBackingScale
+{
+    return YES;
+}
+
+- (void)setImage:(IJSVGImage *)image
+{
+    _image = image;
+    [self setNeedsDisplay];
+}
+
+- (void)drawInContext:(CGContextRef)ctx
+{
+    CGImageRef image = _image.CGImage;
+    CGRect imageDrawRect = _image.bounds;
+    CGRect currentBounds = self.bounds;
+    IJSVGViewBoxDrawingBlock drawBlock = ^(CGFloat scale[]) {
+        // image will be upside down, so just translate it back on itself
+        CGContextConcatCTM(ctx, CGAffineTransformMakeScale(1.f, -1.f));
+        CGContextTranslateCTM(ctx, 0.f, -CGRectGetHeight(imageDrawRect));
+        CGContextDrawImage(ctx, imageDrawRect, image);
+    };
+    IJSVGContextDrawViewBox(ctx, imageDrawRect, currentBounds,
+                            _image.viewBoxAlignment,
+                            _image.viewBoxMeetOrSlice, drawBlock);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGLayer.h

@@ -0,0 +1,191 @@
+//
+//  IJSVGLayer.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGRendering.h>
+#import <IJSVG/IJSVGTransaction.h>
+#import <QuartzCore/QuartzCore.h>
+
+@class IJSVGShapeLayer;
+@class IJSVGGradientLayer;
+@class IJSVGPatternLayer;
+@class IJSVGStrokeLayer;
+@class IJSVGGroupLayer;
+@class IJSVGLayer;
+@class IJSVGFilter;
+@class IJSVGTraitedColorStorage;
+
+typedef NS_OPTIONS(NSUInteger, IJSVGLayerTraits) {
+    IJSVGLayerTraitNone = 0,
+    IJSVGLayerTraitFilled = 1 << 1,
+    IJSVGLayerTraitStroked = 1 << 2
+};
+
+typedef NS_OPTIONS(NSUInteger, IJSVGLayerDrawingOptions) {
+    IJSVGLayerDrawingOptionNone = 0,
+    IJSVGLayerDrawingOptionIgnoreClipping = 1 << 1
+};
+
+typedef NS_ENUM(NSUInteger, IJSVGLayerFillType) {
+    IJSVGLayerFillTypeColor,
+    IJSVGLayerFillTypePattern,
+    IJSVGLayerFillTypeGradient,
+    IJSVGLayerFillTypeUnknown
+};
+
+typedef NS_ENUM(NSUInteger, IJSVGLayerUsageType) {
+    IJSVGLayerUsageTypeFillGeneric,
+    IJSVGLayerUsageTypeFillPattern,
+    IJSVGLayerUsageTypeFillGradient,
+    IJSVGLayerUsageTypeStrokeGeneric,
+    IJSVGLayerUsageTypeStrokePattern,
+    IJSVGLayerUsageTypeStrokeGradient,
+    IJSVGLayerUsageTypeStroke
+};
+
+@protocol IJSVGPathableLayer <NSObject>
+
+@required
+@property (nonatomic, assign) CGPathRef path;
+
+@end
+
+@protocol IJSVGBasicLayer <NSObject>
+
+@required
+@property (nonatomic, assign) CGFloat backingScaleFactor;
+@property (nonatomic, readonly) BOOL requiresBackingScale;
+@property (nonatomic, assign) IJSVGRenderQuality renderQuality;
+@property (nonatomic, readonly) NSArray<CALayer<IJSVGBasicLayer>*>* debugLayers;
+
+@end
+
+@protocol IJSVGMaskingLayer <NSObject>
+
+@required
+@property (nonatomic, assign) CGRect maskingBoundingBox;
+@property (nonatomic, assign) CGRect maskingClippingRect;
+
+@end
+
+@protocol IJSVGClippingLayer <NSObject>
+
+@required
+@property (nonatomic, assign) CGRect clippingBoundingBox;
+@property (nonatomic, assign) CGAffineTransform clippingTransform;
+@property (nonatomic, assign) CGPathRef clipPath;
+@property (nonatomic, assign) CGAffineTransform clipPathTransform;
+
+@end
+
+@protocol IJSVGDrawableLayer <NSObject, IJSVGBasicLayer, IJSVGMaskingLayer, IJSVGClippingLayer>
+
+@required
+@property (nonatomic, readonly) BOOL treatImplicitOriginAsTransform;
+@property (nonatomic, assign) CGBlendMode blendingMode;
+@property (nonatomic, strong) NSArray<CALayer<IJSVGDrawableLayer>*>* clipLayers;
+@property (nonatomic, strong) CALayer<IJSVGDrawableLayer>* maskLayer;
+@property (nonatomic, copy) CAShapeLayerFillRule clipRule;
+@property (nonatomic, copy) CAShapeLayerFillRule fillRule;
+@property (nonatomic, readonly) CGPoint absoluteOrigin;
+@property (nonatomic, readonly) CGRect absoluteFrame;
+@property (nonatomic, assign) CGRect boundingBox;
+@property (nonatomic, assign) CGRect outerBoundingBox;
+@property (nonatomic, readonly) CGRect innerBoundingBox;
+@property (nonatomic, weak) CALayer<IJSVGDrawableLayer>* referencingLayer;
+@property (nonatomic, strong) IJSVGFilter* filter;
+@property (nonatomic, readonly) IJSVGLayerTraits layerTraits;
+@property (nonatomic, readonly) NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* layerUsageMapTable;
+@property (nonatomic, readonly) IJSVGTraitedColorStorage* colors;
+
+- (void)performRenderInContext:(CGContextRef)ctx;
+
+- (void)setLayer:(CALayer<IJSVGDrawableLayer>*)layer
+    forUsageType:(IJSVGLayerUsageType)type;
+- (CALayer<IJSVGDrawableLayer>*)layerForUsageType:(IJSVGLayerUsageType)type;
+- (CALayer<IJSVGDrawableLayer>*)strokeLayer:(IJSVGLayerUsageType*)usageType;
+
+- (void)addTraits:(IJSVGLayerTraits)traits;
+- (void)removeTraits:(IJSVGLayerTraits)traits;
+- (BOOL)matchesTraits:(IJSVGLayerTraits)traits;
+
+- (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass;
+
+@end
+
+CGRect IJSVGLayerGetBoundingBoxBounds(CALayer<IJSVGDrawableLayer>* drawableLayer);
+NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* IJSVGLayerDefaultUsageMapTable(void);
+
+@interface IJSVGLayer : CALayer <IJSVGDrawableLayer, IJSVGMaskingLayer> {
+
+@private
+    IJSVGLayer* _maskingLayer;
+    NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* _layerUsageMapTable;
+}
+
++ (IJSVGLayerFillType)fillTypeForFill:(id)fill;
+
++ (NSArray*)deepestSublayersOfLayer:(CALayer*)layer;
++ (void)recursivelyWalkLayer:(CALayer<IJSVGBasicLayer>*)layer
+                   withBlock:(void (^)(CALayer<IJSVGBasicLayer>* layer, BOOL* stop))block;
+
++ (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+                                           fromLayer:(CALayer<IJSVGDrawableLayer>*)layer;
+
++ (void)setBackingScaleFactor:(CGFloat)scale
+                renderQuality:(IJSVGRenderQuality)quality
+           recursivelyToLayer:(CALayer<IJSVGDrawableLayer>*)layer;
+
+- (void)applySublayerMaskToContext:(CGContextRef)context
+                       forSublayer:(IJSVGLayer*)sublayer
+                        withOffset:(CGPoint)offset;
+
++ (CGImageRef)newMaskImageForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                           options:(IJSVGLayerDrawingOptions)options
+                             scale:(CGFloat)scale;
+
++ (CGImageRef)newImageForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                       options:(IJSVGLayerDrawingOptions)options
+                    colorSpace:(CGColorSpaceRef)colorSpace
+                    bitmapInfo:(uint32_t)bitmapInfo
+                         scale:(CGFloat)scale;
+
++ (CGImageRef)newImageWithSize:(CGSize)size
+                     drawBlock:(void (^)(CGContextRef context))drawBlock
+                    colorSpace:(CGColorSpaceRef)colorSpace
+                    bitmapInfo:(uint32_t)bitmapInfo
+                         scale:(CGFloat)scale;
+
++ (void)renderLayer:(CALayer<IJSVGDrawableLayer>*)layer
+          inContext:(CGContextRef)ctx
+            options:(IJSVGLayerDrawingOptions)options;
+
++ (void)applyBlendingMode:(CGBlendMode)blendMode
+                toContext:(CGContextRef)ctx
+             drawingBlock:(dispatch_block_t)drawingBlock;
+
++ (void)clipContextWithClipLayers:(NSArray<CALayer<IJSVGDrawableLayer>*>*)clipLayers
+                          toLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                        inContext:(CGContextRef)ctx
+                     drawingBlock:(dispatch_block_t)drawingBlock;
+
++ (void)clipContextWithMask:(CALayer<IJSVGMaskingLayer>*)maskLayer
+                    toLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                  inContext:(CGContextRef)context
+               drawingBlock:(dispatch_block_t)drawingBlock;
+
++ (CALayer<IJSVGDrawableLayer>*)rootLayerForLayer:(CALayer<IJSVGDrawableLayer>*)layer;
++ (CGAffineTransform)absoluteTransformForLayer:(CALayer*)layer;
++ (CGRect)absoluteFrameForLayer:(CALayer<IJSVGDrawableLayer>*)layer;
++ (CGRect)calculateFrameForSublayers:(NSArray<CALayer<IJSVGDrawableLayer>*>*)layers;
++ (CGAffineTransform)userSpaceTransformForLayer:(CALayer<IJSVGDrawableLayer>*)layer;
++ (void)transformLayer:(CALayer<IJSVGDrawableLayer>*)layer
+intoUserSpaceUnitsFrom:(CALayer<IJSVGDrawableLayer>*)fromLayer;
+
++ (void)logLayer:(CALayer<IJSVGDrawableLayer>*)layer;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGLayer.m

@@ -0,0 +1,780 @@
+//
+//  IJSVGLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVG.h>
+#import <IJSVG/IJSVGGroupLayer.h>
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGShapeLayer.h>
+#import <IJSVG/IJSVGTransformLayer.h>
+#import <IJSVG/IJSVGRootLayer.h>
+
+CGRect IJSVGLayerGetBoundingBoxBounds(CALayer<IJSVGDrawableLayer>* drawableLayer)
+{
+    return (CGRect) {
+        .origin = CGPointZero,
+        .size = drawableLayer.boundingBox.size
+    };
+}
+
+NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* IJSVGLayerDefaultUsageMapTable(void)
+{
+    return [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsStrongMemory
+                                     valueOptions:NSPointerFunctionsWeakMemory
+                                         capacity:3];
+}
+
+
+@implementation IJSVGLayer
+
+@synthesize backingScaleFactor = _backingScaleFactor;
+@synthesize requiresBackingScale;
+@synthesize renderQuality;
+@synthesize blendingMode;
+@synthesize absoluteOrigin;
+@synthesize clipPath = _clipPath;
+@synthesize clipRule = _clipRule;
+@synthesize clipLayers = _clipLayers;
+@synthesize clippingTransform;
+@synthesize clippingBoundingBox;
+@synthesize maskingClippingRect;
+@synthesize clipPathTransform;
+@synthesize colors;
+@synthesize boundingBox = _boundingBox;
+@synthesize layerTraits = _layerTraits;
+@synthesize maskingBoundingBox;
+@synthesize filter;
+@synthesize referencingLayer = _referencingLayer;
+@synthesize outerBoundingBox = _outerBoundingBox;
+@synthesize maskLayer = _maskLayer;
+@synthesize treatImplicitOriginAsTransform;
+@synthesize fillRule;
+
+- (void)dealloc
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+}
+
+- (instancetype)init
+{
+    if((self = [super init]) != nil) {
+        _boundingBox = CGRectNull;
+        _outerBoundingBox = CGRectNull;
+    }
+    return self;
+}
+
+- (id<CAAction>)actionForKey:(NSString*)event
+{
+    return nil;
+}
+
+- (CAShapeLayerFillRule)fillRule
+{
+    return kCAFillRuleNonZero;
+}
+
+- (CAShapeLayerFillRule)clipRule
+{
+    if(_clipRule == nil) {
+        return self.fillRule;
+    }
+    return _clipRule;
+}
+
++ (IJSVGLayerFillType)fillTypeForFill:(id)fill
+{
+    if([fill isKindOfClass:IJSVGColorNode.class]) {
+        return IJSVGLayerFillTypeColor;
+    }
+    if([fill isKindOfClass:IJSVGGradient.class]) {
+        return IJSVGLayerFillTypeGradient;
+    }
+    if([fill isKindOfClass:IJSVGPattern.class]) {
+        return IJSVGLayerFillTypePattern;
+    }
+    return IJSVGLayerFillTypeUnknown;
+}
+
++ (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+                                           fromLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    for(CALayer<IJSVGDrawableLayer>* sublayer in layer.sublayers) {
+        if(sublayer.class == aClass) {
+            return sublayer;
+        }
+    }
+    return nil;
+}
+
++ (void)applyAbsoluteTransformForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                             toContext:(CGContextRef)ctx
+{
+    CALayer<IJSVGDrawableLayer>* parentLayer = layer;
+    while((parentLayer = parentLayer.referencingLayer) != nil) {
+        CGContextConcatCTM(ctx, parentLayer.affineTransform);
+        
+        // only go up until we find a root layer, at that point, we know
+        // we can stop looking
+        if([parentLayer isKindOfClass:IJSVGRootLayer.class] == YES) {
+            break;
+        }
+    }
+    CGContextConcatCTM(ctx, layer.affineTransform);
+}
+
++ (CGAffineTransform)absoluteTransformForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    CGAffineTransform identity = CGAffineTransformIdentity;
+    CALayer<IJSVGDrawableLayer>* parentLayer = layer;
+    while((parentLayer = parentLayer.referencingLayer) != nil) {
+        identity = [self absoluteTransformForLayer:parentLayer];
+        
+        // only go up until we find a root layer, at that point, we know
+        // we can stop looking
+        if([parentLayer isKindOfClass:IJSVGRootLayer.class] == YES) {
+            break;
+        }
+    }
+    return CGAffineTransformConcat(identity, layer.affineTransform);
+}
+
++ (void)transformLayer:(CALayer<IJSVGDrawableLayer>*)layer
+intoUserSpaceUnitsFrom:(CALayer<IJSVGDrawableLayer>*)fromLayer
+{
+    CGAffineTransform transform = layer.affineTransform;
+    CGAffineTransform userSpaceTransform = [IJSVGLayer userSpaceTransformForLayer:fromLayer];
+    layer.affineTransform = CGAffineTransformConcat(transform, userSpaceTransform);
+}
+
++ (CGAffineTransform)userSpaceTransformForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    CGRect absolutePosition = layer.outerBoundingBox;
+    return CGAffineTransformTranslate(CGAffineTransformIdentity,
+                                      -CGRectGetMinX(absolutePosition),
+                                      -CGRectGetMinY(absolutePosition));
+}
+
++ (CALayer<IJSVGDrawableLayer>*)rootLayerForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    CALayer<IJSVGDrawableLayer>* parentLayer = (CALayer<IJSVGDrawableLayer>*)layer.referencingLayer;
+    while([parentLayer isKindOfClass:IJSVGRootLayer.class] == NO &&
+          parentLayer.referencingLayer != nil) {
+        parentLayer = (CALayer<IJSVGDrawableLayer>*)parentLayer.referencingLayer;
+    }
+    return parentLayer;
+}
+
++ (void)clipContext:(CGContextRef)ctx
+               path:(CGPathRef)path
+               rule:(CAShapeLayerFillRule)rule
+       drawingBlock:(dispatch_block_t)block
+{
+    CGContextSaveGState(ctx);
+    CGContextAddPath(ctx, path);
+    if([rule isEqualToString:kCAFillRuleEvenOdd] == YES) {
+        CGContextEOClip(ctx);
+    } else {
+        CGContextClip(ctx);
+    }
+    block();
+    CGContextRestoreGState(ctx);
+}
+
++ (void)performBasicRenderOfLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                        inContext:(CGContextRef)ctx
+                          options:(IJSVGLayerDrawingOptions)options
+{
+    dispatch_block_t drawingBlock = ^{
+        if(layer.clipPath != NULL) {
+            [self clipContext:ctx
+                         path:layer.clipPath
+                         rule:layer.clipRule
+                 drawingBlock:^{
+                [layer performRenderInContext:ctx];
+            }];
+            return;
+        }
+        [layer performRenderInContext:ctx];
+    };
+    [self applyBlendingMode:layer.blendingMode
+                  toContext:ctx
+               drawingBlock:^{
+        // we need to clip first
+        IJSVGLayerDrawingOptions opt = IJSVGLayerDrawingOptionIgnoreClipping;
+        BOOL ignoreClipping = (options & opt) == opt;
+        if(ignoreClipping == YES || layer.clipLayers == nil) {
+            drawingBlock();
+            return;
+        }
+        [self clipContextWithClipLayers:layer.clipLayers
+                                toLayer:layer
+                              inContext:ctx
+                           drawingBlock:drawingBlock];
+    }];
+}
+
++ (void)renderLayer:(CALayer<IJSVGDrawableLayer>*)layer
+          inContext:(CGContextRef)ctx
+            options:(IJSVGLayerDrawingOptions)options
+{
+    [self performBasicRenderOfLayer:layer
+                          inContext:ctx
+                            options:options];
+}
+
++ (void)applyBlendingMode:(CGBlendMode)blendMode
+                toContext:(CGContextRef)ctx
+             drawingBlock:(dispatch_block_t)drawingBlock
+{
+    if(blendMode == kCGBlendModeNormal) {
+        drawingBlock();
+        return;
+    }
+    CGContextSaveGState(ctx);
+    CGContextSetBlendMode(ctx, blendMode);
+    drawingBlock();
+    CGContextRestoreGState(ctx);
+}
+
+///// Shape layers are the only thing we can clip, as they contain a path, however
+///// the layer passed to us from a clip could have groups contained with in it that
+///// have transforms on them, so simply recursively iterate over them and concat
+///// their transforms down to the path and clip at the end with the path.
+//+ (void)recursivelyClip:(CALayer<IJSVGDrawableLayer>*)layer
+//              transform:(CGAffineTransform)transform
+//              inContext:(CGContextRef)ctx
+//{
+//    if([layer isKindOfClass:IJSVGShapeLayer.class]) {
+//        [self clipContextWithShapeLayer:(IJSVGShapeLayer*)layer
+//                              transform:transform
+//                              inContext:ctx];
+//        return;
+//    }
+//
+//    for(CALayer<IJSVGDrawableLayer>* drawableLayer in layer.sublayers) {
+//        CGAffineTransform drawTransform = CGAffineTransformConcat(transform,
+//                                                                  drawableLayer.affineTransform);
+//
+//        // If its not a shape layer, just go down the tree until we find one
+//        if([drawableLayer isKindOfClass:IJSVGShapeLayer.class] == NO) {
+//            [self recursivelyClip:drawableLayer
+//                        transform:drawTransform
+//                        inContext:ctx];
+//            continue;
+//        }
+//        IJSVGShapeLayer* shapeLayer = (IJSVGShapeLayer*)drawableLayer;
+//        [self clipContextWithShapeLayer:shapeLayer
+//                              transform:transform
+//                              inContext:ctx];
+//    }
+//}
+//
+//+ (void)clipContextWithShapeLayer:(IJSVGShapeLayer*)shapeLayer
+//                        transform:(CGAffineTransform)transform
+//                        inContext:(CGContextRef)ctx
+//{
+//    CGAffineTransform drawTransform = CGAffineTransformConcat(transform,
+//                                                              shapeLayer.affineTransform);
+//    // Shape layers paths are reset back to 0,0 origin, so in order to be
+//    // correct path, we need to shift it back to where it belongs.
+//    drawTransform = CGAffineTransformTranslate(transform,
+//                                           shapeLayer.frame.origin.x,
+//                                           shapeLayer.frame.origin.y);
+//    CGPathRef path = CGPathCreateCopyByTransformingPath(shapeLayer.path,
+//                                                        &drawTransform);
+//    CGContextAddPath(ctx, path);
+//    CGPathRelease(path);
+//}
+//
+//+ (void)clipContextWithClip:(CALayer<IJSVGDrawableLayer>*)clipLayer
+//                    toLayer:(CALayer<IJSVGDrawableLayer>*)layer
+//                  inContext:(CGContextRef)ctx
+//               drawingBlock:(dispatch_block_t)drawingBlock
+//{
+//    CGContextSaveGState(ctx);
+//    [self recursivelyClip:clipLayer
+//                transform:clipLayer.affineTransform
+//                inContext:ctx];
+//    if([layer.clipRule isEqualToString:kCAFillRuleEvenOdd]) {
+//        CGContextEOClip(ctx);
+//    } else {
+//        CGContextClip(ctx);
+//    }
+//    drawingBlock();
+//    CGContextRestoreGState(ctx);
+//}
+
++ (void)clipContextWithClipLayers:(NSArray<CALayer<IJSVGDrawableLayer>*>*)clipLayers
+                          toLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                        inContext:(CGContextRef)ctx
+                     drawingBlock:(dispatch_block_t)drawingBlock
+{
+    CGContextSaveGState(ctx);
+    const CGFloat maskTolerance = .5f;
+    const CGFloat scale = layer.backingScaleFactor;
+    CGRect rect = layer.clippingBoundingBox;
+    
+    // weed out the no empty clipPaths
+    if(CGRectEqualToRect(rect, CGRectZero) == YES) {
+        drawingBlock();
+        return;
+    }
+    
+    CGSize size = CGSizeMake(CGRectGetWidth(rect),
+                             CGRectGetHeight(rect));
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
+    void (^drawBlock)(CGContextRef maskCtx) = ^(CGContextRef maskCtx) {
+        CGImageRef maskImage = NULL;
+        for(CALayer<IJSVGDrawableLayer>* clipLayer in clipLayers) {
+            CGContextSaveGState(maskCtx);
+            CGRect layerRect = clipLayer.outerBoundingBox;
+            layerRect = CGRectApplyAffineTransform(layerRect, layer.clippingTransform);
+            CGImageRef layerMask = [self newMaskImageForLayer:clipLayer
+                                                      options:IJSVGLayerDrawingOptionIgnoreClipping
+                                                        scale:scale];
+            if(maskImage != NULL) {
+                CGRect maskRect = CGRectInset(rect, -maskTolerance, -maskTolerance);
+                CGContextClipToMask(maskCtx, maskRect, maskImage);
+            }
+            CGContextDrawImage(maskCtx, layerRect, layerMask);
+            CGImageRelease(layerMask);
+            if(maskImage != NULL) {
+                CGImageRelease(maskImage);
+            }
+            maskImage = CGBitmapContextCreateImage(maskCtx);
+            CGContextRestoreGState(maskCtx);
+        }
+        CGImageRelease(maskImage);
+    };
+    
+    CGImageRef image = [self newImageWithSize:size
+                                    drawBlock:drawBlock
+                                   colorSpace:colorSpace
+                                   bitmapInfo:kCGImageAlphaNone
+                                        scale:scale];
+    
+    // we need to transform the mask rect back based on the inner bounding
+    // box of the layer, as this could be a group layer that inner box is
+    // not at 0,0.
+    CGRect layerRect = layer.innerBoundingBox;
+    CGAffineTransform transform = CGAffineTransformMakeTranslation(CGRectGetMinX(layerRect),
+                                                                   CGRectGetMinY(layerRect));
+    rect = CGRectApplyAffineTransform(rect, transform);
+    CGContextClipToMask(ctx, rect, image);
+    drawingBlock();
+    CGImageRelease(image);
+    CGColorSpaceRelease(colorSpace);
+    CGContextRestoreGState(ctx);
+}
+
++ (void)clipContextWithMask:(CALayer<IJSVGDrawableLayer>*)maskLayer
+                    toLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                  inContext:(CGContextRef)ctx
+               drawingBlock:(dispatch_block_t)drawingBlock
+{
+    CGContextSaveGState(ctx);
+    CGFloat scale = layer.backingScaleFactor;
+    CGImageRef maskImage = [self newMaskImageForLayer:maskLayer
+                                              options:IJSVGLayerDrawingOptionNone
+                                                scale:scale];
+    CGContextClipToRect(ctx, maskLayer.maskingClippingRect);
+    CGContextClipToMask(ctx, maskLayer.maskingBoundingBox, maskImage);
+    drawingBlock();
+    CGImageRelease(maskImage);
+    CGContextRestoreGState(ctx);
+}
+
++ (CGImageRef)newMaskImageForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                           options:(IJSVGLayerDrawingOptions)options
+                             scale:(CGFloat)scale
+{
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceGray();
+    CGImageRef alphaMask = [self newImageForLayer:layer
+                                          options:options
+                                       colorSpace:colorSpace
+                                       bitmapInfo:kCGImageAlphaNone
+                                            scale:scale];
+    // low - high pairs
+    const CGFloat colors[6] = {
+        0.f, 11.f,
+        0.f, 11.f,
+        0.f, 11.f
+    };
+    CGImageRef masked = CGImageCreateWithMaskingColors(alphaMask, colors);
+    CGImageRelease(alphaMask);
+    CGColorSpaceRelease(colorSpace);
+    return masked;
+}
+
++ (CGImageRef)newImageWithSize:(CGSize)size
+                     drawBlock:(void (^)(CGContextRef context))drawBlock
+                    colorSpace:(CGColorSpaceRef)colorSpace
+                    bitmapInfo:(uint32_t)bitmapInfo
+                         scale:(CGFloat)scale
+{
+    CGContextRef offscreenContext = CGBitmapContextCreate(NULL,
+                                                          ceilf(size.width*scale),
+                                                          ceilf(size.height*scale),
+                                                          8, 0, colorSpace, bitmapInfo);
+    CGContextScaleCTM(offscreenContext, scale, scale);
+    drawBlock(offscreenContext);
+    CGImageRef image = CGBitmapContextCreateImage(offscreenContext);
+    CGContextRelease(offscreenContext);
+    return image;
+}
+
++ (CGImageRef)newImageForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                       options:(IJSVGLayerDrawingOptions)options
+                    colorSpace:(CGColorSpaceRef)colorSpace
+                    bitmapInfo:(uint32_t)bitmapInfo
+                         scale:(CGFloat)scale
+{
+    CALayer<IJSVGDrawableLayer>* referenceLayer = layer.referencingLayer ?: layer;
+    CGRect frame = layer.outerBoundingBox;
+    CGRect bounds = CGRectApplyAffineTransform(layer.innerBoundingBox,
+                                               [self userSpaceTransformForLayer:referenceLayer]);
+    CGContextRef offscreenContext = CGBitmapContextCreate(NULL,
+                                                          ceilf(frame.size.width*scale),
+                                                          ceilf(frame.size.height*scale),
+                                                          8, 0, colorSpace, bitmapInfo);
+    CGContextScaleCTM(offscreenContext, scale, scale);
+    CGContextConcatCTM(offscreenContext, CGAffineTransformMakeTranslation(-bounds.origin.x,
+                                                                          -bounds.origin.y));
+    [IJSVGLayer renderLayer:layer
+                  inContext:offscreenContext
+                    options:options];
+    CGImageRef image = CGBitmapContextCreateImage(offscreenContext);
+    CGContextRelease(offscreenContext);
+    return image;
+}
+
++ (CGRect)absoluteFrameForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    return (CGRect) {
+      .origin = [self absoluteOriginForLayer:layer],
+      .size = layer.frame.size
+    };
+}
+
++ (CGPoint)absoluteOriginForLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    CGPoint point = CGPointZero;
+    CALayer<IJSVGDrawableLayer>* pLayer = layer;
+    while (pLayer != nil) {
+        point.x += pLayer.frame.origin.x;
+        point.y += pLayer.frame.origin.y;
+        pLayer = pLayer.referencingLayer;
+    }
+    return point;
+}
+
++ (NSArray*)deepestSublayersOfLayer:(CALayer*)layer
+{
+    NSMutableArray* arr = [[NSMutableArray alloc] init];
+    for (CALayer* subLayer in layer.sublayers) {
+        if(subLayer.sublayers.count != 0) {
+            NSArray* moreLayers = [self deepestSublayersOfLayer:(IJSVGLayer*)subLayer];
+            [arr addObjectsFromArray:moreLayers];
+        } else {
+            [arr addObject:subLayer];
+        }
+    }
+    return arr;
+}
+
++ (void)recursivelyWalkLayer:(CALayer<IJSVGBasicLayer>*)layer
+                   withBlock:(void (^)(CALayer<IJSVGBasicLayer>* layer, BOOL* stop))block
+{
+    // call for layer and mask if there is one
+    BOOL stop = NO;
+    block(layer, &stop);
+    if(stop == YES) {
+        return;
+    }
+
+    // sublayers!!
+    for (CALayer<IJSVGBasicLayer>* aLayer in layer.sublayers) {
+        [self recursivelyWalkLayer:aLayer
+                         withBlock:block];
+    }
+}
+
++ (void)setBackingScaleFactor:(CGFloat)scale
+                renderQuality:(IJSVGRenderQuality)quality
+           recursivelyToLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    [self recursivelyWalkLayer:layer
+                     withBlock:^(CALayer<IJSVGDrawableLayer>*sublayer, BOOL *stop) {
+        if(sublayer.requiresBackingScale == YES) {
+            sublayer.backingScaleFactor = scale;
+        }
+        sublayer.renderQuality = quality;
+    }];
+}
+
++ (void)logLayer:(CALayer<IJSVGDrawableLayer>*)layer
+{
+    [self logLayer:layer
+             depth:0];
+}
+
++ (void)logLayer:(CALayer<IJSVGDrawableLayer>*)layer
+           depth:(NSUInteger)depth
+{
+    NSLog(@"%@ %@ frame: %@ transform: %@",[@"" stringByPaddingToLength:depth
+                                    withString:@"- - "
+                               startingAtIndex:0],  layer,
+          NSStringFromRect(layer.frame),
+          [IJSVGTransform affineTransformToSVGTransformComponentString:layer.affineTransform]);
+    for(CALayer<IJSVGDrawableLayer>* sublayer in layer.debugLayers) {
+        [self logLayer:sublayer
+                 depth:depth+1];
+    }
+}
+
++ (CGRect)calculateFrameForSublayers:(NSArray<CALayer<IJSVGDrawableLayer>*>*)layers
+{
+    CGRect rect = CGRectNull;
+    for(CALayer<IJSVGDrawableLayer>* layer in layers) {
+        CGRect layerFrame = layer.outerBoundingBox;
+        // if we are a transform layer, we can just apply its transform
+        // to its sublayers and keep going down the tree
+        if([layer isKindOfClass:IJSVGTransformLayer.class] == YES) {
+            CGRect frame = [self calculateFrameForSublayers:layer.sublayers];
+            frame = CGRectApplyAffineTransform(frame, layer.affineTransform);
+            layerFrame = frame;
+        }
+        if(CGRectIsNull(rect)) {
+            rect = layerFrame;
+            continue;
+        }
+        rect = CGRectUnion(rect, layerFrame);
+    }
+    return rect;
+}
+
+- (void)setBackingScaleFactor:(CGFloat)newFactor
+{
+    if(_backingScaleFactor == newFactor) {
+        return;
+    }
+    
+    _backingScaleFactor = newFactor;
+    self.contentsScale = newFactor;
+    self.rasterizationScale = newFactor;
+    
+    // make sure its applied to any mask or clipPath
+    _maskLayer.backingScaleFactor = newFactor;
+    for(CALayer<IJSVGDrawableLayer>* clipLayer in _clipLayers) {
+        clipLayer.backingScaleFactor = newFactor;
+    }
+}
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+    if(_maskLayer != nil) {
+        [self.class clipContextWithMask:_maskLayer
+                                toLayer:self
+                              inContext:ctx
+                           drawingBlock:^{
+            [super renderInContext:ctx];
+        }];
+        return;
+    }
+    [super renderInContext:ctx];
+}
+
+- (void)applySublayerMaskToContext:(CGContextRef)context
+                       forSublayer:(IJSVGLayer*)sublayer
+                        withOffset:(CGPoint)offset
+{
+    // apply any transforms needed
+    CGPoint layerOffset = offset;
+    CGAffineTransform sublayerTransform = CATransform3DGetAffineTransform(sublayer.transform);
+    CGContextConcatCTM(context, CGAffineTransformInvert(sublayerTransform));
+
+    // walk up the superlayer chain
+    CALayer* superlayer = self.superlayer;
+    if(IJSVGIsSVGLayer(superlayer) == YES) {
+        [(IJSVGLayer*)superlayer applySublayerMaskToContext:context
+                                                forSublayer:(IJSVGLayer*)self
+                                                 withOffset:layerOffset];
+    }
+
+    // grab the masking layer
+    IJSVGShapeLayer* maskingLayer = [self maskingLayer];
+
+    // if its a group we need to get the lowest level children
+    // and walk up the chain again
+    if([maskingLayer isKindOfClass:[IJSVGGroupLayer class]]) {
+        NSArray* subs = [IJSVGLayer deepestSublayersOfLayer:maskingLayer];
+        for (IJSVGLayer* subLayer in subs) {
+            [subLayer applySublayerMaskToContext:context
+                                     forSublayer:(IJSVGLayer*)self
+                                      withOffset:layerOffset];
+        }
+    } else if([maskingLayer isKindOfClass:[IJSVGShapeLayer class]]) {
+        // is a shape, go for it!
+        CGPathRef maskPath = maskingLayer.path;
+        CGContextTranslateCTM(context, -layerOffset.x, -layerOffset.y);
+        CGContextAddPath(context, maskPath);
+        CGContextClip(context);
+        CGContextTranslateCTM(context, layerOffset.x, layerOffset.y);
+    }
+    CGContextConcatCTM(context, sublayerTransform);
+}
+
+- (CGAffineTransform)absoluteTransform
+{
+    return [IJSVGLayer absoluteTransformForLayer:self];
+}
+
+- (BOOL)requiresBackingScale
+{
+    return _maskLayer != nil || (_clipLayers != nil && _clipLayers.count != 0);
+}
+
+- (IJSVGShapeLayer*)maskingLayer
+{
+    return (IJSVGShapeLayer*)_maskingLayer ?: nil;
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+{
+    [IJSVGLayer renderLayer:self
+                  inContext:ctx
+                    options:IJSVGLayerDrawingOptionNone];
+}
+
+- (CGRect)absoluteFrame
+{
+    return [self.class absoluteFrameForLayer:self];
+}
+
+- (CGRect)boundingBox
+{
+    return CGRectIsNull(_boundingBox) == NO ? _boundingBox : self.frame;
+}
+
+- (CGRect)outerBoundingBox
+{
+    return CGRectIsNull(_outerBoundingBox) == NO ? _outerBoundingBox : self.frame;
+}
+
+- (CGRect)boundingBoxBounds
+{
+    return (CGRect) {
+        .origin = CGPointZero,
+        .size = self.boundingBox.size
+    };
+}
+
+- (CGRect)innerBoundingBox
+{
+    return (CGRect) {
+        .origin = CGPointZero,
+        .size = self.outerBoundingBox.size
+    };
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencingLayer
+{
+    return _referencingLayer ?: self.superlayer;
+}
+
+-(NSArray<CALayer<IJSVGDrawableLayer>*>*)debugLayers
+{
+    return self.sublayers;
+}
+
+- (void)setClipPath:(CGPathRef)clipPath
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+    _clipPath = CGPathRetain(clipPath);
+}
+
+- (NSMapTable<NSNumber*,CALayer<IJSVGDrawableLayer>*>*)layerUsageMapTable
+{
+    if(_layerUsageMapTable == nil) {
+        _layerUsageMapTable = IJSVGLayerDefaultUsageMapTable();
+    }
+    return _layerUsageMapTable;
+}
+
+- (void)setLayer:(CALayer<IJSVGDrawableLayer>*)layer
+    forUsageType:(IJSVGLayerUsageType)type
+{
+    [self.layerUsageMapTable setObject:layer
+                                forKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)layerForUsageType:(IJSVGLayerUsageType)type
+{
+    return [self.layerUsageMapTable objectForKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)strokeLayer:(IJSVGLayerUsageType*)usageType
+{
+    CALayer<IJSVGDrawableLayer>* layer = nil;
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGeneric]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGeneric;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGradient]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGradient;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokePattern]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokePattern;
+        return layer;
+    }
+    return nil;
+}
+
+- (void)addTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits |= traits;
+}
+
+- (void)removeTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits = _layerTraits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGLayerTraits)traits
+{
+    return (_layerTraits & traits) == traits;
+}
+
+- (BOOL)treatImplicitOriginAsTransform
+{
+    return YES;
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    IJSVGTraitedColorStorage* colorList = [[IJSVGTraitedColorStorage alloc] init];
+    for(CALayer<IJSVGDrawableLayer>* layer in self.sublayers) {
+        [colorList unionColorStorage:layer.colors];
+    }
+    return colorList;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+{
+    return [self.class firstSublayerOfClass:aClass
+                                  fromLayer:self];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGPatternLayer.h

@@ -0,0 +1,22 @@
+//
+//  IJSVGPatternLayer.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGPattern.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface IJSVGPatternLayer : IJSVGLayer
+
+@property (nonatomic, strong) CALayer<IJSVGDrawableLayer>* pattern;
+@property (nonatomic, strong) IJSVGPattern* patternNode;
+
+- (void)computeCellSize:(CGSize*)cellSize
+                viewBox:(CGRect*)viewBox
+                 origin:(CGPoint*)origin;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGPatternLayer.m

@@ -0,0 +1,163 @@
+//
+//  IJSVGPatternLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGPatternLayer.h>
+#import <IJSVG/IJSVGTransform.h>
+#import <IJSVG/IJSVGUnitRect.h>
+#import <IJSVG/IJSVGViewBox.h>
+
+@interface IJSVGPatternLayer ()
+
+@property (nonatomic, assign, readonly) CGSize cellSize;
+@property (nonatomic, assign) CGRect viewBox;
+
+@end
+
+@implementation IJSVGPatternLayer
+
+- (BOOL)requiresBackingScale
+{
+    return YES;
+}
+
+- (void)setBackingScaleFactor:(CGFloat)backingScaleFactor
+{
+    [super setBackingScaleFactor:backingScaleFactor];
+    [IJSVGLayer setBackingScaleFactor:backingScaleFactor
+                        renderQuality:self.renderQuality
+                   recursivelyToLayer:self.pattern];
+}
+
+void IJSVGPatternDrawingCallBack(void* info, CGContextRef ctx)
+{
+    // reassign the layer
+    IJSVGPatternLayer* layer = (__bridge IJSVGPatternLayer*)info;
+    CGSize size = layer.cellSize;
+    CGContextSaveGState(ctx);
+    CGRect rect = CGRectMake(0.f, 0.f, size.width, size.height);
+    CGContextClipToRect(ctx, rect);
+    
+    IJSVGViewBoxAlignment alignment = layer.patternNode.viewBoxAlignment;
+    IJSVGViewBoxMeetOrSlice meetOrSlice = layer.patternNode.viewBoxMeetOrSlice;
+    CGRect viewBox = layer.viewBox;
+    IJSVGViewBoxDrawingBlock drawBlock = ^(CGFloat scale[]) {
+        [IJSVGLayer renderLayer:layer.pattern
+                      inContext:ctx
+                        options:IJSVGLayerDrawingOptionNone];
+    };
+    IJSVGContextDrawViewBox(ctx, viewBox, rect, alignment, meetOrSlice,
+                            drawBlock);
+    CGContextSaveGState(ctx);
+};
+
+- (CALayer<IJSVGDrawableLayer>*)referencingLayer
+{
+    return [super referencingLayer] ?: self.superlayer;
+}
+
+- (void)computeCellSize:(CGSize*)cellSize
+                viewBox:(CGRect*)viewBox
+                 origin:(CGPoint*)origin
+{
+    CALayer<IJSVGDrawableLayer>* layer = (CALayer<IJSVGDrawableLayer>*)self.referencingLayer;
+    CGRect rect = IJSVGLayerGetBoundingBoxBounds(layer);
+    
+    // get the bounds, we need these as when we render we might need to swap
+    // the coordinates over to objectBoundingBox
+    IJSVGUnitLength* xLength = _patternNode.x;
+    IJSVGUnitLength* yLength = _patternNode.y;
+    IJSVGUnitLength* wLength = _patternNode.width;
+    IJSVGUnitLength* hLength = _patternNode.height;
+        
+    // actually do the swap if required
+    if(_patternNode.units == IJSVGUnitObjectBoundingBox) {
+        wLength = wLength.lengthByMatchingPercentage;
+        hLength = hLength.lengthByMatchingPercentage;
+        xLength = xLength.lengthByMatchingPercentage;
+        yLength = yLength.lengthByMatchingPercentage;
+    }
+    
+    *origin = CGPointMake([xLength computeValue:rect.size.width],
+                          [yLength computeValue:rect.size.height]);
+    
+    CGFloat width = [wLength computeValue:rect.size.width];
+    CGFloat height = [hLength computeValue:rect.size.height];
+    *cellSize = CGSizeMake(width, height);
+    
+    // who knew that patterns have viewBoxes? Not me, but here is an implementation
+    // of it anyway
+    if(_patternNode.viewBox != nil && _patternNode.viewBox.isZeroRect == NO) {
+        IJSVGUnitRect* nViewBox = _patternNode.viewBox;
+        if(_patternNode.contentUnits == IJSVGUnitObjectBoundingBox) {
+            nViewBox = [nViewBox copyByConvertingToUnitsLengthType:IJSVGUnitLengthTypePercentage];
+        }
+        *viewBox = [nViewBox computeValue:rect.size];
+    } else {
+        // no viewbox is assigned, so just map it 1:1 with its cellSize
+        *viewBox = CGRectMake(0.f, 0.f, cellSize->width, cellSize->height);
+    }
+}
+
+- (void)drawInContext:(CGContextRef)ctx
+{
+    // holder for callback
+    static const CGPatternCallbacks callbacks = { 0, &IJSVGPatternDrawingCallBack, NULL };
+
+    // create base pattern space
+    CGColorSpaceRef patternSpace = CGColorSpaceCreatePattern(NULL);
+    CGContextSetFillColorSpace(ctx, patternSpace);
+    CGColorSpaceRelease(patternSpace);
+    
+    CALayer<IJSVGDrawableLayer>* layer = (CALayer<IJSVGDrawableLayer>*)self.referencingLayer;
+            
+    // transform us back into the correct space
+    CGAffineTransform transform = CGAffineTransformIdentity;
+    if(_patternNode.units == IJSVGUnitUserSpaceOnUse) {
+        transform = [IJSVGLayer userSpaceTransformForLayer:layer];
+    }
+    
+    CGPoint origin = CGPointZero;
+    [self computeCellSize:&_cellSize
+                  viewBox:&_viewBox
+                   origin:&origin];
+    
+    // transform the X and Y shift
+    transform = CGAffineTransformConcat(transform, IJSVGConcatTransforms(self.patternNode.transforms));
+    transform = CGAffineTransformTranslate(transform, origin.x, origin.y);
+    
+    // its possible that this layer is shifted inwards due to a stroke on the
+    // parent layer
+    transform = CGAffineTransformConcat(transform, [IJSVGLayer userSpaceTransformForLayer:self]);
+            
+    // create the pattern
+    CGRect selfBounds = IJSVGLayerGetBoundingBoxBounds(self);
+    CGPatternRef ref = CGPatternCreate((void*)self, selfBounds,
+        transform, _cellSize.width, _cellSize.height,
+        kCGPatternTilingConstantSpacing,
+        true, &callbacks);
+
+    // set the pattern then release it
+    CGFloat alpha = 1.f;
+    CGContextSetFillPattern(ctx, ref, &alpha);
+    CGPatternRelease(ref);
+
+    // fill it
+    CGContextFillRect(ctx, selfBounds);
+}
+
+- (NSArray<CALayer<IJSVGDrawableLayer>*>*)debugLayers
+{
+    return @[self.pattern];
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    return _pattern.colors;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGRootLayer.h

@@ -0,0 +1,24 @@
+//
+//  IJSVGRootLayer.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 15/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVG.h>
+
+@interface IJSVGRootLayer : IJSVGGroupLayer {
+    
+@private
+    BOOL _disableBackingScalePropagation;
+    
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+               viewPort:(CGRect)viewPort
+           backingScale:(CGFloat)backingScale
+                quality:(IJSVGRenderQuality)quality
+    ignoreIntrinsicSize:(BOOL)ignoreIntrinsicSize;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGRootLayer.m

@@ -0,0 +1,93 @@
+//
+//  IJSVGRootLayer.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 15/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGRootLayer.h>
+
+@implementation IJSVGRootLayer
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+    if(self.viewBox != nil) {
+        CGRect viewBox = [self.viewBox computeValue:CGSizeZero];
+        __weak IJSVGRootLayer* weakSelf = self;
+        IJSVGViewBoxDrawingBlock drawingBlock = ^(CGFloat scale[]) {
+            CGContextSaveGState(ctx);
+            // we have to make sure we set the backing scale factor once
+            // we know how scale this will be drawn at
+            CGFloat nScale = MIN(scale[0], scale[1]);
+            nScale += weakSelf.backingScaleFactor;
+            weakSelf.backingScaleFactor = nScale;
+            
+            // perform the actual render now we have computed backing scale
+            [super performRenderInContext:ctx];
+            CGContextRestoreGState(ctx);
+        };
+        
+        IJSVGContextDrawViewBox(ctx, viewBox, IJSVGLayerGetBoundingBoxBounds(self),
+                                self.viewBoxAlignment,
+                                self.viewBoxMeetOrSlice, drawingBlock);
+        return;
+    }
+    [super performRenderInContext:ctx];
+}
+
+- (void)setBackingScaleFactor:(CGFloat)backingScaleFactor
+{
+    // get nearest .5f
+    backingScaleFactor = MAX(round(backingScaleFactor * 2.f) / 2.f, .5f);
+    [super setBackingScaleFactor:backingScaleFactor];
+    if(_disableBackingScalePropagation == YES) {
+        return;
+    }
+    [self propagateBackingScalePropertiesToSublayers];
+}
+
+- (void)propagateBackingScalePropertiesToSublayers
+{
+    for(CALayer<IJSVGDrawableLayer>* layer in self.sublayers) {
+        [IJSVGLayer setBackingScaleFactor:self.backingScaleFactor
+                            renderQuality:self.renderQuality
+                       recursivelyToLayer:layer];
+    }
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+               viewPort:(CGRect)viewPort
+           backingScale:(CGFloat)backingScale
+                quality:(IJSVGRenderQuality)quality
+    ignoreIntrinsicSize:(BOOL)ignoreIntrinsicSize
+{
+    CGRect frame = viewPort;
+    IJSVGUnitSize* size = nil;
+    
+    // The SVG might have an intrinsic size against it, if so, we need to use
+    // that instead of the viewPort size to make sure we obey the render correctly.
+    if(ignoreIntrinsicSize == NO && (size = self.intrinsicSize) != nil) {
+        CGFloat width = 0.f;
+        CGFloat height = 0.f;
+        if((width = [size.width computeValue:frame.size.width]) != 0.f) {
+            frame.size.width = width;
+        }
+        if((height = [size.height computeValue:frame.size.height]) != 0.f) {
+            frame.size.height = height;
+        }
+    }
+    self.frame = frame;
+    _disableBackingScalePropagation = YES;
+    self.backingScaleFactor = backingScale;
+    self.renderQuality = quality;
+    _disableBackingScalePropagation = NO;
+    [self renderInContext:ctx];
+}
+
+- (BOOL)treatImplicitOriginAsTransform
+{
+    return NO;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGShapeLayer.h

@@ -0,0 +1,26 @@
+//
+//  IJSVGShapeLayer.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <QuartzCore/QuartzCore.h>
+
+@interface IJSVGShapeLayer : CAShapeLayer <IJSVGDrawableLayer, IJSVGPathableLayer> {
+
+@private
+    IJSVGLayer* _maskingLayer;
+    NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* _layerUsageMapTable;
+}
+
+@property (nonatomic, assign) IJSVGPrimitivePathType primitiveType;
+
+- (void)applySublayerMaskToContext:(CGContextRef)context
+                       forSublayer:(IJSVGLayer*)sublayer
+                        withOffset:(CGPoint)offset;
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGShapeLayer.m

@@ -0,0 +1,312 @@
+//
+//  IJSVGShapeLayer.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 07/01/2017.
+//  Copyright © 2017 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroupLayer.h>
+#import <IJSVG/IJSVGShapeLayer.h>
+#import <IJSVG/IJSVGStrokeLayer.h>
+#import <IJSVG/IJSVGGradientLayer.h>
+#import <IJSVG/IJSVGTraitedColorStorage.h>
+#import <IJSVG/IJSVGPatternLayer.h>
+
+@implementation IJSVGShapeLayer
+
+@synthesize backingScaleFactor = _backingScaleFactor;
+@synthesize requiresBackingScale;
+@synthesize renderQuality;
+@synthesize blendingMode;
+@synthesize absoluteOrigin;
+@synthesize clipPath = _clipPath;
+@synthesize clipRule;
+@synthesize clipLayers = _clipLayers;
+@synthesize clippingTransform;
+@synthesize clippingBoundingBox;
+@synthesize maskingClippingRect;
+@synthesize clipPathTransform;
+@synthesize colors;
+@synthesize boundingBox;
+@synthesize layerTraits = _layerTraits;
+@synthesize maskingBoundingBox;
+@synthesize filter;
+@synthesize referencingLayer = _referencingLayer;
+@synthesize outerBoundingBox;
+@synthesize maskLayer = _maskLayer;
+@synthesize treatImplicitOriginAsTransform;
+
+- (void)dealloc
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+}
+
+- (id<CAAction>)actionForKey:(NSString*)event
+{
+    return nil;
+}
+
+- (CGRect)absoluteFrame
+{
+    return [IJSVGLayer absoluteFrameForLayer:self];
+}
+
+- (CGAffineTransform)absoluteTransform
+{
+    return [IJSVGLayer absoluteTransformForLayer:self];
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencingLayer
+{
+    return _referencingLayer ?: self.superlayer;
+}
+
+- (CGRect)boundingBoxBounds
+{
+    return (CGRect) {
+        .origin = CGPointZero,
+        .size = self.boundingBox.size
+    };
+}
+
+- (CGRect)innerBoundingBox
+{
+    return self.bounds;
+}
+
+- (BOOL)requiresBackingScale
+{
+    return _maskLayer != nil || (_clipLayers != nil && _clipLayers.count != 0);
+}
+
+- (void)setClipPath:(CGPathRef)clipPath
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+    _clipPath = CGPathRetain(clipPath);
+}
+
+- (void)setBackingScaleFactor:(CGFloat)newFactor
+{
+    if(_backingScaleFactor == newFactor) {
+        return;
+    }
+        
+    _backingScaleFactor = newFactor;
+    self.contentsScale = newFactor;
+    self.rasterizationScale = newFactor;
+    
+    // make sure its applied to any mask or clipPath
+    _maskLayer.backingScaleFactor = newFactor;
+    
+    for(CALayer<IJSVGDrawableLayer>* clipLayer in _clipLayers) {
+        clipLayer.backingScaleFactor = newFactor;
+    }
+    
+    [self setNeedsDisplay];
+}
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+    if(_maskLayer != nil) {
+        [IJSVGLayer clipContextWithMask:_maskLayer
+                                toLayer:self
+                              inContext:ctx
+                           drawingBlock:^{
+            [super renderInContext:ctx];
+        }];
+        return;
+    }
+    [super renderInContext:ctx];
+}
+
+- (void)applySublayerMaskToContext:(CGContextRef)context
+                       forSublayer:(IJSVGLayer*)sublayer
+                        withOffset:(CGPoint)offset
+{
+    // apply any transforms needed
+    CGPoint layerOffset = offset;
+    CGAffineTransform sublayerTransform = CATransform3DGetAffineTransform(sublayer.transform);
+    CGContextConcatCTM(context, CGAffineTransformInvert(sublayerTransform));
+
+    // walk up the superlayer chain
+    CALayer* superlayer = self.superlayer;
+    if(IJSVGIsSVGLayer(superlayer) == YES) {
+        [(IJSVGLayer*)superlayer applySublayerMaskToContext:context
+                                                forSublayer:(IJSVGLayer*)self
+                                                 withOffset:layerOffset];
+    }
+
+    // grab the masking layer
+    IJSVGShapeLayer* maskingLayer = [self maskingLayer];
+
+    // if its a group we need to get the lowest level children
+    // and walk up the chain again
+    if([maskingLayer isKindOfClass:[IJSVGGroupLayer class]]) {
+        NSArray* subs = [IJSVGLayer deepestSublayersOfLayer:maskingLayer];
+        for (IJSVGLayer* subLayer in subs) {
+            [subLayer applySublayerMaskToContext:context
+                                     forSublayer:(IJSVGLayer*)self
+                                      withOffset:layerOffset];
+        }
+    } else if([maskingLayer isKindOfClass:[IJSVGShapeLayer class]]) {
+        // is a shape, go for it!
+        CGPathRef maskPath = maskingLayer.path;
+        CGContextTranslateCTM(context, -layerOffset.x, -layerOffset.y);
+        CGContextAddPath(context, maskPath);
+        CGContextClip(context);
+        CGContextTranslateCTM(context, layerOffset.x, layerOffset.y);
+    }
+    CGContextConcatCTM(context, sublayerTransform);
+}
+
+- (IJSVGShapeLayer*)maskingLayer
+{
+    return (IJSVGShapeLayer*)_maskingLayer ?: nil;
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+{
+    [IJSVGLayer renderLayer:(IJSVGLayer*)self
+                  inContext:ctx
+                    options:IJSVGLayerDrawingOptionNone];
+}
+
+- (NSMapTable<NSNumber*,CALayer<IJSVGDrawableLayer>*>*)layerUsageMapTable
+{
+    if(_layerUsageMapTable == nil) {
+        _layerUsageMapTable = IJSVGLayerDefaultUsageMapTable();
+    }
+    return _layerUsageMapTable;
+}
+
+- (void)setLayer:(CALayer<IJSVGDrawableLayer>*)layer
+    forUsageType:(IJSVGLayerUsageType)type
+{
+    [self.layerUsageMapTable setObject:layer
+                                forKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)layerForUsageType:(IJSVGLayerUsageType)type
+{
+    return [self.layerUsageMapTable objectForKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)strokeLayer:(IJSVGLayerUsageType*)usageType
+{
+    CALayer<IJSVGDrawableLayer>* layer = nil;
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGeneric]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGeneric;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGradient]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGradient;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokePattern]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokePattern;
+        return layer;
+    }
+    return nil;
+}
+
+-(NSArray<CALayer<IJSVGDrawableLayer>*>*)debugLayers
+{
+    return self.sublayers;
+}
+
+- (BOOL)treatImplicitOriginAsTransform
+{
+    return YES;
+}
+
+- (void)addTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits |= traits;
+}
+
+- (void)removeTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits = _layerTraits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGLayerTraits)traits
+{
+    return (_layerTraits & traits) == traits;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+{
+    return [IJSVGLayer firstSublayerOfClass:aClass
+                                  fromLayer:self];
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    IJSVGTraitedColorStorage* list = [[IJSVGTraitedColorStorage alloc] init];
+    
+    // we have a fill color
+    if([self matchesTraits:IJSVGLayerTraitFilled] == YES) {
+        IJSVGShapeLayer* fillLayer = nil;
+        if((fillLayer = (IJSVGShapeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeFillGeneric]) != nil) {
+            CGColorRef colorRef = NULL;
+            if((colorRef = fillLayer.fillColor) != NULL) {
+                NSColor* nsColor = [NSColor colorWithCGColor:colorRef];
+                IJSVGTraitedColor* color = [IJSVGTraitedColor colorWithColor:nsColor
+                                                                      traits:IJSVGColorUsageTraitFill];
+                [list addColor:color];
+            }
+        }
+        
+        // patterns
+        if((fillLayer = (IJSVGShapeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeFillPattern]) != nil) {
+            IJSVGTraitedColorStorage* storage = fillLayer.colors;
+            [storage addTraits:IJSVGColorUsageTraitFill];
+            [list unionColorStorage:storage];
+        }
+        
+        // gradients
+        if((fillLayer = (IJSVGShapeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeFillGradient]) != nil) {
+            IJSVGTraitedColorStorage* storage = fillLayer.colors;
+            [storage addTraits:IJSVGColorUsageTraitGradientStop];
+            [list unionColorStorage:storage];
+        }
+    }
+    
+    // we have a stroke color
+    if([self matchesTraits:IJSVGLayerTraitStroked] == YES) {
+        IJSVGStrokeLayer* strokeLayer = nil;
+        if((strokeLayer = (IJSVGStrokeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeStrokeGeneric]) != nil) {
+            CGColorRef colorRef = NULL;
+            if((colorRef = strokeLayer.strokeColor) != NULL) {
+                NSColor* nsColor = [NSColor colorWithCGColor:colorRef];
+                IJSVGTraitedColor* color = [IJSVGTraitedColor colorWithColor:nsColor
+                                                                     traits:IJSVGColorUsageTraitStroke];
+                [list addColor:color];
+            }
+        }
+        
+        // patterns
+        if((strokeLayer = (IJSVGStrokeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeStrokePattern]) != nil) {
+            IJSVGTraitedColorStorage* storage = strokeLayer.colors;
+            [storage addTraits:IJSVGColorUsageTraitFill];
+            [list unionColorStorage:storage];
+        }
+        
+        // gradients
+        if((strokeLayer = (IJSVGStrokeLayer*)[self layerForUsageType:IJSVGLayerUsageTypeStrokeGradient]) != nil) {
+            IJSVGTraitedColorStorage* storage = strokeLayer.colors;
+            [storage addTraits:IJSVGColorUsageTraitGradientStop];
+            [list unionColorStorage:storage];
+        }
+    }
+    return list;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGStrokeLayer.h

@@ -6,7 +6,7 @@
 //  Copyright © 2017 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGShapeLayer.h"
+#import <IJSVG/IJSVGShapeLayer.h>
 
 @interface IJSVGStrokeLayer : IJSVGShapeLayer
 

Framework/IJSVG/IJSVG/Source/Layers/IJSVGStrokeLayer.m

@@ -6,7 +6,7 @@
 //  Copyright © 2017 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGStrokeLayer.h"
+#import <IJSVG/IJSVGStrokeLayer.h>
 
 @implementation IJSVGStrokeLayer
 

Framework/IJSVG/IJSVG/Source/Layers/IJSVGTileLayer.h

@@ -0,0 +1,17 @@
+//
+//  IJSVGTileLayer.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/06/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <QuartzCore/QuartzCore.h>
+#import <IJSVG/IJSVGLayer.h>
+
+@interface IJSVGTileLayer : CATiledLayer <IJSVGDrawableLayer> {
+@private
+    NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* _layerUsageMapTable;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGTileLayer.m

@@ -0,0 +1,150 @@
+//
+//  IJSVGTileLayer.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/06/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import "IJSVGTileLayer.h"
+
+@implementation IJSVGTileLayer
+
+@synthesize clipLayers;
+@synthesize backingScaleFactor;
+@synthesize renderQuality;
+@synthesize requiresBackingScale;
+@synthesize maskLayer = _maskLayer;
+@synthesize fillRule = _fillRule;
+@synthesize clipRule = _clipRule;
+@synthesize absoluteFrame;
+@synthesize boundingBox;
+@synthesize outerBoundingBox;
+@synthesize filter = _filter;
+@synthesize innerBoundingBox;
+@synthesize maskingBoundingBox;
+@synthesize maskingClippingRect;
+@synthesize clippingBoundingBox;
+@synthesize clippingTransform;
+@synthesize layerTraits = _layerTraits;
+@synthesize clipPath = _clipPath;
+@synthesize clipPathTransform;
+@synthesize referencingLayer = _referencingLayer;
+@synthesize absoluteOrigin;
+@synthesize blendingMode;
+@synthesize colors;
+
+- (void)dealloc
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+}
+
+- (id<CAAction>)actionForKey:(NSString*)event
+{
+    return nil;
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencedLayer
+{
+    return self.sublayers.firstObject;
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencingLayer
+{
+    return _referencingLayer ?: self.superlayer;
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+{
+    [IJSVGLayer renderLayer:self
+                  inContext:ctx
+                    options:IJSVGLayerDrawingOptionNone];
+}
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+    [super renderInContext:ctx];
+}
+
+- (NSArray<CALayer<IJSVGDrawableLayer>*>*)debugLayers
+{
+    return self.sublayers;
+}
+
+- (void)setClipPath:(CGPathRef)clipPath
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+    _clipPath = CGPathRetain(clipPath);
+}
+
+- (NSMapTable<NSNumber*,CALayer<IJSVGDrawableLayer>*>*)layerUsageMapTable
+{
+    if(_layerUsageMapTable == nil) {
+        _layerUsageMapTable = IJSVGLayerDefaultUsageMapTable();
+    }
+    return _layerUsageMapTable;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)layerForUsageType:(IJSVGLayerUsageType)type
+{
+    return [self.layerUsageMapTable objectForKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)strokeLayer:(IJSVGLayerUsageType*)usageType
+{
+    CALayer<IJSVGDrawableLayer>* layer = nil;
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGeneric]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGeneric;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGradient]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGradient;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokePattern]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokePattern;
+        return layer;
+    }
+    return nil;
+}
+
+- (void)setLayer:(CALayer<IJSVGDrawableLayer>*)layer
+    forUsageType:(IJSVGLayerUsageType)type
+{
+    [self.layerUsageMapTable setObject:layer
+                                forKey:@(type)];
+}
+
+- (void)addTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits |= traits;
+}
+
+- (void)removeTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits = _layerTraits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGLayerTraits)traits
+{
+    return (_layerTraits & traits) == traits;
+}
+
+- (BOOL)treatImplicitOriginAsTransform
+{
+    return YES;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+{
+    return [IJSVGLayer firstSublayerOfClass:aClass
+                                  fromLayer:self];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGTransformLayer.h

@@ -0,0 +1,17 @@
+//
+//  IJSVGTransformLayer.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 31/03/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <QuartzCore/QuartzCore.h>
+#import <IJSVG/IJSVGLayer.h>
+
+@interface IJSVGTransformLayer : CATransformLayer <IJSVGDrawableLayer> {
+@private
+    NSMapTable<NSNumber*, CALayer<IJSVGDrawableLayer>*>* _layerUsageMapTable;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Layers/IJSVGTransformLayer.m

@@ -0,0 +1,160 @@
+//
+//  IJSVGTransformLayer.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 31/03/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGTransformLayer.h>
+#import <IJSVG/IJSVGTraitedColorStorage.h>
+
+@implementation IJSVGTransformLayer
+
+@synthesize clipLayers;
+@synthesize backingScaleFactor;
+@synthesize renderQuality;
+@synthesize requiresBackingScale;
+@synthesize maskLayer = _maskLayer;
+@synthesize fillRule = _fillRule;
+@synthesize clipRule = _clipRule;
+@synthesize absoluteFrame;
+@synthesize boundingBox;
+@synthesize outerBoundingBox;
+@synthesize filter = _filter;
+@synthesize innerBoundingBox;
+@synthesize maskingBoundingBox;
+@synthesize maskingClippingRect;
+@synthesize clippingBoundingBox;
+@synthesize clippingTransform;
+@synthesize layerTraits = _layerTraits;
+@synthesize clipPath = _clipPath;
+@synthesize clipPathTransform;
+@synthesize colors;
+@synthesize absoluteOrigin;
+@synthesize blendingMode;
+@synthesize referencingLayer = _referencingLayer;
+
+- (void)dealloc
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+}
+
+- (id<CAAction>)actionForKey:(NSString*)event
+{
+    return nil;
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencedLayer
+{
+    return self.sublayers.firstObject;
+}
+
+- (CALayer<IJSVGDrawableLayer> *)referencingLayer
+{
+    return _referencingLayer ?: self.superlayer;
+}
+
+- (void)renderInContext:(CGContextRef)ctx
+{
+    [IJSVGLayer renderLayer:self
+                  inContext:ctx
+                    options:IJSVGLayerDrawingOptionNone];
+}
+
+- (void)performRenderInContext:(CGContextRef)ctx
+{
+    [super renderInContext:ctx];
+}
+
+- (NSArray<CALayer<IJSVGDrawableLayer>*>*)debugLayers
+{
+    return self.sublayers;
+}
+
+- (void)setClipPath:(CGPathRef)clipPath
+{
+    if(_clipPath != NULL) {
+        CGPathRelease(_clipPath);
+    }
+    _clipPath = CGPathRetain(clipPath);
+}
+
+- (NSMapTable<NSNumber*,CALayer<IJSVGDrawableLayer>*>*)layerUsageMapTable
+{
+    if(_layerUsageMapTable == nil) {
+        _layerUsageMapTable = IJSVGLayerDefaultUsageMapTable();
+    }
+    return _layerUsageMapTable;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)layerForUsageType:(IJSVGLayerUsageType)type
+{
+    return [self.layerUsageMapTable objectForKey:@(type)];
+}
+
+- (CALayer<IJSVGDrawableLayer>*)strokeLayer:(IJSVGLayerUsageType*)usageType
+{
+    CALayer<IJSVGDrawableLayer>* layer = nil;
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGeneric]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGeneric;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokeGradient]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokeGradient;
+        return layer;
+    }
+    
+    if((layer = [self layerForUsageType:IJSVGLayerUsageTypeStrokePattern]) != nil) {
+        *usageType = IJSVGLayerUsageTypeStrokePattern;
+        return layer;
+    }
+    return nil;
+}
+
+- (void)setLayer:(CALayer<IJSVGDrawableLayer>*)layer
+    forUsageType:(IJSVGLayerUsageType)type
+{
+    [self.layerUsageMapTable setObject:layer
+                                forKey:@(type)];
+}
+
+- (void)addTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits |= traits;
+}
+
+- (void)removeTraits:(IJSVGLayerTraits)traits
+{
+    _layerTraits = _layerTraits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGLayerTraits)traits
+{
+    return (_layerTraits & traits) == traits;
+}
+
+- (BOOL)treatImplicitOriginAsTransform
+{
+    return YES;
+}
+
+- (CALayer<IJSVGDrawableLayer>*)firstSublayerOfClass:(Class)aClass
+{
+    return [IJSVGLayer firstSublayerOfClass:aClass
+                                  fromLayer:self];
+}
+
+- (IJSVGTraitedColorStorage*)colors
+{
+    IJSVGTraitedColorStorage* colorList = [[IJSVGTraitedColorStorage alloc] init];
+    for(CALayer<IJSVGDrawableLayer>* layer in self.sublayers) {
+        [colorList unionColorStorage:layer.colors];
+    }
+    return colorList;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/Filter Effects/IJSVGFilterEffectGaussianBlur.h

@@ -0,0 +1,13 @@
+//
+//  IJSVGFilterEffectGaussianBlur.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGFilterEffect.h>
+
+@interface IJSVGFilterEffectGaussianBlur : IJSVGFilterEffect
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/Filter Effects/IJSVGFilterEffectGaussianBlur.m

@@ -0,0 +1,36 @@
+//
+//  IJSVGFilterEffectGaussianBlur.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGFilterEffectGaussianBlur.h>
+#import <IJSVG/IJSVGThreadManager.h>
+
+@implementation IJSVGFilterEffectGaussianBlur
+
++ (CIFilter*)sharedFilter
+{
+    IJSVGThreadManager* manager = IJSVGThreadManager.currentManager;
+    NSString* key = @"CIFilterGaussianBlur";
+    CIFilter* filter = nil;
+    if((filter = [manager userInfoObjectForKey:key]) == nil) {
+        filter = [CIFilter filterWithName:@"CIGaussianBlur"];
+        [manager setUserInfoObject:filter
+                            forKey:key];
+    }
+    return filter;
+}
+
+- (CIImage*)processImage:(CIImage*)image
+{
+    CIFilter* filter = [self.class sharedFilter];
+    [filter setDefaults];
+    [filter setValue:image forKey:kCIInputImageKey];
+    [filter setValue:@(self.stdDeviation.value) forKey:kCIInputRadiusKey];
+    return [filter valueForKey:kCIOutputImageKey];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGClipPath.h

@@ -0,0 +1,16 @@
+//
+//  IJSVGClipPath.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/05/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroup.h>
+
+@interface IJSVGClipPath : IJSVGGroup {
+}
+
+@property (nonatomic, readonly) IJSVGWindingRule computedClipRule;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGClipPath.m

@@ -0,0 +1,88 @@
+//
+//  IJSVGClipPath.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/05/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGClipPath.h>
+#import <IJSVG/IJSVGRootNode.h>
+
+@implementation IJSVGClipPath
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage setBit:IJSVGNodeAttributeX];
+    [storage setBit:IJSVGNodeAttributeY];
+    [storage setBit:IJSVGNodeAttributeWidth];
+    [storage setBit:IJSVGNodeAttributeHeight];
+    [storage setBit:IJSVGNodeAttributeClipPathUnits];
+    [storage setBit:IJSVGNodeAttributeClipRule];
+    return storage;
+}
+
+- (void)setDefaults
+{
+    self.units = IJSVGUnitObjectBoundingBox;
+    self.contentUnits = IJSVGUnitUserSpaceOnUse;
+    self.windingRule = IJSVGWindingRuleNonZero;
+    self.overflowVisibility = IJSVGOverflowVisibilityHidden;
+    self.fill = [IJSVGColorNode colorNodeWithColor:NSColor.whiteColor];
+}
+
+- (IJSVGUnitType)contentUnitsWithReferencingNodeBounds:(CGRect*)bounds
+{
+    IJSVGNode* node = nil;
+    IJSVGUnitType units = [self contentUnitsWithReferencingNode:&node];
+    if(units == IJSVGUnitUserSpaceOnUse) {
+        *bounds = node.rootNode.bounds;
+    } else {
+        *bounds = node.parentNode.bounds;
+    }
+    return units;
+}
+
+- (void)postProcess
+{
+    // clip paths only allow shapes in them, nothing else, we can simply
+    // check the node types for the trait of pathed
+    IJSVGNodeTraits childTraits = IJSVGNodeTraitPathed;
+    for(IJSVGNode* childNode in self.children.copy) {
+        if([childNode matchesTraits:childTraits] == NO) {
+            BOOL remove = YES;
+            IJSVGNodeType type = childNode.type;
+            if(type == IJSVGNodeTypeUse) {
+                remove = [(IJSVGGroup*)childNode childrenMatchTraits:childTraits] == NO;
+            }
+            if(remove == YES) {
+                [self removeChild:childNode];
+            }
+        }
+    }
+}
+
+- (IJSVGWindingRule)computedClipRule
+{
+    // find the first use of a clipRule that is useful
+    __block IJSVGWindingRule rule = IJSVGWindingRuleInherit;
+    __weak IJSVGClipPath* weakSelf = self;
+    IJSVGNodeWalkHandler handler = ^(IJSVGNode *node, BOOL *allowChildNodes,
+                                     BOOL *stop) {
+        if(node == weakSelf) {
+            return;
+        }
+        IJSVGWindingRule clipRule = node.clipRule;
+        if(clipRule != IJSVGWindingRuleInherit) {
+            rule = clipRule;
+            *stop = YES;
+        }
+    };
+    [IJSVGNode walkNodeTree:self
+                    handler:handler];
+    return rule;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGColorNode.h

@@ -0,0 +1,22 @@
+//
+//  IJSVGColorNode.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/03/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGNode.h>
+
+@interface IJSVGColorNode : IJSVGNode {
+    
+}
+
+@property (nonatomic, strong) NSColor* color;
+@property (nonatomic, assign) BOOL isNoneOrTransparent;
+
++ (IJSVGNode*)colorNodeWithColor:(NSColor*)color;
+
+- (id)initWithColor:(NSColor*)color;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGColorNode.m

@@ -0,0 +1,33 @@
+//
+//  IJSVGColorNode.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 29/03/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGColorNode.h>
+
+@implementation IJSVGColorNode
+
++ (IJSVGNode*)colorNodeWithColor:(NSColor *)color
+{
+    return [[self alloc] initWithColor:color];
+}
+
+- (id)initWithColor:(NSColor*)color {
+    if((self = [super init]) != nil) {
+        [self addTraits:IJSVGNodeTraitPaintable];
+        self.color = color;
+    }
+    return self;
+}
+
+- (void)applyPropertiesFromNode:(IJSVGNode*)node
+{
+    if([node isKindOfClass:self.class]) {
+        self.color = ((IJSVGColorNode*)node).color;
+    }
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGFilter.h

@@ -0,0 +1,19 @@
+//
+//  IJSVGFilter.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroup.h>
+#import <IJSVG/IJSVGLayer.h>
+
+@interface IJSVGFilter : IJSVGGroup
+
+- (CGImageRef)newImageByApplyFilterToLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                                     scale:(CGFloat)scale;
+
+@property (nonatomic, readonly) BOOL valid;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGFilter.m

@@ -0,0 +1,57 @@
+//
+//  IJSVGFilter.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGFilter.h>
+#import <IJSVG/IJSVGFilterEffect.h>
+#import <IJSVG/IJSVGLayer.h>
+#import <IJSVG/IJSVGThreadManager.h>
+
+@implementation IJSVGFilter
+
+- (BOOL)valid
+{
+    return self.children.count != 0;
+}
+
+- (CGImageRef)newImageByApplyFilterToLayer:(CALayer<IJSVGDrawableLayer>*)layer
+                                     scale:(CGFloat)scale
+{
+    IJSVGFilter* filter = layer.filter;
+    layer.filter = nil;
+    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB();
+    uint32_t info = kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Little;
+    CGImageRef originalImage = [IJSVGLayer newImageForLayer:layer
+                                                    options:IJSVGLayerDrawingOptionNone
+                                                 colorSpace:colorSpace
+                                                 bitmapInfo:info
+                                                      scale:scale];
+    CIImage* image = [CIImage imageWithCGImage:originalImage];
+    CGColorSpaceRelease(colorSpace);
+    CGImageRelease(originalImage);
+    
+    for(IJSVGFilterEffect* effect in self.children) {
+        image = [effect processImage:image];
+    }
+    
+    IJSVGThreadManager* manager = IJSVGThreadManager.currentManager;
+    CIContext* context = manager.CIContext;
+    CGImageRef outputImage = [context createCGImage:image
+                                           fromRect:image.extent];
+    layer.filter = filter;
+    return outputImage;
+}
+
+- (void)addChild:(IJSVGNode*)child
+{
+    if([child isKindOfClass:IJSVGFilterEffect.class] == NO) {
+        return;
+    }
+    [super addChild:child];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGFilterEffect.h

@@ -0,0 +1,40 @@
+//
+//  IJSVGFilterEffect.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroup.h>
+
+typedef NS_ENUM(NSInteger, IJSVGFilterEffectSource) {
+    IJSVGFilterEffectSourceGraphic,
+    IJSVGFilterEffectSourceAlpha,
+    IJSVGFilterEffectSourceBackgroundImage,
+    IJSVGFilterEffectSourceBackgroundAlpha,
+    IJSVGFilterEffectSourceFillPaint,
+    IJSVGFilterEffectSourceStrokePaint,
+    IJSVGFilterEffectSourcePrimitiveReference,
+};
+
+typedef NS_ENUM(NSInteger, IJSVGFilterEffectEdgeMode) {
+    IJSVGFilterEffectEdgeModeNone,
+    IJSVGFilterEffectEdgeModeWrap,
+    IJSVGFilterEffectEdgeModeDuplicate,
+};
+
+@interface IJSVGFilterEffect : IJSVGGroup
+
+@property (nonatomic, assign) IJSVGFilterEffectSource source;
+@property (nonatomic, strong) IJSVGUnitLength* stdDeviation;
+@property (nonatomic, assign) IJSVGFilterEffectEdgeMode edgeMode;
+@property (nonatomic, copy) NSString* primitiveReference;
+
++ (Class)effectClassForElementName:(NSString*)name;
++ (IJSVGFilterEffectSource)sourceForString:(NSString*)string;
++ (IJSVGFilterEffectEdgeMode)edgeModeForString:(NSString*)string;
+
+- (CIImage*)processImage:(CIImage*)image;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGFilterEffect.m

@@ -0,0 +1,80 @@
+//
+//  IJSVGFilterEffect.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 18/04/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGFilterEffect.h>
+#import <IJSVG/IJSVGFilterEffectGaussianBlur.h>
+#import <IJSVG/IJSVGUtils.h>
+
+@implementation IJSVGFilterEffect
+
+static NSDictionary<NSString*, Class>* _elementClassMap = nil;
+
++ (void)load
+{
+    _elementClassMap = @{
+        @"fegaussianblur": IJSVGFilterEffectGaussianBlur.class
+    };
+}
+
++ (Class)effectClassForElementName:(NSString*)name
+{
+    NSString* key = name.lowercaseString;
+    return _elementClassMap[key] ?: IJSVGFilterEffect.class;
+}
+
++ (IJSVGFilterEffectSource)sourceForString:(NSString*)string
+{
+    const char* name = string.UTF8String;
+    if(name == NULL) {
+        return IJSVGFilterEffectSourceGraphic;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "sourcegraphic") == YES) {
+        return IJSVGFilterEffectSourceGraphic;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "sourcealpha") == YES) {
+        return IJSVGFilterEffectSourceAlpha;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "backgroundimage") == YES) {
+        return IJSVGFilterEffectSourceBackgroundImage;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "backgroundalpha") == YES) {
+        return IJSVGFilterEffectSourceBackgroundAlpha;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "fillpaint") == YES) {
+        return IJSVGFilterEffectSourceFillPaint;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(name, "strokepain") == YES) {
+        return IJSVGFilterEffectSourceStrokePaint;
+    }
+    return IJSVGFilterEffectSourcePrimitiveReference;
+}
+
++ (IJSVGFilterEffectEdgeMode)edgeModeForString:(NSString*)string
+{
+    const char* name = string.lowercaseString.UTF8String;
+    if(name == NULL) {
+        return IJSVGFilterEffectEdgeModeNone;
+    }
+    if(IJSVGCharBufferCompare(name, "none") == YES) {
+        return IJSVGFilterEffectEdgeModeNone;
+    }
+    if(IJSVGCharBufferCompare(name, "wrap") == YES) {
+        return IJSVGFilterEffectEdgeModeWrap;
+    }
+    if(IJSVGCharBufferCompare(name, "duplicate") == YES) {
+        return IJSVGFilterEffectEdgeModeDuplicate;
+    }
+    return IJSVGFilterEffectEdgeModeNone;
+}
+
+- (CIImage*)processImage:(CIImage*)image
+{
+    return image;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGForeignObject.h

@@ -7,14 +7,11 @@
 //
 
 #import <Foundation/Foundation.h>
-#import "IJSVGNode.h"
+#import <IJSVG/IJSVGNode.h>
 
 @interface IJSVGForeignObject : IJSVGNode {
-
-    NSString * requiredExtension;
-    
 }
 
-@property ( nonatomic, copy ) NSString * requiredExtension;
+@property (nonatomic, copy) NSString* requiredExtension;
 
 @end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGForeignObject.m

@@ -6,16 +6,8 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGForeignObject.h"
+#import <IJSVG/IJSVGForeignObject.h>
 
 @implementation IJSVGForeignObject
 
-@synthesize requiredExtension;
-
-- (void)dealloc
-{
-    (void)([requiredExtension release]), requiredExtension = nil;
-    [super dealloc];
-}
-
 @end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGGradient.h

@@ -0,0 +1,33 @@
+//
+//  IJSVGGradient.h
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 03/09/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <IJSVG/IJSVGTraitedColorStorage.h>
+#import <IJSVG/IJSVGTransform.h>
+#import <IJSVG/IJSVGGroup.h>
+
+@interface IJSVGGradient : IJSVGGroup
+
+@property (nonatomic, strong) NSArray<NSColor*>* colors;
+@property (nonatomic, assign) CGFloat* locations;
+@property (nonatomic, assign) NSUInteger numberOfStops;
+@property (nonatomic, assign) CGGradientRef CGGradient;
+@property (nonatomic, strong) IJSVGUnitLength* x1;
+@property (nonatomic, strong) IJSVGUnitLength* x2;
+@property (nonatomic, strong) IJSVGUnitLength* y1;
+@property (nonatomic, strong) IJSVGUnitLength* y2;
+
++ (CGFloat*)computeColorStops:(IJSVGGradient*)gradient
+                       colors:(NSArray**)someColors;
+
+- (CGGradientRef)CGGradient;
+- (void)drawInContextRef:(CGContextRef)ctx
+                  bounds:(NSRect)objectRect
+               transform:(CGAffineTransform)absoluteTransform;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGGradient.m

@@ -0,0 +1,114 @@
+//
+//  IJSVGGradient.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 03/09/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGradient.h>
+#import <IJSVG/IJSVGParser.h>
+
+@implementation IJSVGGradient
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage setBit:IJSVGNodeAttributeGradientUnits];
+    [storage setBit:IJSVGNodeAttributeGradientTransform];
+    return storage;
+}
+
+- (void)dealloc
+{
+    if(_locations != NULL) {
+        (void)free(_locations), _locations = NULL;
+    }
+    if(_CGGradient != NULL) {
+        (void)CGGradientRelease(_CGGradient), _CGGradient = NULL;
+    }
+}
+
+- (id)copyWithZone:(NSZone*)zone
+{
+    IJSVGGradient* clone = [[self.class alloc] init];
+    [clone applyPropertiesFromNode:self];
+    return clone;
+}
+
+- (void)applyPropertiesFromNode:(IJSVGGradient*)node
+{
+    [super applyPropertiesFromNode:node];
+    self.numberOfStops = node.numberOfStops;
+    self.colors = node.colors.copy;
+    size_t length = sizeof(CGFloat)*node.numberOfStops;
+    self.locations = (CGFloat*)malloc(length);
+    memcpy(self.locations, node.locations, length);
+    self.x1 = node.x1.copy;
+    self.x2 = node.x2.copy;
+    self.y1 = node.y1.copy;
+    self.y2 = node.y2.copy;
+}
+
+- (void)setLocations:(CGFloat*)locations
+{
+    if(_locations != NULL) {
+        (void)free(_locations), _locations = NULL;
+    }
+    _locations = locations;
+}
+
++ (CGFloat*)computeColorStops:(IJSVGGradient*)gradient
+                       colors:(NSArray**)someColors
+{
+    NSArray<IJSVGNode*>* stops = gradient.children;
+    NSMutableArray* colors = [[NSMutableArray alloc] initWithCapacity:stops.count];
+    CGFloat* stopsParams = (CGFloat*)malloc(stops.count * sizeof(CGFloat));
+    
+    NSInteger i = 0;
+    for(IJSVGNode* stopNode in stops) {
+        NSColor* color = ((IJSVGColorNode*)(stopNode.fill)).color;
+        CGFloat opacity = stopNode.fillOpacity.value;
+        CGFloat offset = stopNode.offset.value;
+        stopsParams[i++] = offset;
+        if(color == nil) {
+            color = [IJSVGColor colorFromHEXInteger:0x000000];
+            if(opacity != 1.f) {
+                color = [IJSVGColor changeAlphaOnColor:color
+                                                    to:opacity];
+            }
+        }
+        [colors addObject:color];
+    }
+    *someColors = (NSArray*)colors;
+    return stopsParams;
+}
+
+- (CGGradientRef)CGGradient
+{
+    // store it in the cache
+    if(_CGGradient != nil) {
+        return _CGGradient;
+    }
+
+    // actually create the gradient
+    NSInteger num = self.numberOfStops;
+    CFMutableArrayRef colors = CFArrayCreateMutable(kCFAllocatorDefault, (CFIndex)num,
+        &kCFTypeArrayCallBacks);
+    for (NSColor* color in _colors) {
+        CFArrayAppendValue(colors, color.CGColor);
+    }
+    CGGradientRef result = CGGradientCreateWithColors(IJSVGColor.defaultColorSpace.CGColorSpace,
+        colors, _locations);
+    CFRelease(colors);
+    return _CGGradient = result;
+}
+
+- (void)drawInContextRef:(CGContextRef)ctx
+                  bounds:(NSRect)objectRect
+               transform:(CGAffineTransform)absoluteTransform
+{
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGGroup.h

@@ -0,0 +1,30 @@
+//
+//  IJSVGGroup.h
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGNode.h>
+#import <IJSVG/IJSVGPath.h>
+#import <Foundation/Foundation.h>
+
+@interface IJSVGGroup : IJSVGNode {
+
+@private
+    NSMutableArray<IJSVGNode*>* _children;
+}
+
+@property (weak, nonatomic, readonly) NSArray<IJSVGNode*>* children;
+
+- (void)addChild:(IJSVGNode*)child;
+- (void)addChildren:(NSArray<IJSVGNode*>*)children;
+- (void)removeChild:(IJSVGNode*)child;
+- (void)removeChildren:(NSArray<IJSVGNode*>*)children;
+- (BOOL)childrenMatchTraits:(IJSVGNodeTraits)traits;
+- (BOOL)containsNodesMatchingTraits:(IJSVGNodeTraits)traits;
+- (NSArray<IJSVGNode*>*)nodesMatchingTraits:(IJSVGNodeTraits)traits;
+- (NSSet<IJSVGNode*>*)childrenOfType:(IJSVGNodeType)type;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGGroup.m

@@ -0,0 +1,138 @@
+//
+//  IJSVGGroup.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroup.h>
+#import <IJSVG/IJSVGImage.h>
+
+@implementation IJSVGGroup
+
+- (id)init
+{
+    if((self = [super init]) != nil) {
+        _children = [[NSMutableArray alloc] init];
+    }
+    return self;
+}
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage addBits:[IJSVGPath allowedAttributes]];
+    [storage addBits:[IJSVGImage allowedAttributes]];
+    return storage;
+}
+
+- (void)prepareFromCopy
+{
+    _children = [[NSMutableArray alloc] init];
+}
+
+- (id)copyWithZone:(NSZone*)zone
+{
+    IJSVGGroup* node = [super copyWithZone:zone];
+    [node prepareFromCopy];
+
+    for (__strong IJSVGNode* childNode in _children) {
+        childNode = childNode.copy;
+        childNode.parentNode = node;
+        [node addChild:childNode];
+    }
+    return node;
+}
+
+- (void)addChild:(IJSVGNode*)child
+{
+    if(child == nil || child == self ||
+       (child.parentNode == self && [_children containsObject:child])) {
+        return;
+    }
+    child.parentNode = self;
+    [_children addObject:child];
+}
+
+- (void)removeChild:(IJSVGNode*)child
+{
+    if(child.parentNode == self) {
+        [child detach];
+    }
+    [_children removeObject:child];
+}
+
+- (void)addChildren:(NSArray<IJSVGNode*>*)children
+{
+    for(IJSVGNode* node in children) {
+        [self addChild:node];
+    }
+}
+
+- (void)removeChildren:(NSArray<IJSVGNode*>*)children
+{
+    for(IJSVGNode* node in children) {
+        [self removeChild:node];
+    }
+}
+
+- (BOOL)childrenMatchTraits:(IJSVGNodeTraits)traits
+{
+    for(IJSVGNode* node in _children) {
+        if([node matchesTraits:traits] == NO) {
+            return NO;
+        }
+    }
+    return YES;
+}
+
+- (NSSet<IJSVGNode*>*)childrenOfType:(IJSVGNodeType)type
+{
+    NSMutableSet<IJSVGNode*>* nodes = [[NSMutableSet alloc] init];
+    for(IJSVGNode* node in self.children) {
+        if(node.type == type) {
+            [nodes addObject:node];
+        }
+    }
+    return nodes;
+}
+
+- (BOOL)containsNodesMatchingTraits:(IJSVGNodeTraits)traits
+{
+    return [self.class node:self
+containsNodesMatchingTraits:traits];
+}
+
+- (NSArray<IJSVGNode*>*)nodesMatchingTraits:(IJSVGNodeTraits)traits
+{
+    return [self.class node:self
+        nodesMatchingTraits:traits];
+}
+
+- (CGRect)bounds
+{
+    CGRect rect = CGRectNull;
+    for(IJSVGNode* node in self.children) {
+        if(CGRectIsNull(rect)) {
+            rect = node.bounds;
+        } else {
+            rect = CGRectUnion(rect, node.bounds);
+        }
+    }
+    return rect;
+}
+
+- (NSArray<IJSVGNode*>*)children
+{
+    return _children;
+}
+
+- (NSString*)description
+{
+    return [NSString stringWithFormat:@"%@ - %@",
+            [super description], self.children];
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGImage.h

@@ -6,21 +6,21 @@
 //  Copyright © 2016 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGNode.h"
+#import <IJSVG/IJSVGNode.h>
 #import <Foundation/Foundation.h>
 
 @class IJSVGPath;
 
 @interface IJSVGImage : IJSVGNode {
-
-    NSImage* image;
     CGImageRef CGImage;
-    IJSVGPath* imagePath;
 }
 
+@property (nonatomic, readonly) CGSize intrinsicSize;
+@property (nonatomic, readonly) CGRect intrinsicBounds;
+@property (nonatomic, strong) NSImage* image;
+
 - (CGImageRef)CGImage;
-- (void)drawInContextRef:(CGContextRef)context
-                    path:(IJSVGPath*)path;
-- (void)loadFromBase64EncodedString:(NSString*)encodedString;
+- (void)loadFromString:(NSString*)encodedString;
+- (void)loadFromURL:(NSURL*)aURL;
 
 @end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGImage.m

@@ -0,0 +1,107 @@
+//
+//  IJSVGImage.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 28/05/2016.
+//  Copyright © 2016 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGImage.h>
+#import <IJSVG/IJSVGPath.h>
+#import <IJSVG/IJSVGTransform.h>
+
+@implementation IJSVGImage
+
+- (void)dealloc
+{
+    (void)(CGImageRelease(CGImage)), CGImage = nil;
+}
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage setBit:IJSVGNodeAttributeX];
+    [storage setBit:IJSVGNodeAttributeY];
+    [storage setBit:IJSVGNodeAttributeWidth];
+    [storage setBit:IJSVGNodeAttributeHeight];
+    [storage setBit:IJSVGNodeAttributePreserveAspectRatio];
+    return storage;
+}
+
+- (void)setDefaults
+{
+    [super setDefaults];
+    self.viewBoxAlignment = IJSVGViewBoxAlignmentXMidYMid;
+    self.viewBoxMeetOrSlice = IJSVGViewBoxMeetOrSliceMeet;
+}
+
+- (void)loadFromString:(NSString*)encodedString
+{
+    if([encodedString hasPrefix:@"data:"]) {
+        encodedString = [encodedString stringByReplacingOccurrencesOfString:@"\\s+"
+                                                                 withString:@""
+                                                                    options:NSRegularExpressionSearch
+                                                                      range:NSMakeRange(0, encodedString.length)];
+    }
+    NSURL* url = [NSURL URLWithString:encodedString];
+    if(url != nil) {
+        [self loadFromURL:url];
+    }
+}
+
+- (void)loadFromURL:(NSURL*)aURL
+{
+    NSData* data = [NSData dataWithContentsOfURL:aURL];
+
+    // no data, just ignore...invalid probably
+    if(data == nil) {
+        return;
+    }
+
+    // set the image against the container
+    NSImage* anImage = [[NSImage alloc] initWithData:data];
+    [self setImage:anImage];
+}
+
+- (void)setImage:(NSImage*)anImage
+{
+    _image = anImage;
+    _intrinsicSize = (CGSize)_image.size;
+
+    if(CGImage != nil) {
+        CGImageRelease(CGImage);
+        CGImage = nil;
+    }
+
+    CGRect rect = CGRectMake(0.f, 0.f,
+                             _intrinsicSize.width,
+                             _intrinsicSize.height);
+    CGImage = [_image CGImageForProposedRect:&rect
+                                     context:nil
+                                       hints:nil];
+
+    CGImageRetain(CGImage);
+}
+
+- (CGImageRef)CGImage
+{
+    return CGImage;
+}
+
+- (CGRect)intrinsicBounds
+{
+    CGRect rect = CGRectZero;
+    rect.size.width = _intrinsicSize.width;
+    rect.size.height = _intrinsicSize.height;
+    return rect;
+}
+
+- (CGRect)bounds
+{
+    return CGRectMake(0.f, 0.f,
+                      self.width.value,
+                      self.height.value);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGLinearGradient.h

@@ -6,12 +6,12 @@
 //  Copyright (c) 2014 Curtis Hard. All rights reserved.
 //
 
-#import "IJSVGGradient.h"
+#import <IJSVG/IJSVGGradient.h>
 #import <Foundation/Foundation.h>
 
 @interface IJSVGLinearGradient : IJSVGGradient
 
-+ (NSGradient*)parseGradient:(NSXMLElement*)element
-                    gradient:(IJSVGLinearGradient*)aGradient;
++ (void)parseGradient:(NSXMLElement*)element
+             gradient:(IJSVGLinearGradient*)aGradient;
 
 @end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGLinearGradient.m

@@ -0,0 +1,87 @@
+//
+//  IJSVGGradient.m
+//  IJSVGExample
+//
+//  Created by Curtis Hard on 03/09/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGLinearGradient.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <IJSVG/IJSVGParser.h>
+
+@implementation IJSVGLinearGradient
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage setBit:IJSVGNodeAttributeX1];
+    [storage setBit:IJSVGNodeAttributeX2];
+    [storage setBit:IJSVGNodeAttributeY1];
+    [storage setBit:IJSVGNodeAttributeY2];
+    return storage;
+}
+
++ (void)parseGradient:(NSXMLElement*)element
+             gradient:(IJSVGLinearGradient*)aGradient
+{
+    // just ask unit for the value
+    NSString* x1 = ([element attributeForName:IJSVGAttributeX1].stringValue ?: @"0");
+    NSString* x2 = ([element attributeForName:IJSVGAttributeX2].stringValue ?: @"100%");
+    NSString* y1 = ([element attributeForName:IJSVGAttributeY1].stringValue ?: @"0");
+    NSString* y2 = ([element attributeForName:IJSVGAttributeY2].stringValue ?: @"0");
+    aGradient.x1 = [IJSVGGradientUnitLength unitWithString:x1 fromUnitType:aGradient.units];
+    aGradient.x2 = [IJSVGGradientUnitLength unitWithString:x2 fromUnitType:aGradient.units];
+    aGradient.y1 = [IJSVGGradientUnitLength unitWithString:y1 fromUnitType:aGradient.units];
+    aGradient.y2 = [IJSVGGradientUnitLength unitWithString:y2 fromUnitType:aGradient.units];
+    
+    // compute the color stops and colours
+    NSArray* colors = nil;
+    CGFloat* stopsParams = [self.class computeColorStops:aGradient
+                                                  colors:&colors];
+    aGradient.colors = colors;
+    aGradient.locations = stopsParams;
+    aGradient.numberOfStops = colors.count;
+}
+
+- (void)drawInContextRef:(CGContextRef)ctx
+                  bounds:(NSRect)objectRect
+               transform:(CGAffineTransform)absoluteTransform
+{
+    BOOL inUserSpace = self.units == IJSVGUnitUserSpaceOnUse;
+
+    CGPoint gradientStartPoint = CGPointZero;
+    CGPoint gradientEndPoint = CGPointZero;
+    CGRect boundingBox = objectRect;
+    
+    // make sure we apply the absolute position to
+    // transform us back into the correct space
+    CGFloat width = CGRectGetWidth(boundingBox);
+    CGFloat height = CGRectGetHeight(boundingBox);
+    
+    if(inUserSpace == YES) {
+        CGContextConcatCTM(ctx, absoluteTransform);
+    } else {
+        width = 1.f;
+        height = 1.f;
+        CGContextConcatCTM(ctx, CGAffineTransformMakeScale(boundingBox.size.width,
+                                                           boundingBox.size.height));
+    }
+    
+    gradientStartPoint = CGPointMake([self.x1 computeValue:width],
+                                     [self.y1 computeValue:height]);
+    gradientEndPoint = CGPointMake([self.x2 computeValue:width],
+                                     [self.y2 computeValue:height]);
+    
+    // concat the gradient transform into the context
+    IJSVGConcatTransformsCTM(ctx, self.transforms);
+    
+    // draw the gradient
+    CGGradientDrawingOptions options = kCGGradientDrawsBeforeStartLocation | kCGGradientDrawsAfterEndLocation;
+
+    CGContextDrawLinearGradient(ctx, self.CGGradient, gradientStartPoint,
+        gradientEndPoint, options);
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGMask.h

@@ -0,0 +1,13 @@
+//
+//  IJSVGMask.h
+//  IJSVG
+//
+//  Created by Curtis Hard on 28/05/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGGroup.h>
+
+@interface IJSVGMask : IJSVGGroup
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGMask.m

@@ -0,0 +1,51 @@
+//
+//  IJSVGMask.m
+//  IJSVG
+//
+//  Created by Curtis Hard on 28/05/2022.
+//  Copyright © 2022 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGMask.h>
+#import <IJSVG/IJSVGRootNode.h>
+
+@implementation IJSVGMask
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage addBits:[super allowedAttributes]];
+    [storage setBit:IJSVGNodeAttributeX];
+    [storage setBit:IJSVGNodeAttributeY];
+    [storage setBit:IJSVGNodeAttributeWidth];
+    [storage setBit:IJSVGNodeAttributeHeight];
+    [storage setBit:IJSVGNodeAttributeMaskUnits];
+    [storage setBit:IJSVGNodeAttributeMaskContentUnits];
+    return storage;
+}
+
+- (void)setDefaults
+{
+    [super setDefaults];
+    self.x = [IJSVGUnitLength unitWithPercentageFloat:-.2f];
+    self.y = [IJSVGUnitLength unitWithPercentageFloat:-.2f];
+    self.width = [IJSVGUnitLength unitWithPercentageFloat:1.2f];
+    self.height = [IJSVGUnitLength unitWithPercentageFloat:1.2f];
+    self.units = IJSVGUnitObjectBoundingBox;
+    self.contentUnits = IJSVGUnitUserSpaceOnUse;
+    self.overflowVisibility = IJSVGOverflowVisibilityHidden;
+}
+
+- (IJSVGUnitType)contentUnitsWithReferencingNodeBounds:(CGRect *)bounds
+{
+    IJSVGNode* node = nil;
+    IJSVGUnitType units = [self contentUnitsWithReferencingNode:&node];
+    if(units == IJSVGUnitUserSpaceOnUse) {
+        *bounds = node.rootNode.bounds;
+    } else {
+        *bounds = node.parentNode.bounds;
+    }
+    return units;
+}
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGNode.h

@@ -0,0 +1,293 @@
+//
+//  IJSVGNode.h
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGStyleSheetStyle.h>
+#import <IJSVG/IJSVGUnitLength.h>
+#import <IJSVG/IJSVGViewBox.h>
+#import <IJSVG/IJSVGBitFlags64.h>
+#import <AppKit/AppKit.h>
+#import <Foundation/Foundation.h>
+
+@class IJSVGNode;
+@class IJSVG;
+@class IJSVGGroup;
+@class IJSVGGradient;
+@class IJSVGGroup;
+@class IJSVGPattern;
+@class IJSVGTransform;
+@class IJSVGRootNode;
+@class IJSVGUnitRect;
+@class IJSVGFilter;
+@class IJSVGMask;
+@class IJSVGClipPath;
+@class IJSVGThreadManager;
+
+typedef void (^IJSVGNodeWalkHandler)(IJSVGNode* node, BOOL* allowChildNodes, BOOL* stop);
+
+typedef NS_ENUM(NSInteger, IJSVGNodeAttribute) {
+    IJSVGNodeAttributeVersion,
+    IJSVGNodeAttributeXMLNS,
+    IJSVGNodeAttributeXMLNSXlink,
+    IJSVGNodeAttributeViewBox,
+    IJSVGNodeAttributePreserveAspectRatio,
+    IJSVGNodeAttributeID,
+    IJSVGNodeAttributeClass,
+    IJSVGNodeAttributeX,
+    IJSVGNodeAttributeY,
+    IJSVGNodeAttributeWidth,
+    IJSVGNodeAttributeHeight,
+    IJSVGNodeAttributeOpacity,
+    IJSVGNodeAttributeStrokeOpacity,
+    IJSVGNodeAttributeStrokeWidth,
+    IJSVGNodeAttributeStrokeDashOffset,
+    IJSVGNodeAttributeFillOpacity,
+    IJSVGNodeAttributeClipPath,
+    IJSVGNodeAttributeClipPathUnits,
+    IJSVGNodeAttributeClipRule,
+    IJSVGNodeAttributeMask,
+    IJSVGNodeAttributeGradientUnits,
+    IJSVGNodeAttributePatternUnits,
+    IJSVGNodeAttributePatternContentUnits,
+    IJSVGNodeAttributePatternTransform,
+    IJSVGNodeAttributeMaskUnits,
+    IJSVGNodeAttributeMaskContentUnits,
+    IJSVGNodeAttributeTransform,
+    IJSVGNodeAttributeGradientTransform,
+    IJSVGNodeAttributeUnicode,
+    IJSVGNodeAttributeStrokeLineCap,
+    IJSVGNodeAttributeStrokeLineJoin,
+    IJSVGNodeAttributeStroke,
+    IJSVGNodeAttributeStrokeDashArray,
+    IJSVGNodeAttributeStrokeMiterLimit,
+    IJSVGNodeAttributeFill,
+    IJSVGNodeAttributeFillRule,
+    IJSVGNodeAttributeBlendMode,
+    IJSVGNodeAttributeDisplay,
+    IJSVGNodeAttributeStyle,
+    IJSVGNodeAttributeD,
+    IJSVGNodeAttributeXLink,
+    IJSVGNodeAttributeX1,
+    IJSVGNodeAttributeX2,
+    IJSVGNodeAttributeY1,
+    IJSVGNodeAttributeY2,
+    IJSVGNodeAttributeRX,
+    IJSVGNodeAttributeRY,
+    IJSVGNodeAttributeCX,
+    IJSVGNodeAttributeCY,
+    IJSVGNodeAttributeR,
+    IJSVGNodeAttributeFX,
+    IJSVGNodeAttributeFY,
+    IJSVGNodeAttributeFR,
+    IJSVGNodeAttributePoints,
+    IJSVGNodeAttributeOffset,
+    IJSVGNodeAttributeStopColor,
+    IJSVGNodeAttributeStopOpacity,
+    IJSVGNodeAttributeHref,
+    IJSVGNodeAttributeOverflow,
+    IJSVGNodeAttributeFilter,
+    IJSVGNodeAttributeStdDeviation,
+    IJSVGNodeAttributeIn,
+    IJSVGNodeAttributeEdgeMode,
+    IJSVGNodeAttributeMarker
+};
+
+static const int kIJSVGNodeAttributeStorageLength = 64;
+
+typedef NS_OPTIONS(NSInteger, IJSVGIntrinsicDimensions) {
+    IJSVGIntrinsicDimensionNone = 0,
+    IJSVGIntrinsicDimensionWidth = 1 << 1,
+    IJSVGIntrinsicDimensionHeight = 1 << 2,
+    IJSVGIntrinsicDimensionBoth = IJSVGIntrinsicDimensionWidth | IJSVGIntrinsicDimensionHeight
+};
+
+typedef NS_OPTIONS(NSInteger, IJSVGNodeTraits) {
+    IJSVGNodeTraitNone = 0,
+    IJSVGNodeTraitStroked = 1 << 0,
+    IJSVGNodeTraitPaintable = 1 << 1,
+    IJSVGNodeTraitPathed = 1 << 2
+};
+
+typedef NS_ENUM(NSInteger, IJSVGNodeType) {
+    IJSVGNodeTypeUnknown = 0,
+    IJSVGNodeTypeGroup,
+    IJSVGNodeTypePath,
+    IJSVGNodeTypeDef,
+    IJSVGNodeTypePolygon,
+    IJSVGNodeTypePolyline,
+    IJSVGNodeTypeRect,
+    IJSVGNodeTypeLine,
+    IJSVGNodeTypeCircle,
+    IJSVGNodeTypeEllipse,
+    IJSVGNodeTypeUse,
+    IJSVGNodeTypeLinearGradient,
+    IJSVGNodeTypeRadialGradient,
+    IJSVGNodeTypeClipPath,
+    IJSVGNodeTypeFont,
+    IJSVGNodeTypeGlyph,
+    IJSVGNodeTypeMask,
+    IJSVGNodeTypeImage,
+    IJSVGNodeTypePattern,
+    IJSVGNodeTypeSVG,
+    IJSVGNodeTypeText,
+    IJSVGNodeTypeTextSpan,
+    IJSVGNodeTypeStyle,
+    IJSVGNodeTypeSwitch,
+    IJSVGNodeTypeTitle,
+    IJSVGNodeTypeDesc,
+    IJSVGNodeTypeStop,
+    IJSVGNodeTypeNotFound,
+    IJSVGNodeTypeFilter,
+    IJSVGNodeTypeFilterEffect,
+    IJSVGNodeTypeForeignObject
+};
+
+typedef NS_ENUM(NSInteger, IJSVGWindingRule) {
+    IJSVGWindingRuleNonZero,
+    IJSVGWindingRuleEvenOdd,
+    IJSVGWindingRuleInherit
+};
+
+typedef NS_ENUM(NSInteger, IJSVGLineCapStyle) {
+    IJSVGLineCapStyleNone,
+    IJSVGLineCapStyleButt,
+    IJSVGLineCapStyleRound,
+    IJSVGLineCapStyleSquare,
+    IJSVGLineCapStyleInherit
+};
+
+typedef NS_ENUM(NSInteger, IJSVGLineJoinStyle) {
+    IJSVGLineJoinStyleNone,
+    IJSVGLineJoinStyleMiter,
+    IJSVGLineJoinStyleRound,
+    IJSVGLineJoinStyleBevel,
+    IJSVGLineJoinStyleInherit
+};
+
+typedef NS_OPTIONS(NSInteger, IJSVGFontTraits) {
+    IJSVGFontTraitNone = 1 << 0,
+    IJSVGFontTraitBold = 1 << 1,
+    IJSVGFontTraitItalic = 1 << 2
+};
+
+typedef NS_ENUM(NSInteger, IJSVGBlendMode) {
+    IJSVGBlendModeNormal = kCGBlendModeNormal,
+    IJSVGBlendModeMultiply = kCGBlendModeMultiply,
+    IJSVGBlendModeScreen = kCGBlendModeScreen,
+    IJSVGBlendModeOverlay = kCGBlendModeOverlay,
+    IJSVGBlendModeDarken = kCGBlendModeDarken,
+    IJSVGBlendModeLighten = kCGBlendModeLighten,
+    IJSVGBlendModeColorDodge = kCGBlendModeColorDodge,
+    IJSVGBlendModeColorBurn = kCGBlendModeColorBurn,
+    IJSVGBlendModeHardLight = kCGBlendModeHardLight,
+    IJSVGBlendModeSoftLight = kCGBlendModeSoftLight,
+    IJSVGBlendModeDifference = kCGBlendModeDifference,
+    IJSVGBlendModeExclusion = kCGBlendModeExclusion,
+    IJSVGBlendModeHue = kCGBlendModeHue,
+    IJSVGBlendModeSaturation = kCGBlendModeSaturation,
+    IJSVGBlendModeColor = kCGBlendModeColor,
+    IJSVGBlendModeLuminosity = kCGBlendModeLuminosity
+};
+
+typedef NS_ENUM(NSInteger, IJSVGOverflowVisibility) {
+    IJSVGOverflowVisibilityHidden,
+    IJSVGOverflowVisibilityVisible
+};
+
+static CGFloat IJSVGInheritedFloatValue = -99.9999991;
+static CGFloat IJSVGInheritedIntegerValue = INT_MIN;
+
+@interface IJSVGNode : NSObject <NSCopying> {
+@private
+    BOOL _computedTraits;
+}
+
+void IJSVGAssertPaintableObject(id object);
+
+@property (nonatomic, assign) IJSVGNodeTraits traits;
+@property (nonatomic, assign, readonly) CGRect bounds;
+@property (nonatomic, strong) IJSVGUnitRect* viewBox;
+@property (nonatomic, assign) IJSVGViewBoxAlignment viewBoxAlignment;
+@property (nonatomic, assign) IJSVGViewBoxMeetOrSlice viewBoxMeetOrSlice;
+@property (nonatomic, copy) NSString* title;
+@property (nonatomic, copy) NSString* desc;
+@property (nonatomic, assign) IJSVGNodeType type;
+@property (nonatomic, copy) NSString* name;
+@property (nonatomic, copy) NSString* className;
+@property (nonatomic, strong) NSSet<NSString*>* classNameList;
+@property (nonatomic, copy) NSString* unicode;
+@property (nonatomic, assign) BOOL shouldRender;
+@property (nonatomic, strong) IJSVGUnitLength* x;
+@property (nonatomic, strong) IJSVGUnitLength* y;
+@property (nonatomic, strong) IJSVGUnitLength* width;
+@property (nonatomic, strong) IJSVGUnitLength* height;
+@property (nonatomic, strong) IJSVGUnitLength* opacity;
+@property (nonatomic, strong) IJSVGUnitLength* fillOpacity;
+@property (nonatomic, strong) IJSVGUnitLength* strokeOpacity;
+@property (nonatomic, strong) IJSVGUnitLength* strokeWidth;
+@property (nonatomic, strong) IJSVGUnitLength* offset;
+@property (nonatomic, strong) IJSVGNode* fill;
+@property (nonatomic, strong) IJSVGNode* stroke;
+@property (nonatomic, copy) NSString* identifier;
+@property (nonatomic, assign) IJSVGNode* parentNode;
+@property (nonatomic, strong) IJSVGClipPath* clipPath;
+@property (nonatomic, strong) IJSVGMask* mask;
+@property (nonatomic, assign) IJSVGWindingRule windingRule;
+@property (nonatomic, assign) IJSVGWindingRule clipRule;
+@property (nonatomic, assign) IJSVGLineCapStyle lineCapStyle;
+@property (nonatomic, assign) IJSVGLineJoinStyle lineJoinStyle;
+@property (nonatomic, strong) IJSVGUnitLength* strokeMiterLimit;
+@property (nonatomic, strong) NSArray<IJSVGTransform*>* transforms;
+@property (nonatomic, strong) IJSVGFilter* filter;
+@property (nonatomic, assign) CGFloat* strokeDashArray;
+@property (nonatomic, assign) NSInteger strokeDashArrayCount;
+@property (nonatomic, readonly) NSArray<NSNumber*>* lineDashPattern;
+@property (nonatomic, strong) IJSVGUnitLength* strokeDashOffset;
+@property (nonatomic, strong) IJSVG* svg;
+@property (nonatomic, assign) IJSVGUnitType contentUnits;
+@property (nonatomic, assign) IJSVGUnitType units;
+@property (nonatomic, assign) IJSVGBlendMode blendMode;
+@property (nonatomic, assign) IJSVGOverflowVisibility overflowVisibility;
+@property (nonatomic, readonly) BOOL detachedFromParentNode;
+@property (nonatomic, readonly) IJSVGRootNode* rootNode;
+
++ (IJSVGBitFlags*)computedAllowedAttributes;
++ (IJSVGBitFlags*)allowedAttributes;
+
++ (void)walkNodeTree:(IJSVGNode*)node
+             handler:(IJSVGNodeWalkHandler)handler;
+
++ (NSArray<IJSVGNode*>*)node:(IJSVGNode*)node
+         nodesMatchingTraits:(IJSVGNodeTraits)traits;
+
++ (BOOL)node:(IJSVGNode*)node
+containsNodesMatchingTraits:(IJSVGNodeTraits)traits;
+
++ (IJSVGNodeType)typeForString:(NSString*)string
+                          kind:(NSXMLNodeKind)kind;
++ (BOOL)typeIsPathable:(IJSVGNodeType)type;
+
+- (void)setDefaults;
+- (void)postProcess;
+- (void)applyPropertiesFromNode:(IJSVGNode*)node;
+
+- (IJSVGUnitType)contentUnitsWithReferencingNodeBounds:(CGRect*)bounds;
+- (IJSVGUnitType)contentUnitsWithReferencingNode:(IJSVGNode**)referencingNode;
+
+- (instancetype)detach;
+
+- (void)addTraits:(IJSVGNodeTraits)traits;
+- (void)removeTraits:(IJSVGNodeTraits)traits;
+- (BOOL)matchesTraits:(IJSVGNodeTraits)traits;
+- (void)computeTraits;
+
+- (NSSet<IJSVGNode*>*)nodesMatchingTypes:(NSIndexSet*)types;
+
+- (instancetype)parentNodeMatchingClass:(Class)someClass;
+- (instancetype)rootNodeMatchingClass:(Class)someClass;
+
+@end

Framework/IJSVG/IJSVG/Source/Nodes/IJSVGNode.m

@@ -0,0 +1,662 @@
+//
+//  IJSVGNode.m
+//  IconJar
+//
+//  Created by Curtis Hard on 30/08/2014.
+//  Copyright (c) 2014 Curtis Hard. All rights reserved.
+//
+
+#import <IJSVG/IJSVGNode.h>
+#import <IJSVG/IJSVGGroup.h>
+#import <IJSVG/IJSVGUtils.h>
+#import <IJSVG/IJSVGRootNode.h>
+#import <IJSVG/IJSVGThreadManager.h>
+
+@implementation IJSVGNode
+
+@synthesize fill = _fill;
+@synthesize stroke = _stroke;
+
+- (void)dealloc
+{
+    if(_strokeDashArray != NULL) {
+        (void)free(_strokeDashArray), _strokeDashArray = NULL;
+    }
+}
+
++ (IJSVGNodeType)typeForString:(NSString*)string
+                          kind:(NSXMLNodeKind)kind
+{
+    // if string is nil, or its not a generic element or some text span
+    if(string == nil || (kind != NSXMLElementKind && kind != NSXMLTextKind)) {
+        return IJSVGNodeTypeNotFound;
+    }
+    
+    const char* nodeType = string.UTF8String;
+    if(nodeType == NULL) {
+        return IJSVGNodeTypeNotFound;
+    }
+    
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "g") == YES) {
+        return IJSVGNodeTypeGroup;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "path") == YES) {
+        return IJSVGNodeTypePath;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "style") == YES) {
+        return IJSVGNodeTypeStyle;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "switch") == YES) {
+        return IJSVGNodeTypeSwitch;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "defs") == YES) {
+        return IJSVGNodeTypeDef;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "polygon") == YES) {
+        return IJSVGNodeTypePolygon;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "polyline") == YES) {
+        return IJSVGNodeTypePolyline;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "rect") == YES) {
+        return IJSVGNodeTypeRect;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "line") == YES) {
+        return IJSVGNodeTypeLine;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "circle") == YES) {
+        return IJSVGNodeTypeCircle;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "ellipse") == YES) {
+        return IJSVGNodeTypeEllipse;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "use") == YES) {
+        return IJSVGNodeTypeUse;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "lineargradient") == YES) {
+        return IJSVGNodeTypeLinearGradient;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "radialgradient") == YES) {
+        return IJSVGNodeTypeRadialGradient;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "stop") == YES) {
+        return IJSVGNodeTypeStop;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "glyph") == YES) {
+        return IJSVGNodeTypeGlyph;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "font") == YES) {
+        return IJSVGNodeTypeFont;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "clippath") == YES) {
+        return IJSVGNodeTypeClipPath;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "mask") == YES) {
+        return IJSVGNodeTypeMask;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "image") == YES) {
+        return IJSVGNodeTypeImage;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "pattern") == YES) {
+        return IJSVGNodeTypePattern;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "svg") == YES) {
+        return IJSVGNodeTypeSVG;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "text") == YES) {
+        return IJSVGNodeTypeText;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "tspan") == YES || kind == NSXMLTextKind) {
+        return IJSVGNodeTypeTextSpan;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "title") == YES) {
+        return IJSVGNodeTypeTitle;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "desc") == YES) {
+        return IJSVGNodeTypeDesc;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "foreignobject") == YES) {
+        return IJSVGNodeTypeForeignObject;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "filter") == YES) {
+        return IJSVGNodeTypeFilter;
+    }
+    if(IJSVGCharBufferCaseInsensitiveCompare(nodeType, "fegaussianblur") == YES) {
+        return IJSVGNodeTypeFilterEffect;
+    }
+    return IJSVGNodeTypeUnknown;
+}
+
++ (IJSVGBitFlags*)computedAllowedAttributes
+{
+    static NSMutableDictionary<Class, IJSVGBitFlags*>* computed = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        computed = [[NSMutableDictionary alloc] init];
+    });
+    
+    @synchronized (computed) {
+        IJSVGBitFlags* set = computed[self];
+        if(set == nil) {
+            set = [self allowedAttributes];
+            computed[(id<NSCopying>)self] = set;
+        }
+        return set;
+    }
+}
+
++ (IJSVGBitFlags*)allowedAttributes
+{
+    IJSVGBitFlags64* storage = [[IJSVGBitFlags64 alloc] init];
+    [storage setBit:IJSVGNodeAttributeStyle];
+    [storage setBit:IJSVGNodeAttributeClass];
+    [storage setBit:IJSVGNodeAttributeTransform];
+    [storage setBit:IJSVGNodeAttributeID];
+    [storage setBit:IJSVGNodeAttributeDisplay];
+    return storage;
+}
+
++ (BOOL)typeIsPathable:(IJSVGNodeType)type
+{
+    return type == IJSVGNodeTypePath || type == IJSVGNodeTypeRect ||
+        type == IJSVGNodeTypeCircle || type == IJSVGNodeTypeEllipse ||
+        type == IJSVGNodeTypePolygon || type == IJSVGNodeTypePolyline ||
+        type == IJSVGNodeTypeLine;
+}
+
++ (void)walkNodeTree:(IJSVGNode*)node
+             handler:(IJSVGNodeWalkHandler)handler
+{
+    BOOL allowChildNodes = YES;
+    BOOL stop = NO;
+    [self _walkNodeTree:node
+                handler:handler
+        allowChildNodes:&allowChildNodes
+                   stop:&stop];
+}
+
++ (void)_walkNodeTree:(IJSVGNode*)node
+              handler:(IJSVGNodeWalkHandler)handler
+      allowChildNodes:(BOOL*)allowChildNodes
+                 stop:(BOOL*)stop
+{
+    // run the handler and instantly stop
+    // if stop is set
+    handler(node, allowChildNodes, stop);
+    if(*stop == YES) {
+        return;
+    }
+    
+    // child nodes only work for nodes
+    // that are type group
+    if(*allowChildNodes == NO ||
+       [node isKindOfClass:IJSVGGroup.class] == NO) {
+        *allowChildNodes = YES;
+        return;
+    }
+    
+    // iterate over the childnodes
+    IJSVGGroup* group = (IJSVGGroup*)node;
+    for(IJSVGNode* childNode in group.children) {
+        [self _walkNodeTree:childNode
+                    handler:handler
+            allowChildNodes:allowChildNodes
+                       stop:stop];
+        if(*stop == YES) {
+            return;
+        }
+    }
+}
+
++ (NSArray<IJSVGNode*>*)node:(IJSVGNode*)node
+         nodesMatchingTraits:(IJSVGNodeTraits)traits
+{
+    NSMutableArray<IJSVGNode*>* nodes = [[NSMutableArray alloc] init];
+    IJSVGNodeWalkHandler handler = ^(IJSVGNode* node,
+                                     BOOL* allowChildNodes,
+                                     BOOL* stop) {
+        // dont compute nodes that are not designed
+        // to be rendered
+        if(node.shouldRender == NO) {
+            *allowChildNodes = NO;
+            return;
+        }
+        
+        if([node matchesTraits:traits] == YES) {
+            [nodes addObject:node];
+        }
+    };
+    [IJSVGNode walkNodeTree:node
+                    handler:handler];
+    return nodes;
+}
+
++ (BOOL)node:(IJSVGNode*)node
+containsNodesMatchingTraits:(IJSVGNodeTraits)traits
+{
+    __block IJSVGNodeTraits matchedTraits = IJSVGNodeTraitNone;
+    IJSVGNodeWalkHandler handler = ^(IJSVGNode* node,
+                                     BOOL* allowChildNodes,
+                                     BOOL* stop) {
+        // dont compute nodes that are not designed
+        // to be rendered
+        if(node.shouldRender == NO) {
+            *allowChildNodes = NO;
+            return;
+        }
+        
+        // check for stroke
+        if((traits & IJSVGNodeTraitStroked) == IJSVGNodeTraitStroked &&
+           [node matchesTraits:IJSVGNodeTraitStroked] == YES) {
+            matchedTraits |= IJSVGNodeTraitStroked;
+        }
+        
+        // check for pathed
+        if((traits & IJSVGNodeTraitPathed) == IJSVGNodeTraitPathed &&
+           [node matchesTraits:IJSVGNodeTraitPathed] == YES) {
+            matchedTraits |= IJSVGNodeTraitPathed;
+        }
+        
+        // check for paintable
+        if((traits & IJSVGNodeTraitPaintable) == IJSVGNodeTraitPaintable &&
+           [node matchesTraits:IJSVGNodeTraitPaintable] == YES) {
+            matchedTraits |= IJSVGNodeTraitPaintable;
+        }
+                
+        // simply check if masks equal, if they are, stop this loop
+        // and return the evaluation
+        if(matchedTraits == traits) {
+            *stop = YES;
+        }
+    };
+    [IJSVGNode walkNodeTree:node
+                    handler:handler];
+    return matchedTraits == traits;
+}
+
+- (id)init
+{
+    if((self = [super init]) != nil) {
+        self.opacity = [IJSVGUnitLength unitWithFloat:1.f];
+        self.fillOpacity = [IJSVGUnitLength unitWithFloat:1.f];
+        self.fillOpacity.inherit = YES;
+
+        self.strokeDashArrayCount = IJSVGInheritedIntegerValue;
+        self.strokeDashOffset = [IJSVGUnitLength unitWithFloat:0.f];
+        self.shouldRender = YES;
+
+        self.strokeOpacity = [IJSVGUnitLength unitWithFloat:1.f];
+        self.strokeOpacity.inherit = YES;
+
+        self.strokeWidth = [IJSVGUnitLength unitWithFloat:1.f];
+        self.strokeWidth.inherit = YES;
+
+        self.windingRule = IJSVGWindingRuleInherit;
+        self.clipRule = IJSVGWindingRuleInherit;
+        self.lineCapStyle = IJSVGLineCapStyleInherit;
+        self.lineJoinStyle = IJSVGLineJoinStyleInherit;
+        self.units = IJSVGUnitInherit;
+        self.contentUnits = IJSVGUnitInherit;
+
+        self.blendMode = IJSVGBlendModeNormal;
+        self.overflowVisibility = IJSVGOverflowVisibilityVisible;
+        
+        // peform basic init
+        [self setDefaults];
+    }
+    return self;
+}
+
+
+- (void)applyPropertiesFromNode:(IJSVGNode*)node
+{
+    self.title = node.title;
+    self.desc = node.desc;
+    
+    self.name = node.name;
+    self.type = node.type;
+    self.unicode = node.unicode;
+    self.className = node.className;
+    self.classNameList = node.classNameList;
+    
+    self.viewBox = node.viewBox;
+    self.viewBoxAlignment = node.viewBoxAlignment;
+    self.viewBoxMeetOrSlice = node.viewBoxMeetOrSlice;
+
+    self.x = node.x;
+    self.y = node.y;
+    self.width = node.width;
+    self.height = node.height;
+
+    self.fill = node.fill;
+    self.stroke = node.stroke;
+    self.clipPath = node.clipPath;
+
+    self.units = node.units;
+    self.contentUnits = node.contentUnits;
+
+    self.opacity = node.opacity;
+    self.strokeWidth = node.strokeWidth;
+    self.fillOpacity = node.fillOpacity;
+    self.strokeOpacity = node.strokeOpacity;
+    self.strokeMiterLimit = node.strokeMiterLimit;
+
+    self.identifier = node.identifier;
+
+    self.transforms = node.transforms;
+    self.windingRule = node.windingRule;
+    self.clipRule = node.clipRule;
+    self.lineCapStyle = node.lineCapStyle;
+    self.lineJoinStyle = node.lineJoinStyle;
+    self.parentNode = node.parentNode;
+
+    self.shouldRender = node.shouldRender;
+    self.blendMode = node.blendMode;
+    self.overflowVisibility = node.overflowVisibility;
+
+    // dash array needs physical memory copied
+    CGFloat* nStrokeDashArray = (CGFloat*)malloc(node.strokeDashArrayCount * sizeof(CGFloat));
+    memcpy(self.strokeDashArray, nStrokeDashArray, node.strokeDashArrayCount * sizeof(CGFloat));
+    self.strokeDashArray = nStrokeDashArray;
+    self.strokeDashArrayCount = node.strokeDashArrayCount;
+    self.strokeDashOffset = node.strokeDashOffset;
+}
+
+- (id)copyWithZone:(NSZone*)zone
+{
+    IJSVGNode* node = [self.class allocWithZone:zone];
+    [node applyPropertiesFromNode:self];
+    return node;
+}
+
+- (void)postProcess
+{
+}
+
+- (void)setFill:(IJSVGNode*)fill
+{
+    NSAssert([fill matchesTraits:IJSVGNodeTraitPaintable] || fill == nil, @"Fill must a paintable node.");
+    _fill = fill;
+}
+
+- (void)setStroke:(IJSVGNode*)stroke
+{
+    NSAssert([stroke matchesTraits:IJSVGNodeTraitPaintable]|| stroke == nil, @"Stroke must be a paintable node.");
+    _stroke = stroke;
+}
+
+// winding rule can inherit..
+- (IJSVGWindingRule)windingRule
+{
+    if(_windingRule == IJSVGWindingRuleInherit && _parentNode != nil) {
+        return _parentNode.windingRule;
+    }
+    return _windingRule;
+}
+
+- (IJSVGWindingRule)clipRule
+{
+    if(_clipRule == IJSVGWindingRuleInherit && _parentNode != nil) {
+        return _parentNode.clipRule;
+    }
+    return _clipRule;
+}
+
+- (IJSVGLineCapStyle)lineCapStyle
+{
+    if(_lineCapStyle == IJSVGLineCapStyleInherit) {
+        if(_parentNode != nil) {
+            return _parentNode.lineCapStyle;
+        }
+    }
+    return _lineCapStyle;
+}
+
+- (IJSVGLineJoinStyle)lineJoinStyle
+{
+    if(_lineJoinStyle == IJSVGLineJoinStyleInherit) {
+        if(_parentNode != nil) {
+            return _parentNode.lineJoinStyle;
+        }
+    }
+    return _lineJoinStyle;
+}
+
+// these are all recursive, so go up the chain
+// if they dont exist on this specific node
+- (IJSVGUnitLength*)opacity
+{
+    if(_opacity.inherit && _parentNode != nil) {
+        return _parentNode.opacity;
+    }
+    return _opacity;
+}
+
+// these are all recursive, so go up the chain
+// if they dont exist on this specific node
+- (IJSVGUnitLength*)fillOpacity
+{
+    if(_fillOpacity.inherit && _parentNode != nil) {
+        return _parentNode.fillOpacity;
+    }
+    return _fillOpacity;
+}
+
+// these are all recursive, so go up the chain
+// if they dont exist on this specific node
+- (IJSVGUnitLength*)strokeWidth
+{
+    if(_strokeWidth.inherit && _parentNode != nil) {
+        return _parentNode.strokeWidth;
+    }
+    return _strokeWidth;
+}
+
+- (NSArray<NSNumber*>*)lineDashPattern
+{
+    NSMutableArray* arr = [[NSMutableArray alloc] initWithCapacity:self.strokeDashArrayCount];
+    for (NSInteger i = 0; i < self.strokeDashArrayCount; i++) {
+        [arr addObject:@((CGFloat)self.strokeDashArray[i])];
+    }
+    return arr;
+}
+
+// these are all recursive, so go up the chain
+// if they dont exist on this specific node
+- (IJSVGNode*)stroke
+{
+    if(_stroke == nil && _parentNode != nil) {
+        return _parentNode.stroke;
+    }
+    return _stroke;
+}
+
+- (CGFloat*)strokeDashArray
+{
+    if(_strokeDashArray == NULL && _parentNode != nil) {
+        return _parentNode.strokeDashArray;
+    }
+    return _strokeDashArray;
+}
+
+- (NSInteger)strokeDashArrayCount
+{
+    if(_strokeDashArrayCount == IJSVGInheritedIntegerValue && _parentNode != nil) {
+        return _parentNode.strokeDashArrayCount;
+    }
+    return _strokeDashArrayCount;
+}
+
+- (IJSVGUnitLength *)strokeDashOffset
+{
+    if(_strokeDashOffset == nil && _parentNode != nil) {
+        return _parentNode.strokeDashOffset;
+    }
+    return _strokeDashOffset;
+}
+
+- (IJSVGUnitLength*)strokeOpacity
+{
+    if(_strokeOpacity.inherit && _parentNode != nil) {
+        return _parentNode.strokeOpacity;
+    }
+    return _strokeOpacity;
+}
+
+// even though the spec explicity states fill color
+// must be on the path, it can also be on the
+- (IJSVGNode*)fill
+{
+    if(_fill == nil && _parentNode != nil) {
+        return _parentNode.fill;
+    }
+    return _fill;
+}
+
+- (IJSVGUnitType)units
+{
+    if(_units == IJSVGUnitInherit && _parentNode != nil) {
+        return _parentNode.units;
+    }
+    return _units;
+}
+
+- (IJSVGUnitType)contentUnits
+{
+    if(_contentUnits == IJSVGUnitInherit && _parentNode != nil) {
+        return _parentNode.contentUnits;
+    }
+    return _contentUnits;
+}
+
+- (IJSVGUnitLength*)strokeMiterLimit
+{
+    if(_strokeMiterLimit == nil && _parentNode != nil) {
+        return _parentNode.strokeMiterLimit;
+    }
+    return _strokeMiterLimit;
+}
+
+- (IJSVGUnitType)contentUnitsWithReferencingNodeBounds:(CGRect*)bounds
+{
+    IJSVGNode* node = nil;
+    IJSVGUnitType type = [self contentUnitsWithReferencingNode:&node];
+    *bounds = node.parentNode.bounds;
+    return type;
+}
+
+- (IJSVGUnitType)contentUnitsWithReferencingNode:(IJSVGNode**)referencingNode
+{
+    if(_contentUnits == IJSVGUnitInherit && _parentNode != nil) {
+        return [_parentNode contentUnitsWithReferencingNode:referencingNode];
+    }
+    *referencingNode = self;
+    return _contentUnits;
+}
+
+- (IJSVGNodeTraits)traits
+{
+    if(_computedTraits == NO) {
+        _computedTraits = YES;
+        [self computeTraits];
+    }
+    return _traits;
+}
+
+- (void)addTraits:(IJSVGNodeTraits)traits
+{
+    _traits |= traits;
+}
+
+- (void)removeTraits:(IJSVGNodeTraits)traits
+{
+    _traits = _traits & ~traits;
+}
+
+- (BOOL)matchesTraits:(IJSVGNodeTraits)traits
+{
+    return (self.traits & traits) == traits;
+}
+
+- (void)computeTraits
+{
+    // by default this does nothing
+}
+
+- (void)setDefaults
+{
+}
+
+- (instancetype)detach
+{
+    self.parentNode = nil;
+    return self;
+}
+
+- (NSString *)description
+{
+    return [NSString stringWithFormat:@"%@ %@ %@ %@",NSStringFromClass(self.class),
+            self.name,self.classNameList,self.identifier];
+}
+
+- (BOOL)detachedFromParentNode
+{
+    return self.type == IJSVGNodeTypeClipPath ||
+        self.type == IJSVGNodeTypeMask;
+}
+
+- (IJSVGRootNode*)rootNode
+{
+    IJSVGNode* parent = self;
+    while([parent isKindOfClass:IJSVGRootNode.class] == NO) {
+        parent = parent.parentNode;
+        if(parent == nil) {
+            return nil;
+        }
+    }
+    return (IJSVGRootNode*)parent;
+}
+
+- (NSSet<IJSVGNode*>*)nodesMatchingTypes:(NSIndexSet*)types
+{
+    NSMutableSet<IJSVGNode*>* nodes = [[NSMutableSet alloc] init];
+    IJSVGNodeWalkHandler handler = ^(IJSVGNode* node,
+                                     BOOL* allowChildNodes,
+                                     BOOL* stop) {
+        if([types containsIndex:node.type] == YES) {
+            [nodes addObject:node];
+        }
+    };
+    [self.class walkNodeTree:self
+                     handler:handler];
+    return nodes.copy;
+}
+
+- (instancetype)parentNodeMatchingClass:(Class)class
+{
+    IJSVGNode* parent = self.parentNode;
+    if([parent isKindOfClass:class] == YES) {
+        return parent;
+    }
+    return [parent parentNodeMatchingClass:class];
+}
+
+- (instancetype)rootNodeMatchingClass:(Class)class
+{
+    IJSVGRootNode* rootNode = self.rootNode;
+    IJSVGNode* parentNode = self.parentNode;
+    IJSVGNode* foundNode = nil;
+    while(parentNode != nil) {
+        // break on root node or if its matching
+        if(parentNode == rootNode || parentNode == nil) {
+            break;
+        }
+        if([parentNode isKindOfClass:class] == YES) {
+            foundNode = parentNode;
+        }
+        parentNode = parentNode.parentNode;
+    }
+    return foundNode;
+}
+
+@end