@shopify/react-native-skia 0.1.124 → 0.1.125

package/android/CMakeLists.txt

@@ -39,6 +39,9 @@ add_library(
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkManager.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDrawView.cpp"
         "${PROJECT_SOURCE_DIR}/cpp/rnskia/RNSkDispatchQueue.cpp"
+
+
+        "${PROJECT_SOURCE_DIR}/cpp/api/third_party/CSSColorParser.cpp"
         
 )
 

package/android/build.gradle

@@ -175,7 +175,7 @@ dependencies {
     //noinspection GradleDynamicVersion
     extractJNI("com.facebook.fbjni:fbjni:0.2.2")
 
-    def rnAAR = fileTree("${rootDir}/../node_modules/react-native/android").matching({ it.include "**/**/*.aar" }).singleFile
+    def rnAAR = fileTree("${nodeModules}/react-native/android").matching({ it.include "**/**/*.aar" }).singleFile
     extractJNI(files(rnAAR))
 }
 

package/cpp/api/JsiSkApi.h

@@ -39,6 +39,7 @@
 #include "JsiSkContourMeasureIter.h"
 #include "JsiSkPictureRecorder.h"
 #include "JsiSkPictureFactory.h"
+#include "JsiSkRuntimeShaderBuilder.h"
 #include "JsiSkColor.h"
 
 namespace RNSkia
@@ -65,10 +66,11 @@ namespace RNSkia
       installFunction("XYWHRect", JsiSkRect::createCtor(context));
       installFunction("RRectXY", JsiSkRRect::createCtor(context));
       installFunction("Point", JsiSkPoint::createCtor(context));
+      installFunction("RuntimeShaderBuilder", JsiSkRuntimeShaderBuilder::createCtor(context));
       installFunction("ContourMeasureIter", JsiSkContourMeasureIter::createCtor(context));
       installFunction("MakeVertices", JsiSkVertices::createCtor(context));
       installFunction("PictureRecorder", JsiSkPictureRecorder::createCtor(context));
-      installFunction("parseColorString", JsiSkColor::createCtor());
+      installFunction("Color", JsiSkColor::createCtor());
 
       // Static members
       installReadonlyProperty("FontMgr",

package/cpp/api/JsiSkCanvas.h

@@ -278,7 +278,7 @@ public:
       auto colorsSize = jsiColors.size(runtime);
       colors.reserve(colorsSize);
       for (int i = 0; i < colorsSize; i++) {
-        SkColor color = jsiColors.getValueAtIndex(runtime, i).asNumber();
+        SkColor color = JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
         colors.push_back(color);
       }
     }

package/cpp/api/JsiSkColor.h

@@ -26,6 +26,35 @@ namespace RNSkia {
 
         ~JsiSkColor() {}
 
+        static jsi::Object toValue(jsi::Runtime &runtime, SkColor color) {
+            auto result = runtime
+                    .global()
+                    .getPropertyAsFunction(runtime, "Float32Array")
+                    .callAsConstructor(runtime, 4)
+                    .getObject(runtime);
+            jsi::ArrayBuffer buffer = result
+                    .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+                    .asObject(runtime)
+                    .getArrayBuffer(runtime);
+            auto bfrPtr = reinterpret_cast<float *>(buffer.data(runtime));
+            auto color4f = SkColor4f::FromColor(color).array();
+            std::copy(color4f.begin(), color4f.end(), bfrPtr);
+            return result;
+        }
+
+        static SkColor fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+            const auto& object = obj.asObject(runtime);
+            jsi::ArrayBuffer buffer = object
+                    .getProperty(runtime, jsi::PropNameID::forAscii(runtime, "buffer"))
+                    .asObject(runtime)
+                    .getArrayBuffer(runtime);
+            auto bfrPtr = reinterpret_cast<float *>(buffer.data(runtime));
+            if (bfrPtr[0] > 1 || bfrPtr[1] > 1 || bfrPtr[2] > 1 || bfrPtr[3] > 1) {
+                return SK_ColorBLACK;
+            }
+            return SkColorSetARGB(bfrPtr[3] * 255, bfrPtr[0] * 255, bfrPtr[1] * 255, bfrPtr[2] * 255);
+        }
+
         /**
          * Creates the function for construction a new instance of the SkColor
          * wrapper
@@ -35,14 +64,19 @@ namespace RNSkia {
         static const jsi::HostFunctionType
         createCtor() {
             return JSI_HOST_FUNCTION_LAMBDA {
-                auto text = arguments[0].asString(runtime).utf8(runtime);
-                auto color = CSSColorParser::parse(text);
-                if (color.a == -1.0f) {
-                    return jsi::Value::undefined();
+                if (arguments[0].isNumber()) {
+                    return JsiSkColor::toValue(runtime, arguments[0].getNumber());
+                } else if(arguments[0].isString()) {
+                    auto text = arguments[0].asString(runtime).utf8(runtime);
+                    auto color = CSSColorParser::parse(text);
+                    if (color.a == -1.0f) {
+                        return JsiSkColor::toValue(runtime, SK_ColorBLACK);
+                    }
+                    return JsiSkColor::toValue(runtime, SkColorSetARGB(color.a * 255, color.r, color.g, color.b));
+                } else if (arguments[0].isObject()) {
+                    return arguments[0].getObject(runtime);
                 }
-                int a = round(color.a * 255);
-                // Because JS numbers are unsigned we need to do this conversion
-                return jsi::Value(static_cast<double>(SkColorSetARGB(a, color.r, color.g, color.b) >> 0));
+                return jsi::Value::undefined();
             };
         }
     };

package/cpp/api/JsiSkColorFilterFactory.h

@@ -2,6 +2,7 @@
 
 #include "JsiSkColorFilter.h"
 #include "JsiSkHostObjects.h"
+#include "JsiSkColor.h"
 #include <jsi/jsi.h>
 #include <utility>
 
@@ -34,7 +35,7 @@ public:
   }
 
   JSI_HOST_FUNCTION(MakeBlend) {
-    auto color = arguments[0].asNumber();
+    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     SkBlendMode blend = (SkBlendMode)arguments[1].asNumber();
     // Return the newly constructed object
     return jsi::Object::createFromHostObject(

package/cpp/api/JsiSkImageFilter.h

@@ -5,13 +5,11 @@
 
 #include <jsi/jsi.h>
 
-#include "JsiSkColorFilter.h"
 #include "JsiSkHostObjects.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include <SkColorFilter.h>
 #include <SkImageFilters.h>
 
 #pragma clang diagnostic pop

package/cpp/api/JsiSkImageFilterFactory.h

@@ -7,11 +7,12 @@
 
 #include "JsiSkHostObjects.h"
 #include "JsiSkImageFilter.h"
+#include "JsiSkRuntimeShaderBuilder.h"
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
-#include <SkColorFilter.h>
+#include <SkImageFilter.h>
 
 #pragma clang diagnostic pop
 
@@ -123,7 +124,7 @@ public:
     auto dy = arguments[1].asNumber();
     auto sigmaX = arguments[2].asNumber();
     auto sigmaY = arguments[3].asNumber();
-    auto color = arguments[4].asNumber();
+    auto color = JsiSkColor::fromValue(runtime, arguments[4]);
     sk_sp<SkImageFilter> input;
     if (!arguments[5].isNull() && !arguments[5].isUndefined()) {
       input = JsiSkImageFilter::fromValue(runtime, arguments[5]);
@@ -144,7 +145,7 @@ public:
     auto dy = arguments[1].asNumber();
     auto sigmaX = arguments[2].asNumber();
     auto sigmaY = arguments[3].asNumber();
-    auto color = arguments[4].asNumber();
+    auto color = JsiSkColor::fromValue(runtime, arguments[4]);
     sk_sp<SkImageFilter> input;
     if (!arguments[5].isNull() && !arguments[5].isUndefined()) {
       input = JsiSkImageFilter::fromValue(runtime, arguments[5]);
@@ -195,20 +196,39 @@ public:
                     getContext(), SkImageFilters::Dilate(rx, ry, std::move(input), cropRect)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeBlur),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeOffset),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory,
-                                       MakeColorFilter),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory,
-                                       MakeShader),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDisplacementMap),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeCompose),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeErode),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDilate),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeBlend),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDropShadow),
-                       JSI_EXPORT_FUNC(JsiSkImageFilterFactory,
-                                       MakeDropShadowOnly))
+    JSI_HOST_FUNCTION(MakeRuntimeShader) {
+      auto rtb = JsiSkRuntimeShaderBuilder::fromValue(runtime, arguments[0]);
+
+      const char* childName = nullptr;
+      if (!arguments[1].isNull() && !arguments[1].isUndefined()) {
+        childName = arguments[1].asString(runtime).utf8(runtime).c_str();
+      }
+
+      sk_sp<SkImageFilter> input;
+      if (!arguments[2].isNull() && !arguments[2].isUndefined()) {
+        input = JsiSkImageFilter::fromValue(runtime, arguments[2]);
+      }
+      return jsi::Object::createFromHostObject(
+            runtime,
+            std::make_shared<JsiSkImageFilter>(
+                getContext(), SkImageFilters::RuntimeShader(*rtb, childName, std::move(input)))
+      );
+    }
+
+  JSI_EXPORT_FUNCTIONS(
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeBlur),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeOffset),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeColorFilter),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeShader),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDisplacementMap),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeCompose),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeErode),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDilate),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeBlend),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDropShadow),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeDropShadowOnly),
+        JSI_EXPORT_FUNC(JsiSkImageFilterFactory, MakeRuntimeShader)
+   )
 
   JsiSkImageFilterFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkMatrix.h

@@ -25,9 +25,51 @@ public:
       : JsiSkWrappingSharedPtrHostObject<SkMatrix>(
             context, std::make_shared<SkMatrix>(std::move(m))) {}
 
+
+  JSI_HOST_FUNCTION(preConcat) {
+    auto m3 = JsiSkMatrix::fromValue(runtime, arguments[0]);
+    getObject()->preConcat(*m3);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(preTranslate) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    getObject()->preTranslate(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(preScale) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    getObject()->preScale(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(preSkew) {
+    auto x = arguments[0].asNumber();
+    auto y = arguments[1].asNumber();
+    getObject()->preSkew(x, y);
+    return jsi::Value::undefined();
+  }
+
+  JSI_HOST_FUNCTION(preRotate) {
+    auto a = arguments[0].asNumber();
+    getObject()->preRotate(a);
+    return jsi::Value::undefined();
+  }
+
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkMatrix, preConcat),
+    JSI_EXPORT_FUNC(JsiSkMatrix, preTranslate),
+    JSI_EXPORT_FUNC(JsiSkMatrix, preScale),
+    JSI_EXPORT_FUNC(JsiSkMatrix, preSkew),
+    JSI_EXPORT_FUNC(JsiSkMatrix, preRotate),
+  )
+
   /**
-Returns the underlying object from a host object of this type
-*/
+   * Returns the underlying object from a host object of this type
+   */
   static std::shared_ptr<SkMatrix> fromValue(jsi::Runtime &runtime,
                                              const jsi::Value &obj) {
     const auto& object = obj.asObject(runtime);

package/cpp/api/JsiSkPaint.h

@@ -8,8 +8,10 @@
 #include <JsiSkHostObjects.h>
 #include <JsiSkImageFilter.h>
 #include <JsiSkMaskFilter.h>
+#include <JsiSkColorFilter.h>
 #include <JsiSkPathEffect.h>
 #include <JsiSkShader.h>
+#include <JsiSkColor.h>
 
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
@@ -38,7 +40,7 @@ public:
   }
 
   JSI_HOST_FUNCTION(getColor) {
-    return static_cast<double>(getObject()->getColor());
+    return JsiSkColor::toValue(runtime, getObject()->getColor());
   }
 
   JSI_HOST_FUNCTION(getStrokeCap) {
@@ -58,7 +60,7 @@ public:
   }
 
   JSI_HOST_FUNCTION(setColor) {
-    SkColor color = arguments[0].asNumber();
+    SkColor color = JsiSkColor::fromValue(runtime, arguments[0]);
     getObject()->setColor(color);
     return jsi::Value::undefined();
   }
@@ -90,11 +92,6 @@ public:
     case 1:
       getObject()->setStyle(SkPaint::kStroke_Style);
       break;
-      // This API is expected to be deprecated
-      // https://github.com/flutter/flutter/issues/5912
-      //                    case 2:
-      //                        getObject()->setStyle(SkPaint::kStrokeAndFill_Style);
-      //                        break;
     }
     return jsi::Value::undefined();
   }

package/cpp/api/JsiSkRuntimeEffect.h

@@ -35,6 +35,12 @@ namespace RNSkia
       : public JsiSkWrappingSkPtrHostObject<SkRuntimeEffect>
   {
   public:
+      
+    static sk_sp<SkRuntimeEffect> fromValue(jsi::Runtime &runtime, const jsi::Value &obj) {
+        const auto& object = obj.asObject(runtime);
+        return object.asHostObject<JsiSkRuntimeEffect>(runtime)->getObject();
+    }
+
     JSI_HOST_FUNCTION(makeShader)
     {
       auto uniforms = castUniforms(runtime, arguments[0]);
@@ -213,5 +219,6 @@ namespace RNSkia
       su.slot = (int)(u.offset / sizeof(float));
       return su;
     }
+
   };
 } // namespace RNSkia

package/cpp/api/JsiSkRuntimeEffectFactory.h

@@ -7,7 +7,6 @@
 #include <jsi/jsi.h>
 
 #include "JsiSkRuntimeEffect.h"
-#include "JsiSkColorFilter.h"
 #include "JsiSkHostObjects.h"
 
 namespace RNSkia {
@@ -32,7 +31,9 @@ public:
         runtime, std::make_shared<JsiSkRuntimeEffect>(getContext(), std::move(effect)));
   }
 
-  JSI_EXPORT_FUNCTIONS(JSI_EXPORT_FUNC(JsiSkRuntimeEffectFactory, Make))
+  JSI_EXPORT_FUNCTIONS(
+    JSI_EXPORT_FUNC(JsiSkRuntimeEffectFactory, Make)
+  )
 
   JsiSkRuntimeEffectFactory(std::shared_ptr<RNSkPlatformContext> context)
       : JsiSkHostObject(std::move(context)) {}

package/cpp/api/JsiSkRuntimeShaderBuilder.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include <jsi/jsi.h>
+
+#include "JsiSkHostObjects.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "JsiSkRuntimeEffect.h"
+#include <SkRuntimeEffect.h>
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+    using namespace facebook;
+
+    class JsiSkRuntimeShaderBuilder : public JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder> {
+    public:
+       
+        /**
+         Constructor
+         */
+        JsiSkRuntimeShaderBuilder(std::shared_ptr<RNSkPlatformContext> context, const SkRuntimeShaderBuilder &rt)
+                : JsiSkWrappingSharedPtrHostObject<SkRuntimeShaderBuilder>(
+                std::move(context), std::make_shared<SkRuntimeShaderBuilder>(rt)){}
+
+        /**
+          Returns the underlying object from a host object of this type
+         */
+        static std::shared_ptr<SkRuntimeShaderBuilder> fromValue(jsi::Runtime &runtime,
+                                                 const jsi::Value &obj) {
+            const auto& object = obj.asObject(runtime);
+            return object.asHostObject<JsiSkRuntimeShaderBuilder>(runtime)->getObject();
+           
+        }
+
+        /**
+          Returns the jsi object from a host object of this type
+         */
+        static jsi::Value toValue(jsi::Runtime &runtime,
+                                  std::shared_ptr<RNSkPlatformContext> context,
+                                  const SkRuntimeShaderBuilder &rt) {
+            return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), rt));
+        }
+
+        /**
+         * Creates the function for construction a new instance of the SkRect
+         * wrapper
+         * @param context platform context
+         * @return A function for creating a new host object wrapper for the SkRect
+         * class
+         */
+        static const jsi::HostFunctionType
+        createCtor(std::shared_ptr<RNSkPlatformContext> context) {
+            return JSI_HOST_FUNCTION_LAMBDA {
+                auto rt = JsiSkRuntimeEffect::fromValue(runtime, arguments[0]);
+                auto rtb = SkRuntimeShaderBuilder(rt);
+                // Return the newly constructed object
+                return jsi::Object::createFromHostObject(
+                    runtime, std::make_shared<JsiSkRuntimeShaderBuilder>(std::move(context), std::move(rtb)));
+            };
+        }
+    };
+} // namespace RNSkia

package/cpp/api/JsiSkShaderFactory.h

@@ -50,7 +50,7 @@ std::vector<SkColor> getColors(jsi::Runtime &runtime, const jsi::Value& value) {
     auto size = jsiColors.size(runtime);
     colors.reserve(size);
     for (int i = 0; i < size; i++) {
-      SkColor color = jsiColors.getValueAtIndex(runtime, i).asNumber();
+      SkColor color = JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
       colors.push_back(color);
     }
   }
@@ -191,7 +191,7 @@ public:
   }
 
   JSI_HOST_FUNCTION(MakeColor) {
-    auto color = arguments[0].asNumber();
+    auto color = JsiSkColor::fromValue(runtime, arguments[0]);
     sk_sp<SkShader> gradient = SkShaders::Color(color);
     return jsi::Object::createFromHostObject(
         runtime, std::make_shared<JsiSkShader>(getContext(), std::move(gradient)));

package/cpp/api/JsiSkVertices.h

@@ -97,7 +97,7 @@ namespace RNSkia {
                     auto colorsSize = jsiColors.size(runtime);
                     colors.reserve(colorsSize);
                     for (int i = 0; i < colorsSize; i++) {
-                        SkColor color = jsiColors.getValueAtIndex(runtime, i).asNumber();
+                        SkColor color = JsiSkColor::fromValue(runtime, jsiColors.getValueAtIndex(runtime, i));
                         colors.push_back(color);
                     }
                 }

package/cpp/api/third_party/CSSColorParser.cpp

@@ -0,0 +1,194 @@
+#include "CSSColorParser.h"
+
+namespace CSSColorParser {
+
+    template <typename T>
+    uint8_t clamp_css_byte(T i) {  // Clamp to integer 0 .. 255.
+        i = ::round(i);  // Seems to be what Chrome does (vs truncation).
+        return i < 0 ? 0 : i > 255 ? 255 : uint8_t(i);
+    }
+
+    template <typename T>
+    float clamp_css_float(T f) {  // Clamp to float 0.0 .. 1.0.
+        return f < 0 ? 0 : f > 1 ? 1 : float(f);
+    }
+
+    float parseFloat(const std::string& str) {
+        return strtof(str.c_str(), nullptr);
+    }
+
+    int64_t parseInt(const std::string& str, uint8_t base = 10) {
+        return strtoll(str.c_str(), nullptr, base);
+    }
+
+    uint8_t parse_css_int(const std::string& str) {  // int or percentage.
+        if (str.length() && str.back() == '%') {
+            return clamp_css_byte(parseFloat(str) / 100.0f * 255.0f);
+        } else {
+            return clamp_css_byte(parseInt(str));
+        }
+    }
+
+    float parse_css_float(const std::string& str) {  // float or percentage.
+        if (str.length() && str.back() == '%') {
+            return clamp_css_float(parseFloat(str) / 100.0f);
+        } else {
+            return clamp_css_float(parseFloat(str));
+        }
+    }
+
+    float css_hue_to_rgb(float m1, float m2, float h) {
+        if (h < 0.0f) {
+            h += 1.0f;
+        } else if (h > 1.0f) {
+            h -= 1.0f;
+        }
+
+        if (h * 6.0f < 1.0f) {
+            return m1 + (m2 - m1) * h * 6.0f;
+        }
+        if (h * 2.0f < 1.0f) {
+            return m2;
+        }
+        if (h * 3.0f < 2.0f) {
+            return m1 + (m2 - m1) * (2.0f / 3.0f - h) * 6.0f;
+        }
+        return m1;
+    }
+
+    std::vector<std::string> split(const std::string& s, char delim) {
+        std::vector<std::string> elems;
+        std::stringstream ss(s);
+        std::string item;
+        while (std::getline(ss, item, delim)) {
+            elems.push_back(item);
+        }
+        return elems;
+    }
+
+    Color parse(const std::string& css_str)  {
+        std::string str = css_str;
+
+        // Remove all whitespace, not compliant, but should just be more accepting.
+        str.erase(std::remove(str.begin(), str.end(), ' '), str.end());
+
+        // Convert to lowercase.
+        std::transform(str.begin(), str.end(), str.begin(), ::tolower);
+
+        for (const auto& namedColor : namedColors) {
+            if (str == namedColor.name) {
+                return { namedColor.color };
+            }
+        }
+
+        // #abc and #abc123 syntax.
+        if (str.length() && str.front() == '#') {
+            auto iv = parseInt(str.substr(1), 16);  // TODO(deanm): Stricter parsing.
+            if (str.length() == 4) {
+                if (!(iv >= 0 && iv <= 0xfff)) {
+                    return {};
+                } else {
+                    return {
+                            static_cast<uint8_t>(((iv & 0xf00) >> 4) | ((iv & 0xf00) >> 8)),
+                            static_cast<uint8_t>((iv & 0xf0) | ((iv & 0xf0) >> 4)),
+                            static_cast<uint8_t>((iv & 0xf) | ((iv & 0xf) << 4)),
+                            1
+                    };
+                }
+            } else if (str.length() == 7) {
+                if (!(iv >= 0 && iv <= 0xffffff)) {
+                    return {};  // Covers NaN.
+                } else {
+                    return {
+                            static_cast<uint8_t>((iv & 0xff0000) >> 16),
+                            static_cast<uint8_t>((iv & 0xff00) >> 8),
+                            static_cast<uint8_t>(iv & 0xff),
+                            1
+                    };
+                }
+            }else if (str.length() == 5) {
+                // #rgba
+                if (!(iv >= 0 && iv <= 0xffff)) return {};  // Covers NaN.
+                return {
+                        static_cast<uint8_t>(((iv & 0xf000) >> 8) | ((iv & 0xf000) >> 12)),
+                        static_cast<uint8_t>(((iv & 0x0f00) >> 4) | ((iv & 0x0f00) >> 8)),
+                        static_cast<uint8_t>((iv & 0x00f0)       | ((iv & 0x00f0) >> 4)),
+                        static_cast<uint8_t>(((iv & 0x000f) << 4  |  (iv & 0x000f))) / 255.0f
+                };
+            } else if (str.length() == 9) {
+                // #rrggbbaa
+                if (!(iv >= 0 && iv <= 0xffffffff)) return {};  // Covers NaN.
+                return {
+                        static_cast<uint8_t>(((iv & 0xff000000) >> 24) & 0xff),
+                        static_cast<uint8_t>((iv & 0x00ff0000) >> 16),
+                        static_cast<uint8_t>((iv & 0x0000ff00) >> 8),
+                        static_cast<uint8_t>((iv & 0x000000ff)) / 255.0f
+                };
+            }
+
+            return {};
+        }
+
+        size_t op = str.find_first_of('('), ep = str.find_first_of(')');
+        if (op != std::string::npos && ep + 1 == str.length()) {
+            const std::string fname = str.substr(0, op);
+            const std::vector<std::string> params = split(str.substr(op + 1, ep - (op + 1)), ',');
+
+            float alpha = 1.0f;
+
+            if (fname == "rgba" || fname == "rgb") {
+                if (fname == "rgba") {
+                    if (params.size() != 4) {
+                        return { };
+                    }
+                    alpha = parse_css_float(params.back());
+                } else {
+                    if (params.size() != 3) {
+                        return { };
+                    }
+                }
+
+                return {
+                        parse_css_int(params[0]),
+                        parse_css_int(params[1]),
+                        parse_css_int(params[2]),
+                        alpha
+                };
+
+            } else if (fname == "hsla" || fname == "hsl") {
+                if (fname == "hsla") {
+                    if (params.size() != 4) {
+                        return { };
+                    }
+                    alpha = parse_css_float(params.back());
+                } else {
+                    if (params.size() != 3) {
+                        return { };
+                    }
+                }
+
+                float h = parseFloat(params[0]) / 360.0f;
+                float i;
+                // Normalize the hue to [0..1[
+                h = std::modf(h, &i);
+
+                // NOTE(deanm): According to the CSS spec s/l should only be
+                // percentages, but we don't bother and let float or percentage.
+                float s = parse_css_float(params[1]);
+                float l = parse_css_float(params[2]);
+
+                float m2 = l <= 0.5f ? l * (s + 1.0f) : l + s - l * s;
+                float m1 = l * 2.0f - m2;
+
+                return {
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h + 1.0f / 3.0f) * 255.0f),
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h) * 255.0f),
+                        clamp_css_byte(css_hue_to_rgb(m1, m2, h - 1.0f / 3.0f) * 255.0f),
+                        alpha
+                };
+            }
+        }
+
+        return { };
+    }
+}