@shopify/react-native-skia 0.1.222 → 0.1.223

package/cpp/api/JsiSkTextStyle.h

@@ -0,0 +1,185 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <jsi/jsi.h>
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+
+#include "Paragraph.h"
+#include "ParagraphStyle.h"
+
+#pragma clang diagnostic pop
+
+namespace RNSkia {
+
+namespace jsi = facebook::jsi;
+
+namespace para = skia::textlayout;
+
+/**
+ Implementation of the TextStyle object in JSI for the paragraph builder
+ */
+class JsiSkTextStyle {
+public:
+  static para::TextStyle fromValue(jsi::Runtime &runtime,
+                                   const jsi::Value &value) {
+
+    para::TextStyle retVal;
+
+    // Accept undefined && null
+    if (value.isUndefined() || value.isNull()) {
+      return retVal;
+    }
+
+    // Read values from the argument - expected to be a TextStyle shaped object
+    if (!value.isObject()) {
+      throw jsi::JSError(runtime, "Expected SkTextStyle as first argument");
+    }
+
+    auto object = value.asObject(runtime);
+
+    if (object.hasProperty(runtime, "backgroundColor")) {
+      auto propValue = object.getProperty(runtime, "backgroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setBackgroundPaint(p);
+    }
+    if (object.hasProperty(runtime, "color")) {
+      auto propValue = object.getProperty(runtime, "color");
+      retVal.setColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decoration")) {
+      auto propValue = object.getProperty(runtime, "decoration");
+      retVal.setDecoration(
+          static_cast<para::TextDecoration>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "decorationColor")) {
+      auto propValue = object.getProperty(runtime, "decorationColor");
+      retVal.setDecorationColor(JsiSkColor::fromValue(runtime, propValue));
+    }
+    if (object.hasProperty(runtime, "decorationThickness")) {
+      auto propValue = object.getProperty(runtime, "decorationThickness");
+      retVal.setDecorationThicknessMultiplier(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "decorationStyle")) {
+      auto propValue = object.getProperty(runtime, "decorationStyle");
+      retVal.setDecorationStyle(
+          static_cast<para::TextDecorationStyle>(propValue.asNumber()));
+    }
+    if (object.hasProperty(runtime, "fontFamilies")) {
+      auto propValue = object.getProperty(runtime, "fontFamilies")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      std::vector<SkString> families(size);
+      for (size_t i = 0; i < size; ++i) {
+        families[i] = propValue.getValueAtIndex(runtime, i)
+                          .asString(runtime)
+                          .utf8(runtime)
+                          .c_str();
+      }
+      retVal.setFontFamilies(families);
+    }
+    if (object.hasProperty(runtime, "fontFeatures")) {
+      auto propValue = object.getProperty(runtime, "fontFeatures")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetFontFeatures();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto name = element.getProperty(runtime, "name")
+                        .asString(runtime)
+                        .utf8(runtime);
+        auto value = element.getProperty(runtime, "value").asNumber();
+        retVal.addFontFeature(SkString(name), value);
+      }
+    }
+    if (object.hasProperty(runtime, "fontSize")) {
+      auto propValue = object.getProperty(runtime, "fontSize");
+      retVal.setFontSize(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "fontStyle")) {
+      auto propValue =
+          object.getProperty(runtime, "fontStyle").asObject(runtime);
+      auto weight = static_cast<SkFontStyle::Weight>(
+          propValue.hasProperty(runtime, "weight")
+              ? propValue.getProperty(runtime, "weight").asNumber()
+              : SkFontStyle::Weight::kNormal_Weight);
+
+      auto width = static_cast<SkFontStyle::Width>(
+          propValue.hasProperty(runtime, "width")
+              ? propValue.getProperty(runtime, "width").asNumber()
+              : SkFontStyle::Width::kNormal_Width);
+
+      auto slant = static_cast<SkFontStyle::Slant>(
+          propValue.hasProperty(runtime, "slant")
+              ? propValue.getProperty(runtime, "slant").asNumber()
+              : SkFontStyle::Slant::kUpright_Slant);
+
+      retVal.setFontStyle(SkFontStyle(weight, width, slant));
+    }
+    if (object.hasProperty(runtime, "foregroundColor")) {
+      auto propValue = object.getProperty(runtime, "foregroundColor");
+      SkPaint p;
+      p.setColor(JsiSkColor::fromValue(runtime, propValue));
+      retVal.setForegroundColor(p);
+    }
+    if (object.hasProperty(runtime, "heightMultiplier")) {
+      auto propValue = object.getProperty(runtime, "heightMultiplier");
+      retVal.setHeight(propValue.asNumber());
+      retVal.setHeightOverride(true);
+    }
+    if (object.hasProperty(runtime, "halfLeading")) {
+      auto propValue = object.getProperty(runtime, "halfLeading");
+      retVal.setHalfLeading(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "letterSpacing")) {
+      auto propValue = object.getProperty(runtime, "letterSpacing");
+      retVal.setLetterSpacing(propValue.asNumber());
+    }
+    if (object.hasProperty(runtime, "locale")) {
+      auto propValue = object.getProperty(runtime, "locale");
+      retVal.setLocale(SkString(propValue.asString(runtime).utf8(runtime)));
+    }
+    if (object.hasProperty(runtime, "shadows")) {
+      auto propValue = object.getProperty(runtime, "shadows")
+                           .asObject(runtime)
+                           .asArray(runtime);
+      auto size = propValue.size(runtime);
+      retVal.resetShadows();
+      for (size_t i = 0; i < size; ++i) {
+        auto element = propValue.getValueAtIndex(runtime, i).asObject(runtime);
+        auto color = element.hasProperty(runtime, "color")
+                         ? JsiSkColor::fromValue(
+                               runtime, element.getProperty(runtime, "color"))
+                         : SK_ColorBLACK;
+        SkPoint offset =
+            element.hasProperty(runtime, "offset")
+                ? *JsiSkPoint::fromValue(runtime,
+                                         element.getProperty(runtime, "offset"))
+                       .get()
+                : SkPoint::Make(0, 0);
+        auto blurSigma =
+            element.hasProperty(runtime, "blurRadius")
+                ? element.getProperty(runtime, "blurRadius").asNumber()
+                : 0;
+        retVal.addShadow(para::TextShadow(color, offset, blurSigma));
+      }
+    }
+    if (object.hasProperty(runtime, "textBaseline")) {
+      auto propValue = object.getProperty(runtime, "textBaseline");
+      retVal.setTextBaseline(
+          static_cast<para::TextBaseline>(propValue.asNumber()));
+    }
+
+    return retVal;
+  }
+};
+
+} // namespace RNSkia

package/cpp/jsi/JsiHostObject.h

@@ -331,6 +331,27 @@ protected:
     return value.asHostObject<T>(runtime);
   }
 
+  /**
+   Returns argument as host object or nullptr if the value is not a valid host
+   object of requested type
+   */
+  template <typename T = HostObject>
+  static std::shared_ptr<T>
+  tryGetArgumentAsHostObject(jsi::Runtime &runtime, const jsi::Value *arguments,
+                             size_t count, size_t index) {
+    const jsi::Value &value = getArgument(runtime, arguments, count, index);
+    if (!value.isObject()) {
+      return nullptr;
+    }
+
+    auto object = value.asObject(runtime);
+    if (!object.isHostObject(runtime)) {
+      return nullptr;
+    }
+
+    return object.asHostObject<T>(runtime);
+  }
+
   /**
    Returns argument as array or throws
    */

package/cpp/rnskia/dom/JsiDomApi.h

@@ -48,6 +48,7 @@
 #include "nodes/JsiTextPathNode.h"
 
 #include "nodes/JsiLayerNode.h"
+#include "nodes/JsiParagraphNode.h"
 
 namespace RNSkia {
 
@@ -162,6 +163,9 @@ public:
     installFunction("TextBlobNode", JsiTextBlobNode::createCtor(context));
 
     installFunction("LayerNode", JsiLayerNode::createCtor(context));
+
+    // Paragraph node
+    installFunction("ParagraphNode", JsiParagraphNode::createCtor(context));
   }
 };
 

package/cpp/rnskia/dom/nodes/JsiParagraphNode.h

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "JsiDomDrawingNode.h"
+#include "ParagraphProp.h"
+
+#include <memory>
+
+namespace RNSkia {
+
+class JsiParagraphNode : public JsiDomDrawingNode,
+                         public JsiDomNodeCtor<JsiParagraphNode> {
+public:
+  explicit JsiParagraphNode(std::shared_ptr<RNSkPlatformContext> context)
+      : JsiDomDrawingNode(context, "skParagraph") {}
+
+protected:
+  void draw(DrawingContext *context) override {
+    auto x = _xProp->value().getAsNumber();
+    auto y = _yProp->value().getAsNumber();
+    auto width = static_cast<SkScalar>(_widthProp->value().getAsNumber());
+
+    auto p = *_paragraphProp->getDerivedValue();
+    if (p != nullptr) {
+
+      // Let's ensure that we don't perform unnecessary layouts on the
+      // paragraph. We should only layout if we have a new paragraph or if the
+      // layout width has changed.
+      if (_lastLayoutWidth != width || _lastLayoutParagraph != p) {
+        // perform layout!
+        p->layout(width);
+        _lastLayoutWidth = width;
+        _lastLayoutParagraph = p;
+      }
+      // Paint the layout to the canvas
+      p->paint(context->getCanvas(), x, y);
+    }
+  }
+
+  void defineProperties(NodePropsContainer *container) override {
+    JsiDomDrawingNode::defineProperties(container);
+    _paragraphProp = container->defineProperty<ParagraphProp>("paragraph");
+
+    _xProp = container->defineProperty<NodeProp>("x");
+    _xProp->require();
+
+    _yProp = container->defineProperty<NodeProp>("y");
+    _yProp->require();
+
+    _widthProp = container->defineProperty<NodeProp>("width");
+    _widthProp->require();
+  }
+
+private:
+  ParagraphProp *_paragraphProp;
+  NodeProp *_xProp;
+  NodeProp *_yProp;
+  NodeProp *_widthProp;
+  SkScalar _lastLayoutWidth;
+  para::Paragraph *_lastLayoutParagraph = nullptr;
+};
+
+} // namespace RNSkia

package/cpp/rnskia/dom/props/ParagraphProp.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "DerivedNodeProp.h"
+
+#include "JsiSkParagraph.h"
+
+#include <memory>
+#include <string>
+
+namespace RNSkia {
+
+class ParagraphProp : public DerivedProp<para::Paragraph *> {
+public:
+  explicit ParagraphProp(PropId name,
+                         const std::function<void(BaseNodeProp *)> &onChange)
+      : DerivedProp<para::Paragraph *>(onChange) {
+    _paragraphProp = defineProperty<NodeProp>(name);
+  }
+
+  void updateDerivedValue() override {
+    if (_paragraphProp->isSet()) {
+      if (_paragraphProp->value().getType() != PropType::HostObject) {
+        throw std::runtime_error("Expected Paragraph object for the " +
+                                 std::string(getName()) + " property.");
+      }
+
+      auto ptr = std::dynamic_pointer_cast<JsiSkParagraph>(
+          _paragraphProp->value().getAsHostObject());
+
+      if (ptr == nullptr) {
+        throw std::runtime_error("Expected paragraph object for the " +
+                                 std::string(getName()) + " property.");
+      }
+
+      setDerivedValue(ptr->getParagraph());
+    } else {
+      setDerivedValue(nullptr);
+    }
+  }
+
+private:
+  NodeProp *_paragraphProp;
+};
+
+} // namespace RNSkia

package/cpp/skia/modules/skunicode/include/SkUnicode.h

@@ -0,0 +1,312 @@
+/*
+ * Copyright 2020 Google LLC
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#ifndef SkUnicode_DEFINED
+#define SkUnicode_DEFINED
+#include "include/core/SkSpan.h"
+#include "include/core/SkString.h"
+#include "include/core/SkTypes.h"
+#include "include/private/base/SkTArray.h"
+#include "include/private/base/SkTo.h"
+#include "src/base/SkUTF.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#if !defined(SKUNICODE_IMPLEMENTATION)
+    #define SKUNICODE_IMPLEMENTATION 0
+#endif
+
+#if !defined(SKUNICODE_API)
+    #if defined(SKUNICODE_DLL)
+        #if defined(_MSC_VER)
+            #if SKUNICODE_IMPLEMENTATION
+                #define SKUNICODE_API __declspec(dllexport)
+            #else
+                #define SKUNICODE_API __declspec(dllimport)
+            #endif
+        #else
+            #define SKUNICODE_API __attribute__((visibility("default")))
+        #endif
+    #else
+        #define SKUNICODE_API
+    #endif
+#endif
+
+namespace sknonstd {
+template <typename T> struct is_bitmask_enum;
+}
+
+class SKUNICODE_API SkBidiIterator {
+public:
+    typedef int32_t Position;
+    typedef uint8_t Level;
+    struct Region {
+        Region(Position start, Position end, Level level)
+            : start(start), end(end), level(level) { }
+        Position start;
+        Position end;
+        Level level;
+    };
+    enum Direction {
+        kLTR,
+        kRTL,
+    };
+    virtual ~SkBidiIterator() = default;
+    virtual Position getLength() = 0;
+    virtual Level getLevelAt(Position) = 0;
+};
+
+class SKUNICODE_API SkBreakIterator {
+public:
+    typedef int32_t Position;
+    typedef int32_t Status;
+    virtual ~SkBreakIterator() = default;
+    virtual Position first() = 0;
+    virtual Position current() = 0;
+    virtual Position next() = 0;
+    virtual Status status() = 0;
+    virtual bool isDone() = 0;
+    virtual bool setText(const char utftext8[], int utf8Units) = 0;
+    virtual bool setText(const char16_t utftext16[], int utf16Units) = 0;
+};
+
+class SKUNICODE_API SkUnicode {
+    public:
+        enum CodeUnitFlags {
+            kNoCodeUnitFlag = 0x00,
+            kPartOfWhiteSpaceBreak = 0x01,
+            kGraphemeStart = 0x02,
+            kSoftLineBreakBefore = 0x04,
+            kHardLineBreakBefore = 0x08,
+            kPartOfIntraWordBreak = 0x10,
+            kControl = 0x20,
+            kTabulation = 0x40,
+            kGlyphClusterStart = 0x80,
+            kIdeographic = 0x100,
+            kEmoji = 0x200,
+            kWordBreak = 0x400,
+            kSentenceBreak = 0x800,
+        };
+        enum class TextDirection {
+            kLTR,
+            kRTL,
+        };
+        typedef size_t Position;
+        typedef uint8_t BidiLevel;
+        struct BidiRegion {
+            BidiRegion(Position start, Position end, BidiLevel level)
+              : start(start), end(end), level(level) { }
+            Position start;
+            Position end;
+            BidiLevel level;
+        };
+        enum class LineBreakType {
+            kSoftLineBreak = 0,
+            kHardLineBreak = 100,
+        };
+
+        enum class BreakType { kWords, kGraphemes, kLines, kSentences };
+        struct LineBreakBefore {
+            LineBreakBefore(Position pos, LineBreakType breakType)
+              : pos(pos), breakType(breakType) { }
+            Position pos;
+            LineBreakType breakType;
+        };
+
+        virtual ~SkUnicode() = default;
+
+        virtual SkString toUpper(const SkString&) = 0;
+
+        virtual bool isControl(SkUnichar utf8) = 0;
+        virtual bool isWhitespace(SkUnichar utf8) = 0;
+        virtual bool isSpace(SkUnichar utf8) = 0;
+        virtual bool isTabulation(SkUnichar utf8) = 0;
+        virtual bool isHardBreak(SkUnichar utf8) = 0;
+        virtual bool isEmoji(SkUnichar utf8) = 0;
+        virtual bool isIdeographic(SkUnichar utf8) = 0;
+
+        // Methods used in SkShaper and SkText
+        virtual std::unique_ptr<SkBidiIterator> makeBidiIterator
+            (const uint16_t text[], int count, SkBidiIterator::Direction) = 0;
+        virtual std::unique_ptr<SkBidiIterator> makeBidiIterator
+            (const char text[], int count, SkBidiIterator::Direction) = 0;
+        virtual std::unique_ptr<SkBreakIterator> makeBreakIterator
+            (const char locale[], BreakType breakType) = 0;
+        virtual std::unique_ptr<SkBreakIterator> makeBreakIterator(BreakType type) = 0;
+
+        // Methods used in SkParagraph
+        static bool hasTabulationFlag(SkUnicode::CodeUnitFlags flags);
+        static bool hasHardLineBreakFlag(SkUnicode::CodeUnitFlags flags);
+        static bool hasSoftLineBreakFlag(SkUnicode::CodeUnitFlags flags);
+        static bool hasGraphemeStartFlag(SkUnicode::CodeUnitFlags flags);
+        static bool hasControlFlag(SkUnicode::CodeUnitFlags flags);
+        static bool hasPartOfWhiteSpaceBreakFlag(SkUnicode::CodeUnitFlags flags);
+
+        static bool extractBidi(const char utf8[],
+                                int utf8Units,
+                                TextDirection dir,
+                                std::vector<BidiRegion>* bidiRegions);
+        virtual bool getBidiRegions(const char utf8[],
+                                    int utf8Units,
+                                    TextDirection dir,
+                                    std::vector<BidiRegion>* results) = 0;
+        // Returns results in utf16
+        virtual bool getWords(const char utf8[], int utf8Units, const char* locale,
+                              std::vector<Position>* results) = 0;
+        virtual bool getUtf8Words(const char utf8[],
+                                  int utf8Units,
+                                  const char* locale,
+                                  std::vector<Position>* results) = 0;
+        virtual bool getSentences(const char utf8[],
+                                  int utf8Units,
+                                  const char* locale,
+                                  std::vector<Position>* results) = 0;
+        virtual bool computeCodeUnitFlags(
+                char utf8[], int utf8Units, bool replaceTabs,
+                skia_private::TArray<SkUnicode::CodeUnitFlags, true>* results) = 0;
+        virtual bool computeCodeUnitFlags(
+                char16_t utf16[], int utf16Units, bool replaceTabs,
+                skia_private::TArray<SkUnicode::CodeUnitFlags, true>* results) = 0;
+
+        static SkString convertUtf16ToUtf8(const char16_t * utf16, int utf16Units);
+        static SkString convertUtf16ToUtf8(const std::u16string& utf16);
+        static std::u16string convertUtf8ToUtf16(const char* utf8, int utf8Units);
+        static std::u16string convertUtf8ToUtf16(const SkString& utf8);
+
+        template <typename Appender8, typename Appender16>
+        static bool extractUtfConversionMapping(SkSpan<const char> utf8, Appender8&& appender8, Appender16&& appender16) {
+            size_t size8 = 0;
+            size_t size16 = 0;
+            auto ptr = utf8.begin();
+            auto end = utf8.end();
+            while (ptr < end) {
+
+                size_t index = SkToSizeT(ptr - utf8.begin());
+                SkUnichar u = SkUTF::NextUTF8(&ptr, end);
+
+                // All UTF8 code units refer to the same codepoint
+                size_t next = SkToSizeT(ptr - utf8.begin());
+                for (auto i = index; i < next; ++i) {
+                    //fUTF16IndexForUTF8Index.emplace_back(fUTF8IndexForUTF16Index.size());
+                    appender16(size8);
+                    ++size16;
+                }
+                //SkASSERT(fUTF16IndexForUTF8Index.size() == next);
+                SkASSERT(size16 == next);
+                if (size16 != next) {
+                    return false;
+                }
+
+                // One or two UTF16 code units refer to the same codepoint
+                uint16_t buffer[2];
+                size_t count = SkUTF::ToUTF16(u, buffer);
+                //fUTF8IndexForUTF16Index.emplace_back(index);
+                appender8(index);
+                ++size8;
+                if (count > 1) {
+                    //fUTF8IndexForUTF16Index.emplace_back(index);
+                    appender8(index);
+                    ++size8;
+                }
+            }
+            //fUTF16IndexForUTF8Index.emplace_back(fUTF8IndexForUTF16Index.size());
+            appender16(size8);
+            ++size16;
+            //fUTF8IndexForUTF16Index.emplace_back(fText.size());
+            appender8(utf8.size());
+            ++size8;
+
+            return true;
+        }
+
+        template <typename Callback>
+        void forEachCodepoint(const char* utf8, int32_t utf8Units, Callback&& callback) {
+            const char* current = utf8;
+            const char* end = utf8 + utf8Units;
+            while (current < end) {
+                auto before = current - utf8;
+                SkUnichar unichar = SkUTF::NextUTF8(&current, end);
+                if (unichar < 0) unichar = 0xFFFD;
+                auto after = current - utf8;
+                uint16_t buffer[2];
+                size_t count = SkUTF::ToUTF16(unichar, buffer);
+                callback(unichar, before, after, count);
+            }
+        }
+
+        template <typename Callback>
+        void forEachCodepoint(const char16_t* utf16, int32_t utf16Units, Callback&& callback) {
+            const char16_t* current = utf16;
+            const char16_t* end = utf16 + utf16Units;
+            while (current < end) {
+                auto before = current - utf16;
+                SkUnichar unichar = SkUTF::NextUTF16((const uint16_t**)&current, (const uint16_t*)end);
+                auto after = current - utf16;
+                callback(unichar, before, after);
+            }
+        }
+
+        template <typename Callback>
+        void forEachBidiRegion(const uint16_t utf16[], int utf16Units, SkBidiIterator::Direction dir, Callback&& callback) {
+            auto iter = makeBidiIterator(utf16, utf16Units, dir);
+            const uint16_t* start16 = utf16;
+            const uint16_t* end16 = utf16 + utf16Units;
+            SkBidiIterator::Level currentLevel = 0;
+
+            SkBidiIterator::Position pos16 = 0;
+            while (pos16 <= iter->getLength()) {
+                auto level = iter->getLevelAt(pos16);
+                if (pos16 == 0) {
+                    currentLevel = level;
+                } else if (level != currentLevel) {
+                    callback(pos16, start16 - utf16, currentLevel);
+                    currentLevel = level;
+                }
+                if (start16 == end16) {
+                    break;
+                }
+                SkUnichar u = SkUTF::NextUTF16(&start16, end16);
+                pos16 += SkUTF::ToUTF16(u);
+            }
+        }
+
+        template <typename Callback>
+        void forEachBreak(const char16_t utf16[], int utf16Units, SkUnicode::BreakType type, Callback&& callback) {
+            auto iter = makeBreakIterator(type);
+            iter->setText(utf16, utf16Units);
+            auto pos = iter->first();
+            do {
+                callback(pos, iter->status());
+                pos = iter->next();
+            } while (!iter->isDone());
+        }
+
+        virtual void reorderVisual(const BidiLevel runLevels[], int levelsCount, int32_t logicalFromVisual[]) = 0;
+
+        virtual std::unique_ptr<SkUnicode> copy() = 0;
+
+        static std::unique_ptr<SkUnicode> Make();
+
+        static std::unique_ptr<SkUnicode> MakeIcuBasedUnicode();
+
+        static std::unique_ptr<SkUnicode> MakeClientBasedUnicode(
+                SkSpan<char> text,
+                std::vector<SkUnicode::Position> words,
+                std::vector<SkUnicode::Position> graphemeBreaks,
+                std::vector<SkUnicode::LineBreakBefore> lineBreaks);
+
+        static std::unique_ptr<SkUnicode> MakeLibgraphemeBasedUnicode();
+};
+
+namespace sknonstd {
+template <> struct is_bitmask_enum<SkUnicode::CodeUnitFlags> : std::true_type {};
+}  // namespace sknonstd
+
+#endif // SkUnicode_DEFINED