@vidocsecurity/cli 0.1.12

package/dist/node_modules/yoga-layout/src/Node.h

@@ -0,0 +1,239 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <memory>
+
+#include <emscripten/bind.h>
+#include <yoga/Yoga.h>
+
+#include "./Config.h"
+#include "./Layout.h"
+#include "./Size.h"
+#include "./Value.h"
+
+class MeasureCallback {
+ public:
+  virtual ~MeasureCallback() {}
+  virtual Size
+  measure(float width, int widthMode, float height, int heightMode) = 0;
+};
+
+class MeasureCallbackWrapper : public emscripten::wrapper<MeasureCallback> {
+ public:
+  EMSCRIPTEN_WRAPPER(MeasureCallbackWrapper);
+  Size measure(float width, int widthMode, float height, int heightMode) {
+    return call<Size>("measure", width, widthMode, height, heightMode);
+  }
+};
+
+class DirtiedCallback {
+ public:
+  virtual ~DirtiedCallback() {}
+  virtual void dirtied() = 0;
+};
+
+class DirtiedCallbackWrapper : public emscripten::wrapper<DirtiedCallback> {
+ public:
+  EMSCRIPTEN_WRAPPER(DirtiedCallbackWrapper);
+  void dirtied() {
+    return call<void>("dirtied");
+  }
+};
+
+class Node {
+ public:
+  static Node* createDefault(void);
+  static Node* createWithConfig(Config* config);
+
+  static void destroy(Node* node);
+
+ public:
+  static Node* fromYGNode(YGNodeRef nodeRef);
+
+ private:
+  Node(Config* config);
+
+ public:
+  ~Node(void);
+
+ public: // Prevent accidental copy
+  Node(Node const&) = delete;
+
+  Node const& operator=(Node const&) = delete;
+
+ public:
+  void reset(void);
+
+ public: // Style setters
+  void copyStyle(Node const& other);
+
+  void setPositionType(int positionType);
+  void setPosition(int edge, double position);
+  void setPositionPercent(int edge, double position);
+  void setPositionAuto(int edge);
+
+  void setAlignContent(int alignContent);
+  void setAlignItems(int alignItems);
+  void setAlignSelf(int alignSelf);
+  void setFlexDirection(int flexDirection);
+  void setFlexWrap(int flexWrap);
+  void setJustifyContent(int justifyContent);
+  void setDirection(int direction);
+
+  void setMargin(int edge, double margin);
+  void setMarginPercent(int edge, double margin);
+  void setMarginAuto(int edge);
+
+  void setOverflow(int overflow);
+  void setDisplay(int display);
+
+  void setFlex(double flex);
+  void setFlexBasis(double flexBasis);
+  void setFlexBasisPercent(double flexBasis);
+  void setFlexBasisAuto();
+  void setFlexGrow(double flexGrow);
+  void setFlexShrink(double flexShrink);
+
+  void setWidth(double width);
+  void setWidthPercent(double width);
+  void setWidthAuto();
+  void setHeight(double height);
+  void setHeightPercent(double height);
+  void setHeightAuto();
+
+  void setMinWidth(double minWidth);
+  void setMinWidthPercent(double minWidth);
+  void setMinHeight(double minHeight);
+  void setMinHeightPercent(double minHeight);
+
+  void setMaxWidth(double maxWidth);
+  void setMaxWidthPercent(double maxWidth);
+  void setMaxHeight(double maxHeight);
+  void setMaxHeightPercent(double maxHeight);
+
+  void setAspectRatio(double aspectRatio);
+
+  void setBorder(int edge, double border);
+
+  void setPadding(int edge, double padding);
+  void setPaddingPercent(int edge, double padding);
+
+  void setGap(int gutter, double gapLength);
+  void setGapPercent(int gutter, double gapLength);
+
+  void setBoxSizing(int boxSizing);
+
+ public: // Style getters
+  int getPositionType(void) const;
+  Value getPosition(int edge) const;
+
+  int getAlignContent(void) const;
+  int getAlignItems(void) const;
+  int getAlignSelf(void) const;
+  int getFlexDirection(void) const;
+  int getFlexWrap(void) const;
+  int getJustifyContent(void) const;
+  int getDirection(void) const;
+
+  Value getMargin(int edge) const;
+
+  int getOverflow(void) const;
+  int getDisplay(void) const;
+
+  Value getFlexBasis(void) const;
+  double getFlexGrow(void) const;
+  double getFlexShrink(void) const;
+
+  Value getWidth(void) const;
+  Value getHeight(void) const;
+
+  Value getMinWidth(void) const;
+  Value getMinHeight(void) const;
+
+  Value getMaxWidth(void) const;
+  Value getMaxHeight(void) const;
+
+  double getAspectRatio(void) const;
+
+  double getBorder(int edge) const;
+
+  Value getPadding(int edge) const;
+
+  float getGap(int gutter);
+
+  int getBoxSizing(void) const;
+
+ public: // Tree hierarchy mutators
+  void insertChild(Node* child, unsigned index);
+  void removeChild(Node* child);
+
+ public: // Tree hierarchy inspectors
+  unsigned getChildCount(void) const;
+
+  // The following functions cannot be const because they could discard const
+  // qualifiers (ex: constNode->getChild(0)->getParent() wouldn't be const)
+
+  Node* getParent(void);
+  Node* getChild(unsigned index);
+
+ public: // Measure func mutators
+  void setMeasureFunc(MeasureCallback* measureFunc);
+  void unsetMeasureFunc(void);
+
+ public: // Measure func inspectors
+  Size callMeasureFunc(
+      double width,
+      int widthMode,
+      double height,
+      int heightMode) const;
+
+ public: // Dirtied func mutators
+  void setDirtiedFunc(DirtiedCallback* dirtiedFunc);
+  void unsetDirtiedFunc(void);
+
+ public: // Dirtied func inspectors
+  void callDirtiedFunc(void) const;
+
+ public: // Dirtiness accessors
+  void markDirty(void);
+  bool isDirty(void) const;
+  void markLayoutSeen();
+  bool hasNewLayout(void) const;
+
+ public: // Layout mutators
+  void calculateLayout(double width, double height, int direction);
+
+ public: // Layout inspectors
+  double getComputedLeft(void) const;
+  double getComputedRight(void) const;
+
+  double getComputedTop(void) const;
+  double getComputedBottom(void) const;
+
+  double getComputedWidth(void) const;
+  double getComputedHeight(void) const;
+
+  Layout getComputedLayout(void) const;
+
+  double getComputedMargin(int edge) const;
+  double getComputedBorder(int edge) const;
+  double getComputedPadding(int edge) const;
+
+ public:
+  void setIsReferenceBaseline(bool isReferenceBaseline);
+  bool isReferenceBaseline();
+
+  YGNodeRef m_node;
+
+  std::unique_ptr<MeasureCallback> m_measureFunc;
+  std::unique_ptr<DirtiedCallback> m_dirtiedFunc;
+
+ public:
+  void setAlwaysFormsContainingBlock(bool alwaysFormContainingBlock);
+};

package/dist/node_modules/yoga-layout/src/Size.h

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+struct Size {
+  double width;
+  double height;
+
+  Size(void) : width(0.0), height(0.0) {}
+
+  Size(double width, double height) : width(width), height(height) {}
+};

package/dist/node_modules/yoga-layout/src/Value.h

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#pragma once
+
+#include <yoga/Yoga.h>
+
+struct Value {
+  static Value fromYGValue(YGValue const& ygValue) {
+    return Value(static_cast<int>(ygValue.unit), ygValue.value);
+  }
+
+  int unit;
+  double value;
+
+  Value(void) : unit(YGUnitUndefined), value(0.0) {}
+
+  Value(int unit, double value) : unit(unit), value(value) {}
+};

package/dist/node_modules/yoga-layout/src/embind.cpp

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#include "./Config.h"
+#include "./Layout.h"
+#include "./Node.h"
+#include "./Size.h"
+#include "./Value.h"
+
+#include <emscripten/bind.h>
+#include <yoga/Yoga.h>
+
+using namespace emscripten;
+
+EMSCRIPTEN_BINDINGS(YOGA_LAYOUT) {
+  class_<MeasureCallback>("MeasureCallback")
+      .function("measure", &MeasureCallback::measure, pure_virtual())
+      .allow_subclass<MeasureCallbackWrapper>("MeasureCallbackWrapper");
+  class_<DirtiedCallback>("DirtiedCallback")
+      .function("dirtied", &DirtiedCallback::dirtied, pure_virtual())
+      .allow_subclass<DirtiedCallbackWrapper>("DirtiedCallbackWrapper");
+
+  class_<Config>("Config")
+      .constructor<>(&Config::create, allow_raw_pointers())
+      .class_function<>("create", &Config::create, allow_raw_pointers())
+      .class_function<>("destroy", &Config::destroy, allow_raw_pointers())
+      .function(
+          "setExperimentalFeatureEnabled",
+          &Config::setExperimentalFeatureEnabled)
+      .function("setPointScaleFactor", &Config::setPointScaleFactor)
+      .function("setErrata", &Config::setErrata)
+      .function("setUseWebDefaults", &Config::setUseWebDefaults)
+      .function(
+          "isExperimentalFeatureEnabled", &Config::isExperimentalFeatureEnabled)
+      .function("getErrata", &Config::getErrata)
+      .function("useWebDefaults", &Config::useWebDefaults);
+
+  value_object<Layout>("Layout")
+      .field("left", &Layout::left)
+      .field("right", &Layout::right)
+      .field("top", &Layout::top)
+      .field("bottom", &Layout::bottom)
+      .field("width", &Layout::width)
+      .field("height", &Layout::height);
+
+  value_object<Size>("Size")
+      .field("width", &Size::width)
+      .field("height", &Size::height);
+
+  value_object<Value>("Value")
+      .field("value", &Value::value)
+      .field("unit", &Value::unit);
+
+  class_<Node>("Node")
+      .constructor<>(&Node::createDefault, allow_raw_pointers())
+
+      .class_function<>(
+          "createDefault", &Node::createDefault, allow_raw_pointers())
+      .class_function<>(
+          "createWithConfig", &Node::createWithConfig, allow_raw_pointers())
+      .class_function<>("destroy", &Node::destroy, allow_raw_pointers())
+      .function("reset", &Node::reset)
+
+      .function("copyStyle", &Node::copyStyle)
+
+      .function("setPositionType", &Node::setPositionType)
+      .function("setPosition", &Node::setPosition)
+      .function("setPositionPercent", &Node::setPositionPercent)
+      .function("setPositionAuto", &Node::setPositionAuto)
+
+      .function("setAlignContent", &Node::setAlignContent)
+      .function("setAlignItems", &Node::setAlignItems)
+      .function("setAlignSelf", &Node::setAlignSelf)
+      .function("setFlexDirection", &Node::setFlexDirection)
+      .function("setFlexWrap", &Node::setFlexWrap)
+      .function("setJustifyContent", &Node::setJustifyContent)
+
+      .function("setMargin", &Node::setMargin)
+      .function("setMarginPercent", &Node::setMarginPercent)
+      .function("setMarginAuto", &Node::setMarginAuto)
+
+      .function("setOverflow", &Node::setOverflow)
+      .function("setDisplay", &Node::setDisplay)
+
+      .function("setFlex", &Node::setFlex)
+      .function("setFlexBasis", &Node::setFlexBasis)
+      .function("setFlexBasisPercent", &Node::setFlexBasisPercent)
+      .function("setFlexBasisAuto", &Node::setFlexBasisAuto)
+      .function("setFlexGrow", &Node::setFlexGrow)
+      .function("setFlexShrink", &Node::setFlexShrink)
+
+      .function("setWidth", &Node::setWidth)
+      .function("setWidthPercent", &Node::setWidthPercent)
+      .function("setWidthAuto", &Node::setWidthAuto)
+      .function("setHeight", &Node::setHeight)
+      .function("setHeightPercent", &Node::setHeightPercent)
+      .function("setHeightAuto", &Node::setHeightAuto)
+
+      .function("setMinWidth", &Node::setMinWidth)
+      .function("setMinWidthPercent", &Node::setMinWidthPercent)
+      .function("setMinHeight", &Node::setMinHeight)
+      .function("setMinHeightPercent", &Node::setMinHeightPercent)
+
+      .function("setMaxWidth", &Node::setMaxWidth)
+      .function("setMaxWidthPercent", &Node::setMaxWidthPercent)
+      .function("setMaxHeight", &Node::setMaxHeight)
+      .function("setMaxHeightPercent", &Node::setMaxHeightPercent)
+
+      .function("setBoxSizing", &Node::setBoxSizing)
+
+      .function("setAspectRatio", &Node::setAspectRatio)
+
+      .function("setBorder", &Node::setBorder)
+
+      .function("setPadding", &Node::setPadding)
+      .function("setPaddingPercent", &Node::setPaddingPercent)
+      .function("setGap", &Node::setGap)
+      .function("setGapPercent", &Node::setGapPercent)
+
+      .function("setDirection", &Node::setDirection)
+
+      .function("getPositionType", &Node::getPositionType)
+      .function("getPosition", &Node::getPosition)
+
+      .function("getAlignContent", &Node::getAlignContent)
+      .function("getAlignItems", &Node::getAlignItems)
+      .function("getAlignSelf", &Node::getAlignSelf)
+      .function("getFlexDirection", &Node::getFlexDirection)
+      .function("getFlexWrap", &Node::getFlexWrap)
+      .function("getJustifyContent", &Node::getJustifyContent)
+
+      .function("getMargin", &Node::getMargin)
+
+      .function("getFlexBasis", &Node::getFlexBasis)
+      .function("getFlexGrow", &Node::getFlexGrow)
+      .function("getFlexShrink", &Node::getFlexShrink)
+
+      .function("getWidth", &Node::getWidth)
+      .function("getHeight", &Node::getHeight)
+
+      .function("getMinWidth", &Node::getMinWidth)
+      .function("getMinHeight", &Node::getMinHeight)
+
+      .function("getMaxWidth", &Node::getMaxWidth)
+      .function("getMaxHeight", &Node::getMaxHeight)
+
+      .function("getBoxSizing", &Node::getBoxSizing)
+
+      .function("getAspectRatio", &Node::getAspectRatio)
+
+      .function("getBorder", &Node::getBorder)
+
+      .function("getOverflow", &Node::getOverflow)
+      .function("getDisplay", &Node::getDisplay)
+
+      .function("getPadding", &Node::getPadding)
+      .function("getGap", &Node::getGap)
+
+      .function("insertChild", &Node::insertChild, allow_raw_pointers())
+      .function("removeChild", &Node::removeChild, allow_raw_pointers())
+
+      .function("getChildCount", &Node::getChildCount)
+
+      .function("getParent", &Node::getParent, allow_raw_pointers())
+      .function("getChild", &Node::getChild, allow_raw_pointers())
+
+      .function(
+          "setAlwaysFormsContainingBlock", &Node::setAlwaysFormsContainingBlock)
+
+      .function("isReferenceBaseline", &Node::isReferenceBaseline)
+      .function("setIsReferenceBaseline", &Node::setIsReferenceBaseline)
+
+      .function("setMeasureFunc", &Node::setMeasureFunc, allow_raw_pointers())
+      .function("unsetMeasureFunc", &Node::unsetMeasureFunc)
+
+      .function("setDirtiedFunc", &Node::setDirtiedFunc, allow_raw_pointers())
+      .function("unsetDirtiedFunc", &Node::unsetDirtiedFunc)
+
+      .function("markDirty", &Node::markDirty)
+      .function("isDirty", &Node::isDirty)
+
+      .function("markLayoutSeen", &Node::markLayoutSeen)
+      .function("hasNewLayout", &Node::hasNewLayout)
+
+      .function("calculateLayout", &Node::calculateLayout)
+
+      .function("getComputedLeft", &Node::getComputedLeft)
+      .function("getComputedRight", &Node::getComputedRight)
+
+      .function("getComputedTop", &Node::getComputedTop)
+      .function("getComputedBottom", &Node::getComputedBottom)
+
+      .function("getComputedWidth", &Node::getComputedWidth)
+      .function("getComputedHeight", &Node::getComputedHeight)
+
+      .function("getComputedLayout", &Node::getComputedLayout)
+
+      .function("getComputedMargin", &Node::getComputedMargin)
+      .function("getComputedBorder", &Node::getComputedBorder)
+      .function("getComputedPadding", &Node::getComputedPadding)
+
+      .function("getDirection", &Node::getDirection);
+}

package/dist/node_modules/yoga-layout/src/generated/YGEnums.ts

@@ -0,0 +1,210 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+// @generated by enums.py
+
+export enum Align {
+  Auto = 0,
+  FlexStart = 1,
+  Center = 2,
+  FlexEnd = 3,
+  Stretch = 4,
+  Baseline = 5,
+  SpaceBetween = 6,
+  SpaceAround = 7,
+  SpaceEvenly = 8,
+}
+
+export enum BoxSizing {
+  BorderBox = 0,
+  ContentBox = 1,
+}
+
+export enum Dimension {
+  Width = 0,
+  Height = 1,
+}
+
+export enum Direction {
+  Inherit = 0,
+  LTR = 1,
+  RTL = 2,
+}
+
+export enum Display {
+  Flex = 0,
+  None = 1,
+  Contents = 2,
+}
+
+export enum Edge {
+  Left = 0,
+  Top = 1,
+  Right = 2,
+  Bottom = 3,
+  Start = 4,
+  End = 5,
+  Horizontal = 6,
+  Vertical = 7,
+  All = 8,
+}
+
+export enum Errata {
+  None = 0,
+  StretchFlexBasis = 1,
+  AbsolutePositionWithoutInsetsExcludesPadding = 2,
+  AbsolutePercentAgainstInnerSize = 4,
+  All = 2147483647,
+  Classic = 2147483646,
+}
+
+export enum ExperimentalFeature {
+  WebFlexBasis = 0,
+}
+
+export enum FlexDirection {
+  Column = 0,
+  ColumnReverse = 1,
+  Row = 2,
+  RowReverse = 3,
+}
+
+export enum Gutter {
+  Column = 0,
+  Row = 1,
+  All = 2,
+}
+
+export enum Justify {
+  FlexStart = 0,
+  Center = 1,
+  FlexEnd = 2,
+  SpaceBetween = 3,
+  SpaceAround = 4,
+  SpaceEvenly = 5,
+}
+
+export enum LogLevel {
+  Error = 0,
+  Warn = 1,
+  Info = 2,
+  Debug = 3,
+  Verbose = 4,
+  Fatal = 5,
+}
+
+export enum MeasureMode {
+  Undefined = 0,
+  Exactly = 1,
+  AtMost = 2,
+}
+
+export enum NodeType {
+  Default = 0,
+  Text = 1,
+}
+
+export enum Overflow {
+  Visible = 0,
+  Hidden = 1,
+  Scroll = 2,
+}
+
+export enum PositionType {
+  Static = 0,
+  Relative = 1,
+  Absolute = 2,
+}
+
+export enum Unit {
+  Undefined = 0,
+  Point = 1,
+  Percent = 2,
+  Auto = 3,
+}
+
+export enum Wrap {
+  NoWrap = 0,
+  Wrap = 1,
+  WrapReverse = 2,
+}
+
+const constants = {
+  ALIGN_AUTO: Align.Auto,
+  ALIGN_FLEX_START: Align.FlexStart,
+  ALIGN_CENTER: Align.Center,
+  ALIGN_FLEX_END: Align.FlexEnd,
+  ALIGN_STRETCH: Align.Stretch,
+  ALIGN_BASELINE: Align.Baseline,
+  ALIGN_SPACE_BETWEEN: Align.SpaceBetween,
+  ALIGN_SPACE_AROUND: Align.SpaceAround,
+  ALIGN_SPACE_EVENLY: Align.SpaceEvenly,
+  BOX_SIZING_BORDER_BOX: BoxSizing.BorderBox,
+  BOX_SIZING_CONTENT_BOX: BoxSizing.ContentBox,
+  DIMENSION_WIDTH: Dimension.Width,
+  DIMENSION_HEIGHT: Dimension.Height,
+  DIRECTION_INHERIT: Direction.Inherit,
+  DIRECTION_LTR: Direction.LTR,
+  DIRECTION_RTL: Direction.RTL,
+  DISPLAY_FLEX: Display.Flex,
+  DISPLAY_NONE: Display.None,
+  DISPLAY_CONTENTS: Display.Contents,
+  EDGE_LEFT: Edge.Left,
+  EDGE_TOP: Edge.Top,
+  EDGE_RIGHT: Edge.Right,
+  EDGE_BOTTOM: Edge.Bottom,
+  EDGE_START: Edge.Start,
+  EDGE_END: Edge.End,
+  EDGE_HORIZONTAL: Edge.Horizontal,
+  EDGE_VERTICAL: Edge.Vertical,
+  EDGE_ALL: Edge.All,
+  ERRATA_NONE: Errata.None,
+  ERRATA_STRETCH_FLEX_BASIS: Errata.StretchFlexBasis,
+  ERRATA_ABSOLUTE_POSITION_WITHOUT_INSETS_EXCLUDES_PADDING: Errata.AbsolutePositionWithoutInsetsExcludesPadding,
+  ERRATA_ABSOLUTE_PERCENT_AGAINST_INNER_SIZE: Errata.AbsolutePercentAgainstInnerSize,
+  ERRATA_ALL: Errata.All,
+  ERRATA_CLASSIC: Errata.Classic,
+  EXPERIMENTAL_FEATURE_WEB_FLEX_BASIS: ExperimentalFeature.WebFlexBasis,
+  FLEX_DIRECTION_COLUMN: FlexDirection.Column,
+  FLEX_DIRECTION_COLUMN_REVERSE: FlexDirection.ColumnReverse,
+  FLEX_DIRECTION_ROW: FlexDirection.Row,
+  FLEX_DIRECTION_ROW_REVERSE: FlexDirection.RowReverse,
+  GUTTER_COLUMN: Gutter.Column,
+  GUTTER_ROW: Gutter.Row,
+  GUTTER_ALL: Gutter.All,
+  JUSTIFY_FLEX_START: Justify.FlexStart,
+  JUSTIFY_CENTER: Justify.Center,
+  JUSTIFY_FLEX_END: Justify.FlexEnd,
+  JUSTIFY_SPACE_BETWEEN: Justify.SpaceBetween,
+  JUSTIFY_SPACE_AROUND: Justify.SpaceAround,
+  JUSTIFY_SPACE_EVENLY: Justify.SpaceEvenly,
+  LOG_LEVEL_ERROR: LogLevel.Error,
+  LOG_LEVEL_WARN: LogLevel.Warn,
+  LOG_LEVEL_INFO: LogLevel.Info,
+  LOG_LEVEL_DEBUG: LogLevel.Debug,
+  LOG_LEVEL_VERBOSE: LogLevel.Verbose,
+  LOG_LEVEL_FATAL: LogLevel.Fatal,
+  MEASURE_MODE_UNDEFINED: MeasureMode.Undefined,
+  MEASURE_MODE_EXACTLY: MeasureMode.Exactly,
+  MEASURE_MODE_AT_MOST: MeasureMode.AtMost,
+  NODE_TYPE_DEFAULT: NodeType.Default,
+  NODE_TYPE_TEXT: NodeType.Text,
+  OVERFLOW_VISIBLE: Overflow.Visible,
+  OVERFLOW_HIDDEN: Overflow.Hidden,
+  OVERFLOW_SCROLL: Overflow.Scroll,
+  POSITION_TYPE_STATIC: PositionType.Static,
+  POSITION_TYPE_RELATIVE: PositionType.Relative,
+  POSITION_TYPE_ABSOLUTE: PositionType.Absolute,
+  UNIT_UNDEFINED: Unit.Undefined,
+  UNIT_POINT: Unit.Point,
+  UNIT_PERCENT: Unit.Percent,
+  UNIT_AUTO: Unit.Auto,
+  WRAP_NO_WRAP: Wrap.NoWrap,
+  WRAP_WRAP: Wrap.Wrap,
+  WRAP_WRAP_REVERSE: Wrap.WrapReverse,
+}
+export default constants