rescript-polished 1.15.0 → 2.1.0

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "rescript-polished",
-  "version": "1.15.0",
+  "version": "2.1.0",
+  "type": "module",
   "description": "ReScript bindings for polished.",
   "main": "dist/index.js",
   "repository": "https://github.com/brnrdog/rescript-polished",
@@ -16,29 +17,32 @@
     "colour",
     "styled-components"
   ],
+  "release": {
+    "branches": [
+      "main"
+    ]
+  },
   "scripts": {
-    "res:start": "bsb -make-world -w",
-    "res:build": "bsb -make-world",
-    "res:clean": "bsb -clean-world",
-    "test": "jest",
-    "test:ci": "jest --collect-coverage"
+    "res:start": "rescript build -w",
+    "res:build": "rescript build",
+    "res:clean": "rescript clean",
+    "test": "rescript build && node lib/bs/__tests__/RunTests.res.js",
+    "test:ci": "rescript build && node lib/bs/__tests__/RunTests.res.js"
   },
   "dependencies": {
-    "bs-css": "^13.4.0",
-    "bs-platform": "^9.0.1",
-    "polished": "^4.0.3"
+    "bs-css": "^18.1.1",
+    "polished": "^4.0.3",
+    "rescript": "^12.0.2"
   },
   "devDependencies": {
-    "@glennsl/bs-jest": "^0.7.0",
-    "jest": "^26.6.3",
-    "semantic-release": "^17.2.2"
-  },
-  "jest": {
-    "collectCoverageFrom": [
-      "<rootDir>/lib/js/src/**/*.js",
-      "!<rootDir>/lib/js/src/Polished.js",
-      "!<rootDir>/lib/js/src/PolishedCss.js"
-    ],
-    "verbose": true
+    "@commitlint/cli": "^20.1.0",
+    "@commitlint/config-conventional": "^20.0.0",
+    "@rescript/core": "^1.6.1",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^12.0.2",
+    "@semantic-release/npm": "^13.1.2",
+    "husky": "^9.1.7",
+    "semantic-release": "^25.0.2"
   }
 }

package/{bsconfig.json → rescript.json}

@@ -1,6 +1,5 @@
 {
   "name": "rescript-polished",
-  "version": "0.0.0-semantic-released",
   "sources": [
     {
       "dir": "src",
@@ -11,8 +10,13 @@
       "type": "dev"
     }
   ],
-  "bs-dev-dependencies": ["@glennsl/bs-jest"],
-  "bs-dependencies": ["bs-css"],
+  "package-specs": [
+    {
+      "module": "es6"
+    }
+  ],
+  "suffix": ".res.js",
+  "dependencies": ["bs-css"],
   "warnings": {
     "error": "+101"
   }

package/src/PolishedCss__Color.res

@@ -1,26 +1,26 @@
 module Utils = {
-  open Css_AtomicTypes
+  module StdFloat = Float
+  module StdInt = Int
 
   module Rgba = {
-    let regex = "rgba\(\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*\.\d+(?=%))\s*,\s*(-?\d+|-?\d*.\d+)\s*\)"
-    let rgbaRegexGroups = (_, i) => [1, 2, 3, 4]->Js.Array2.includes(i)
-    let rgbValue = v => v->Js.Nullable.toOption->Belt.Option.getExn->int_of_string
-    let alphaValue = v => v->Js.Nullable.toOption->Belt.Option.getUnsafe->float_of_string
+    let regex = "rgba\\(\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*\\.\\d+(?=%))\\s*,\\s*(-?\\d+|-?\\d*\\.\\d+)\\s*\\)"
+    let rgbValue = v => v->StdInt.fromString->Belt.Option.getExn
+    let alphaValue = v => v->StdFloat.fromString->Belt.Option.getExn
+
+    @get_index external unsafeGet: (RegExp.Result.t, int) => string = ""
 
     let fromString = string => {
-      let result = regex->Js.Re.fromString->Js.Re.exec_(string)
+      let result = regex->RegExp.fromString->RegExp.exec(string)
 
       switch result {
       | None => None
       | Some(result) => {
-          let values = result->Js.Re.captures->Js.Array2.filteri(rgbaRegexGroups)
-
-          let red = values->Array.get(0)->rgbValue
-          let green = values->Array.get(1)->rgbValue
-          let blue = values->Array.get(2)->rgbValue
-          let alpha = values->Array.get(3)->alphaValue
+          let red = result->unsafeGet(1)->rgbValue
+          let green = result->unsafeGet(2)->rgbValue
+          let blue = result->unsafeGet(3)->rgbValue
+          let alpha = result->unsafeGet(4)->alphaValue
 
-          Some(Color.rgba(red, green, blue, #num(alpha)))
+          Some(Css_Js_Core.Types.Color.rgba(red, green, blue, #num(alpha)))
         }
       }
     }
@@ -28,13 +28,13 @@ module Utils = {
 
   module Hex = {
     let fromString = string =>
-      #hex(string->Js.String2.slice(~from=1, ~to_=Js.String.length(string)))
+      #hex(string->String.slice(~start=1, ~end=String.length(string)))
   }
 
-  let toString = Color.toString
+  let toString = Css_Js_Core.Types.Color.toString
 
   let fromString = string => {
-    switch string->Js.String2.slice(~from=0, ~to_=4) {
+    switch string->String.slice(~start=0, ~end=4) {
     | "rgba" => string->Rgba.fromString->Belt.Option.getExn
     | _ => string->Hex.fromString
     }

package/src/Polished__Color.res

@@ -10,19 +10,19 @@ type rgbaColor = {"red": int, "green": int, "blue": int, "alpha": float}
 
 @module("polished")
 external shade: (float, color) => color = "shade"
-let shade = (color, ~amount) => color |> shade(amount)
+let shade = (color, ~amount) =>  shade(amount, color)
 
 @module("polished")
 external tint: (float, color) => color = "tint"
-let tint = (color, ~amount) => color |> tint(amount)
+let tint = (color, ~amount) => tint(amount, color)
 
 @module("polished")
 external lighten: (float, color) => color = "lighten"
-let lighten = (color, ~amount) => color |> lighten(amount)
+let lighten = (color, ~amount) => lighten(amount, color)
 
 @module("polished")
 external darken: (float, color) => color = "darken"
-let darken = (color, ~amount) => color |> darken(amount)
+let darken = (color, ~amount) => darken(amount, color)
 
 @module("polished")
 external hsl: (float, float, float) => color = "hsl"
@@ -30,7 +30,7 @@ let hsl = (~hue, ~saturation, ~lightness) => hsl(hue, saturation, lightness)
 
 @module("polished")
 external extAdjustHue: (float, color) => color = "adjustHue"
-let adjustHue = (color, ~degree) => color |> extAdjustHue(degree)
+let adjustHue = (color, ~degree) => extAdjustHue(degree, color)
 
 @module("polished")
 external complement: color => color = "complement"
@@ -38,7 +38,7 @@ let complement = complement
 
 @module("polished")
 external desaturate: (float, color) => color = "desaturate"
-let desaturate = (color, ~amount) => color |> desaturate(amount)
+let desaturate = (color, ~amount) => desaturate(amount, color)
 
 @module("polished")
 external getContrast: (color, color) => float = "getContrast"
@@ -66,7 +66,7 @@ let meetsContrastGuidelines = meetsContrastGuidelines
 
 @module("polished")
 external extTransparentize: (float, color) => color = "transparentize"
-let transparentize = (color, ~amount) => color |> extTransparentize(amount)
+let transparentize = (color, ~amount) => extTransparentize(amount, color)
 
 @module("polished")
 external hslToColorString: hslColor => color = "hslToColorString"
@@ -74,11 +74,11 @@ let hslToColorString = hslToColorString
 
 @module("polished")
 external mix: (float, color, color) => color = "mix"
-let mix = (color1, color2, ~weight) => color2 |> mix(weight, color1)
+let mix = (color1, color2, ~weight) => mix(weight, color1, color2)
 
 @module("polished")
 external opacify: (float, color) => color = "opacify"
-let opacify = (color, ~amount) => color |> opacify(amount)
+let opacify = (color, ~amount) => opacify(amount, color)
 
 @module("polished")
 external parseToHsl: color => hslColor = "parseToHsl"
@@ -90,7 +90,7 @@ let parseToRgb = parseToRgb
 
 @module("polished")
 external readableColor: (color, color, color, bool) => color = "readableColor"
-let readableColor = (color, ~lightReturnColor="#fff", ~darkReturnColor="#000", ~strict=true, ()) =>
+let readableColor = (color, ~lightReturnColor="#000", ~darkReturnColor="#fff", ~strict=true, ()) =>
   readableColor(color, lightReturnColor, darkReturnColor, strict)
 
 @module("polished")
@@ -103,16 +103,16 @@ let rgba = rgba
 
 @module("polished")
 external saturate: (float, color) => color = "saturate"
-let saturate = (color, ~amount) => color |> saturate(amount)
+let saturate = (color, ~amount) => saturate(amount, color)
 
 @module("polished")
 external setHue: (int, color) => color = "setHue"
-let setHue = (color, ~hue) => color |> setHue(hue)
+let setHue = (color, ~hue) => setHue(hue, color)
 
 @module("polished")
 external setLightness: (float, color) => color = "setLightness"
-let setLightness = (color, ~lightness) => color |> setLightness(lightness)
+let setLightness = (color, ~lightness) => setLightness(lightness, color)
 
 @module("polished")
 external setSaturation: (float, color) => color = "setSaturation"
-let setSaturation = (color, ~saturation) => color |> setSaturation(saturation)
+let setSaturation = (color, ~saturation) => setSaturation(saturation, color)

package/src/Polished__Mixins.res

@@ -26,37 +26,37 @@ external clearFix: option<string> => 'styles = "clearFix"
 let clearFix = (~parent=?) => parent->clearFix
 
 @module("polished")
-external cover: (~offset: Js.undefined<Size.t>) => 'styles = "cover"
-let cover = (~offset=?, ()) => cover(~offset=Js.Undefined.fromOption(offset))
+external cover: (~offset: Nullable.t<Size.t>) => 'styles = "cover"
+let cover = (~offset=?, ()) => cover(~offset=Nullable.fromOption(offset))
 
 @module("polished")
-external ellipsis: (~width: Js.undefined<Size.t>, ~lines: option<int>) => 'styles = "ellipsis"
+external ellipsis: (~width: Nullable.t<Size.t>, ~lines: option<int>) => 'styles = "ellipsis"
 let ellipsis = (~width=?, ~lines=?, ()) => {
-  ellipsis(~width=Js.Undefined.fromOption(width), ~lines)
+  ellipsis(~width=Nullable.fromOption(width), ~lines)
 }
 
 @module("polished")
 external fluidRange: (
   fluidRangeConfiguration,
-  ~minScreen: Js.undefined<string>,
-  ~maxScreen: Js.undefined<string>,
+  ~minScreen: Nullable.t<string>,
+  ~maxScreen: Nullable.t<string>,
 ) => 'styles = "fluidRange"
 let fluidRange = (~minScreen=?, ~maxScreen=?, cssProp) =>
   fluidRange(
     cssProp,
-    ~minScreen=Js.Undefined.fromOption(minScreen),
-    ~maxScreen=Js.Undefined.fromOption(maxScreen),
+    ~minScreen=Nullable.fromOption(minScreen),
+    ~maxScreen=Nullable.fromOption(maxScreen),
   )
 
 @module("polished")
 external fluidRangeWithArray: (
   array<fluidRangeConfiguration>,
-  ~minScreen: Js.undefined<string>,
-  ~maxScreen: Js.undefined<string>,
+  ~minScreen: Nullable.t<string>,
+  ~maxScreen: Nullable.t<string>,
 ) => 'styles = "fluidRange"
 let fluidRangeWithArray = (~minScreen=?, ~maxScreen=?, cssProps) =>
   fluidRangeWithArray(
     cssProps,
-    ~minScreen=Js.Undefined.fromOption(minScreen),
-    ~maxScreen=Js.Undefined.fromOption(maxScreen),
+    ~minScreen=Nullable.fromOption(minScreen),
+    ~maxScreen=Nullable.fromOption(maxScreen),
   )

package/lib/js/__tests__/PolishedCssTest.js

@@ -1,171 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Jest = require("@glennsl/bs-jest/lib/js/src/jest.js");
-var Curry = require("bs-platform/lib/js/curry.js");
-var Css_AtomicTypes = require("bs-css/lib/js/src/Css_AtomicTypes.js");
-var PolishedCss__Color = require("../src/PolishedCss__Color.js");
-
-function toEqual(x, y) {
-  return Jest.Expect.toEqual(y, x);
-}
-
-Jest.describe("Color", (function (param) {
-        Jest.test("shade with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.shade({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "bf0000"
-                          }, x);
-              }));
-        Jest.test("shade with rgb", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.shade(Css_AtomicTypes.Color.rgb(255, 0, 0), 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "bf0000"
-                          }, x);
-              }));
-        Jest.test("shade with rgba", (function (param) {
-                var y = Css_AtomicTypes.Color.rgba(76, 0, 0, {
-                      NAME: "num",
-                      VAL: 0.4375
-                    });
-                var x = Jest.Expect.expect(PolishedCss__Color.shade(Css_AtomicTypes.Color.rgba(255, 0, 0, {
-                              NAME: "num",
-                              VAL: 0.25
-                            }), 0.25));
-                return Jest.Expect.toEqual(y, x);
-              }));
-        Jest.test("tint with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.tint({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff3f3f"
-                          }, x);
-              }));
-        Jest.test("tint with rgb", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.tint(Css_AtomicTypes.Color.rgb(255, 0, 0), 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff3f3f"
-                          }, x);
-              }));
-        Jest.test("darken with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.darken({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "800000"
-                          }, x);
-              }));
-        Jest.test("lighten with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.lighten({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.25));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff8080"
-                          }, x);
-              }));
-        Jest.test("transparentize with hex", (function (param) {
-                var y = Curry._1(PolishedCss__Color.Utils.Rgba.fromString, "rgba(255, 0, 0, 0.5)");
-                var x = Jest.Expect.expect(PolishedCss__Color.transparentize({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.5));
-                return Jest.Expect.toEqual(y, x);
-              }));
-        Jest.test("getContrast with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.getContrast({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, {
-                          NAME: "hex",
-                          VAL: "0000ff"
-                        }));
-                return Jest.Expect.toEqual(2.16, x);
-              }));
-        Jest.test("getLuminance with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.getLuminance({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }));
-                return Jest.Expect.toEqual(0.213, x);
-              }));
-        Jest.test("grayscale with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.grayscale({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "808080"
-                          }, x);
-              }));
-        Jest.test("desaturate with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.desaturate({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.3));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "d92626"
-                          }, x);
-              }));
-        Jest.test("complement with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.complement({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "0ff"
-                          }, x);
-              }));
-        Jest.test("adjustHue with hex", (function (param) {
-                var x = Jest.Expect.expect(PolishedCss__Color.adjustHue({
-                          NAME: "hex",
-                          VAL: "ff0000"
-                        }, 0.3));
-                return Jest.Expect.toEqual({
-                            NAME: "hex",
-                            VAL: "ff0100"
-                          }, x);
-              }));
-        return Jest.describe("Utils", (function (param) {
-                      Jest.test("fromString with hex", (function (param) {
-                              var x = Jest.Expect.expect(PolishedCss__Color.Utils.fromString("#ff0000"));
-                              return Jest.Expect.toEqual({
-                                          NAME: "hex",
-                                          VAL: "ff0000"
-                                        }, x);
-                            }));
-                      return Jest.test("fromString with rgba", (function (param) {
-                                    var x = Jest.Expect.expect(PolishedCss__Color.Utils.fromString("rgba(255, 0, 0, 0.5)"));
-                                    return Jest.Expect.toEqual({
-                                                NAME: "rgba",
-                                                VAL: [
-                                                  255,
-                                                  0,
-                                                  0,
-                                                  {
-                                                    NAME: "num",
-                                                    VAL: 0.5
-                                                  }
-                                                ]
-                                              }, x);
-                                  }));
-                    }));
-      }));
-
-exports.toEqual = toEqual;
-/*  Not a pure module */

package/lib/js/__tests__/PolishedTest.js

@@ -1,183 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-'use strict';
-
-var Jest = require("@glennsl/bs-jest/lib/js/src/jest.js");
-var Caml_option = require("bs-platform/lib/js/caml_option.js");
-var Polished__Math = require("../src/Polished__Math.js");
-var Polished__Color = require("../src/Polished__Color.js");
-var Polished__Mixins = require("../src/Polished__Mixins.js");
-
-function keepGoing(param) {
-  
-}
-
-Jest.describe("Color", (function (param) {
-        Jest.test("shade", (function (param) {
-                return Jest.Expect.toBe("#b13c3c", Jest.Expect.expect(Polished__Color.shade("#ed5051", 0.25)));
-              }));
-        Jest.test("tint", (function (param) {
-                return Jest.Expect.toBe("#f17b7c", Jest.Expect.expect(Polished__Color.tint("#ed5051", 0.25)));
-              }));
-        Jest.test("lighten", (function (param) {
-                return Jest.Expect.toBe("#f9c4c4", Jest.Expect.expect(Polished__Color.lighten("#ed5051", 0.25)));
-              }));
-        Jest.test("darken", (function (param) {
-                return Jest.Expect.toBe("#ac1213", Jest.Expect.expect(Polished__Color.darken("#ed5051", 0.25)));
-              }));
-        Jest.test("hsl", (function (param) {
-                return Jest.Expect.toBe("#734d26", Jest.Expect.expect(Polished__Color.hsl(30, 0.5, 0.3)));
-              }));
-        Jest.test("adjustHue", (function (param) {
-                return Jest.Expect.toBe("#ed9f50", Jest.Expect.expect(Polished__Color.adjustHue("#ed5051", 30.5)));
-              }));
-        Jest.test("complement", (function (param) {
-                return Jest.Expect.toBe("#50edec", Jest.Expect.expect(Polished__Color.complement("#ed5051")));
-              }));
-        Jest.test("desaturate", (function (param) {
-                return Jest.Expect.toBe("#9f9f9f", Jest.Expect.expect(Polished__Color.desaturate("#ed5051", 25.5)));
-              }));
-        Jest.test("getContrast", (function (param) {
-                return Jest.Expect.toBe(3.58, Jest.Expect.expect(Polished__Color.getContrast("#ed5051", "#fff")));
-              }));
-        Jest.test("getLuminance", (function (param) {
-                return Jest.Expect.toBe(0.243, Jest.Expect.expect(Polished__Color.getLuminance("#ed5051")));
-              }));
-        Jest.test("grayscale", (function (param) {
-                return Jest.Expect.toBe("#9f9f9f", Jest.Expect.expect(Polished__Color.grayscale("#ed5051")));
-              }));
-        Jest.test("hsla", (function (param) {
-                return Jest.Expect.toBe("rgba(96,159,106,0.5)", Jest.Expect.expect(Polished__Color.hsla(130, 0.25, 0.5, 0.5)));
-              }));
-        Jest.test("invert", (function (param) {
-                return Jest.Expect.toBe("#12a6ae", Jest.Expect.expect(Polished__Color.invert("#ed5951")));
-              }));
-        Jest.test("meetsContrastGuidelines", (function (param) {
-                var expected = {
-                  AA: true,
-                  AALarge: true,
-                  AAA: true,
-                  AAALarge: true
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.meetsContrastGuidelines("#000000", "#ffffff")));
-              }));
-        Jest.test("transparentize", (function (param) {
-                return Jest.Expect.toBe("rgba(237,80,81,0.5)", Jest.Expect.expect(Polished__Color.transparentize("#ed5051", 0.5)));
-              }));
-        Jest.test("hslToColorString", (function (param) {
-                var hsl = {
-                  hue: 240,
-                  lightness: 1.0,
-                  saturation: 0.5
-                };
-                return Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.hslToColorString(hsl)));
-              }));
-        Jest.test("mix", (function (param) {
-                return Jest.Expect.toBe("#c58383", Jest.Expect.expect(Polished__Color.mix("#ed5051", "#bc9090", 0.2)));
-              }));
-        Jest.test("opacify", (function (param) {
-                return Jest.Expect.toBe("rgba(237,80,81,0.5)", Jest.Expect.expect(Polished__Color.opacify("#ed505100", 0.5)));
-              }));
-        Jest.test("parseToHsl", (function (param) {
-                var expected = {
-                  hue: 0.0,
-                  lightness: 0.5,
-                  saturation: 1.0
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.parseToHsl("#FF0000")));
-              }));
-        Jest.test("parseToRgb", (function (param) {
-                var expected = {
-                  red: 237,
-                  green: 80,
-                  blue: 81
-                };
-                return Jest.Expect.toEqual(expected, Jest.Expect.expect(Polished__Color.parseToRgb("#ed5051")));
-              }));
-        Jest.test("readableColor", (function (param) {
-                Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.readableColor("#ed5051", undefined, undefined, false, undefined)));
-                Jest.Expect.toBe("#000", Jest.Expect.expect(Polished__Color.readableColor("#000", undefined, undefined, undefined, undefined)));
-                Jest.Expect.toBe("#ff8", Jest.Expect.expect(Polished__Color.readableColor("black", undefined, "#ff8", undefined, undefined)));
-                Jest.Expect.toBe("#001", Jest.Expect.expect(Polished__Color.readableColor("white", "#001", undefined, undefined, undefined)));
-                Jest.Expect.toBe("#000", Jest.Expect.expect(Polished__Color.readableColor("red", "#333", "#ddd", true, undefined)));
-                Jest.Expect.toBe("#333", Jest.Expect.expect(Polished__Color.readableColor("yellow", "#333", "#ddd", true, undefined)));
-                return Jest.Expect.toBe("#ddd", Jest.Expect.expect(Polished__Color.readableColor("blue", "#333", "#ddd", true, undefined)));
-              }));
-        Jest.test("rgb", (function (param) {
-                var subject = {
-                  red: 255,
-                  green: 255,
-                  blue: 255
-                };
-                return Jest.Expect.toBe("#fff", Jest.Expect.expect(Polished__Color.rgb(subject)));
-              }));
-        Jest.test("rgba", (function (param) {
-                var subject = {
-                  red: 255,
-                  green: 205,
-                  blue: 100,
-                  alpha: 0.7
-                };
-                return Jest.Expect.toBe("rgba(255,205,100,0.7)", Jest.Expect.expect(Polished__Color.rgba(subject)));
-              }));
-        Jest.test("saturate", (function (param) {
-                return Jest.Expect.toBe("#ff3e3f", Jest.Expect.expect(Polished__Color.saturate("#ed5051", 0.5)));
-              }));
-        Jest.test("setHue", (function (param) {
-                return Jest.Expect.toBe("#cdae64", Jest.Expect.expect(Polished__Color.setHue("#CCCD64", 42)));
-              }));
-        Jest.test("setLightness", (function (param) {
-                return Jest.Expect.toBe("#4d4d19", Jest.Expect.expect(Polished__Color.setLightness("#CCCD64", 0.2)));
-              }));
-        return Jest.test("setSaturation", (function (param) {
-                      return Jest.Expect.toBe("#adad84", Jest.Expect.expect(Polished__Color.setSaturation("#CCCD64", 0.2)));
-                    }));
-      }));
-
-Jest.describe("Math", (function (param) {
-        return Jest.test("math", (function (param) {
-                      Jest.Expect.toBe("20px", Jest.Expect.expect(Polished__Math.math("12px + 8px", undefined)));
-                      Jest.Expect.toBe("20rem", Jest.Expect.expect(Polished__Math.math("12rem + 8rem", undefined)));
-                      return Jest.Expect.toThrow(Jest.Expect.expect(function (param) {
-                                      return Polished__Math.math("10px + 8rem", param);
-                                    }));
-                    }));
-      }));
-
-Jest.describe("Mixins", (function (param) {
-        Jest.test("between", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.between("400px", "1000px", Polished__Mixins.Size.makeString("16px"), Polished__Mixins.Size.makeString("100px"), undefined)));
-              }));
-        Jest.test("clearfix", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.clearFix("div")));
-              }));
-        Jest.test("cover", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.cover(Caml_option.some(Polished__Mixins.Size.makeString("16px")), undefined)));
-              }));
-        Jest.test("ellipsis", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.ellipsis(Caml_option.some(Polished__Mixins.Size.makeString("16px")), 10, undefined)));
-              }));
-        Jest.test("fluidRange", (function (param) {
-                return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.fluidRange("320px", "1024px", {
-                                    prop: "padding",
-                                    fromSize: Polished__Mixins.Size.makeString("20px"),
-                                    toSize: Polished__Mixins.Size.makeString("20px")
-                                  })));
-              }));
-        return Jest.test("fluidRangeWithArray", (function (param) {
-                      return Jest.Expect.toMatchSnapshot(Jest.Expect.expect(Polished__Mixins.fluidRangeWithArray("320px", "1024px", [
-                                          {
-                                            prop: "padding",
-                                            fromSize: Polished__Mixins.Size.makeString("16px"),
-                                            toSize: Polished__Mixins.Size.makeString("32px")
-                                          },
-                                          {
-                                            prop: "margin",
-                                            fromSize: Polished__Mixins.Size.makeString("16px"),
-                                            toSize: Polished__Mixins.Size.makeString("32px")
-                                          }
-                                        ])));
-                    }));
-      }));
-
-exports.keepGoing = keepGoing;
-/*  Not a pure module */