Changeset 2040171

Timestamp:

02/26/2019 10:34:41 PM (7 years ago)

Author:

dwayneparton

Message:

Added color brightness class and background color class.

Location:

gecko-grid-layout/trunk

Files:

• dist/editor-styles.css (modified) (3 diffs)
• dist/editor.bundle.js (modified) (17 diffs)
• gecko-grid-layout.php (modified) (3 diffs)
• readme.txt (modified) (2 diffs)

gecko-grid-layout/trunk/dist/editor-styles.css

@@ -101 +101 @@
 
 .wp-block-gecko-grid-layout-type-select {
-  background-color: white;
   display: -webkit-box;
   display: -ms-flexbox;
@@ -110 +109 @@
 .wp-block-gecko-grid-layout-type-select__item {
   font-size: 0.75rem;
-  line-height: 1.2rem;
+  line-height: 1.2em;
   display: -webkit-box;
   display: -ms-flexbox;
@@ -141 +140 @@
 }
 
-/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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*/
+/*# sourceMappingURL=data:application/json;charset=utf-8;base64,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*/

gecko-grid-layout/trunk/dist/editor.bundle.js

@@ -87 +87 @@
 /******/ ({
 
+/***/ "./node_modules/tinycolor2/tinycolor.js":
+/*!**********************************************!*\
+  !*** ./node_modules/tinycolor2/tinycolor.js ***!
+  \**********************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+var __WEBPACK_AMD_DEFINE_RESULT__;// TinyColor v1.4.1
+// https://github.com/bgrins/TinyColor
+// Brian Grinstead, MIT License
+
+(function(Math) {
+
+var trimLeft = /^\s+/,
+    trimRight = /\s+$/,
+    tinyCounter = 0,
+    mathRound = Math.round,
+    mathMin = Math.min,
+    mathMax = Math.max,
+    mathRandom = Math.random;
+
+function tinycolor (color, opts) {
+
+    color = (color) ? color : '';
+    opts = opts || { };
+
+    // If input is already a tinycolor, return itself
+    if (color instanceof tinycolor) {
+       return color;
+    }
+    // If we are called as a function, call using new instead
+    if (!(this instanceof tinycolor)) {
+        return new tinycolor(color, opts);
+    }
+
+    var rgb = inputToRGB(color);
+    this._originalInput = color,
+    this._r = rgb.r,
+    this._g = rgb.g,
+    this._b = rgb.b,
+    this._a = rgb.a,
+    this._roundA = mathRound(100*this._a) / 100,
+    this._format = opts.format || rgb.format;
+    this._gradientType = opts.gradientType;
+
+    // Don't let the range of [0,255] come back in [0,1].
+    // Potentially lose a little bit of precision here, but will fix issues where
+    // .5 gets interpreted as half of the total, instead of half of 1
+    // If it was supposed to be 128, this was already taken care of by `inputToRgb`
+    if (this._r < 1) { this._r = mathRound(this._r); }
+    if (this._g < 1) { this._g = mathRound(this._g); }
+    if (this._b < 1) { this._b = mathRound(this._b); }
+
+    this._ok = rgb.ok;
+    this._tc_id = tinyCounter++;
+}
+
+tinycolor.prototype = {
+    isDark: function() {
+        return this.getBrightness() < 128;
+    },
+    isLight: function() {
+        return !this.isDark();
+    },
+    isValid: function() {
+        return this._ok;
+    },
+    getOriginalInput: function() {
+      return this._originalInput;
+    },
+    getFormat: function() {
+        return this._format;
+    },
+    getAlpha: function() {
+        return this._a;
+    },
+    getBrightness: function() {
+        //http://www.w3.org/TR/AERT#color-contrast
+        var rgb = this.toRgb();
+        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;
+    },
+    getLuminance: function() {
+        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+        var rgb = this.toRgb();
+        var RsRGB, GsRGB, BsRGB, R, G, B;
+        RsRGB = rgb.r/255;
+        GsRGB = rgb.g/255;
+        BsRGB = rgb.b/255;
+
+        if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}
+        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}
+        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}
+        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);
+    },
+    setAlpha: function(value) {
+        this._a = boundAlpha(value);
+        this._roundA = mathRound(100*this._a) / 100;
+        return this;
+    },
+    toHsv: function() {
+        var hsv = rgbToHsv(this._r, this._g, this._b);
+        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };
+    },
+    toHsvString: function() {
+        var hsv = rgbToHsv(this._r, this._g, this._b);
+        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);
+        return (this._a == 1) ?
+          "hsv("  + h + ", " + s + "%, " + v + "%)" :
+          "hsva(" + h + ", " + s + "%, " + v + "%, "+ this._roundA + ")";
+    },
+    toHsl: function() {
+        var hsl = rgbToHsl(this._r, this._g, this._b);
+        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };
+    },
+    toHslString: function() {
+        var hsl = rgbToHsl(this._r, this._g, this._b);
+        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);
+        return (this._a == 1) ?
+          "hsl("  + h + ", " + s + "%, " + l + "%)" :
+          "hsla(" + h + ", " + s + "%, " + l + "%, "+ this._roundA + ")";
+    },
+    toHex: function(allow3Char) {
+        return rgbToHex(this._r, this._g, this._b, allow3Char);
+    },
+    toHexString: function(allow3Char) {
+        return '#' + this.toHex(allow3Char);
+    },
+    toHex8: function(allow4Char) {
+        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);
+    },
+    toHex8String: function(allow4Char) {
+        return '#' + this.toHex8(allow4Char);
+    },
+    toRgb: function() {
+        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };
+    },
+    toRgbString: function() {
+        return (this._a == 1) ?
+          "rgb("  + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ")" :
+          "rgba(" + mathRound(this._r) + ", " + mathRound(this._g) + ", " + mathRound(this._b) + ", " + this._roundA + ")";
+    },
+    toPercentageRgb: function() {
+        return { r: mathRound(bound01(this._r, 255) * 100) + "%", g: mathRound(bound01(this._g, 255) * 100) + "%", b: mathRound(bound01(this._b, 255) * 100) + "%", a: this._a };
+    },
+    toPercentageRgbString: function() {
+        return (this._a == 1) ?
+          "rgb("  + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%)" :
+          "rgba(" + mathRound(bound01(this._r, 255) * 100) + "%, " + mathRound(bound01(this._g, 255) * 100) + "%, " + mathRound(bound01(this._b, 255) * 100) + "%, " + this._roundA + ")";
+    },
+    toName: function() {
+        if (this._a === 0) {
+            return "transparent";
+        }
+
+        if (this._a < 1) {
+            return false;
+        }
+
+        return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;
+    },
+    toFilter: function(secondColor) {
+        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);
+        var secondHex8String = hex8String;
+        var gradientType = this._gradientType ? "GradientType = 1, " : "";
+
+        if (secondColor) {
+            var s = tinycolor(secondColor);
+            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);
+        }
+
+        return "progid:DXImageTransform.Microsoft.gradient("+gradientType+"startColorstr="+hex8String+",endColorstr="+secondHex8String+")";
+    },
+    toString: function(format) {
+        var formatSet = !!format;
+        format = format || this._format;
+
+        var formattedString = false;
+        var hasAlpha = this._a < 1 && this._a >= 0;
+        var needsAlphaFormat = !formatSet && hasAlpha && (format === "hex" || format === "hex6" || format === "hex3" || format === "hex4" || format === "hex8" || format === "name");
+
+        if (needsAlphaFormat) {
+            // Special case for "transparent", all other non-alpha formats
+            // will return rgba when there is transparency.
+            if (format === "name" && this._a === 0) {
+                return this.toName();
+            }
+            return this.toRgbString();
+        }
+        if (format === "rgb") {
+            formattedString = this.toRgbString();
+        }
+        if (format === "prgb") {
+            formattedString = this.toPercentageRgbString();
+        }
+        if (format === "hex" || format === "hex6") {
+            formattedString = this.toHexString();
+        }
+        if (format === "hex3") {
+            formattedString = this.toHexString(true);
+        }
+        if (format === "hex4") {
+            formattedString = this.toHex8String(true);
+        }
+        if (format === "hex8") {
+            formattedString = this.toHex8String();
+        }
+        if (format === "name") {
+            formattedString = this.toName();
+        }
+        if (format === "hsl") {
+            formattedString = this.toHslString();
+        }
+        if (format === "hsv") {
+            formattedString = this.toHsvString();
+        }
+
+        return formattedString || this.toHexString();
+    },
+    clone: function() {
+        return tinycolor(this.toString());
+    },
+
+    _applyModification: function(fn, args) {
+        var color = fn.apply(null, [this].concat([].slice.call(args)));
+        this._r = color._r;
+        this._g = color._g;
+        this._b = color._b;
+        this.setAlpha(color._a);
+        return this;
+    },
+    lighten: function() {
+        return this._applyModification(lighten, arguments);
+    },
+    brighten: function() {
+        return this._applyModification(brighten, arguments);
+    },
+    darken: function() {
+        return this._applyModification(darken, arguments);
+    },
+    desaturate: function() {
+        return this._applyModification(desaturate, arguments);
+    },
+    saturate: function() {
+        return this._applyModification(saturate, arguments);
+    },
+    greyscale: function() {
+        return this._applyModification(greyscale, arguments);
+    },
+    spin: function() {
+        return this._applyModification(spin, arguments);
+    },
+
+    _applyCombination: function(fn, args) {
+        return fn.apply(null, [this].concat([].slice.call(args)));
+    },
+    analogous: function() {
+        return this._applyCombination(analogous, arguments);
+    },
+    complement: function() {
+        return this._applyCombination(complement, arguments);
+    },
+    monochromatic: function() {
+        return this._applyCombination(monochromatic, arguments);
+    },
+    splitcomplement: function() {
+        return this._applyCombination(splitcomplement, arguments);
+    },
+    triad: function() {
+        return this._applyCombination(triad, arguments);
+    },
+    tetrad: function() {
+        return this._applyCombination(tetrad, arguments);
+    }
+};
+
+// If input is an object, force 1 into "1.0" to handle ratios properly
+// String input requires "1.0" as input, so 1 will be treated as 1
+tinycolor.fromRatio = function(color, opts) {
+    if (typeof color == "object") {
+        var newColor = {};
+        for (var i in color) {
+            if (color.hasOwnProperty(i)) {
+                if (i === "a") {
+                    newColor[i] = color[i];
+                }
+                else {
+                    newColor[i] = convertToPercentage(color[i]);
+                }
+            }
+        }
+        color = newColor;
+    }
+
+    return tinycolor(color, opts);
+};
+
+// Given a string or object, convert that input to RGB
+// Possible string inputs:
+//
+//     "red"
+//     "#f00" or "f00"
+//     "#ff0000" or "ff0000"
+//     "#ff000000" or "ff000000"
+//     "rgb 255 0 0" or "rgb (255, 0, 0)"
+//     "rgb 1.0 0 0" or "rgb (1, 0, 0)"
+//     "rgba (255, 0, 0, 1)" or "rgba 255, 0, 0, 1"
+//     "rgba (1.0, 0, 0, 1)" or "rgba 1.0, 0, 0, 1"
+//     "hsl(0, 100%, 50%)" or "hsl 0 100% 50%"
+//     "hsla(0, 100%, 50%, 1)" or "hsla 0 100% 50%, 1"
+//     "hsv(0, 100%, 100%)" or "hsv 0 100% 100%"
+//
+function inputToRGB(color) {
+
+    var rgb = { r: 0, g: 0, b: 0 };
+    var a = 1;
+    var s = null;
+    var v = null;
+    var l = null;
+    var ok = false;
+    var format = false;
+
+    if (typeof color == "string") {
+        color = stringInputToObject(color);
+    }
+
+    if (typeof color == "object") {
+        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
+            rgb = rgbToRgb(color.r, color.g, color.b);
+            ok = true;
+            format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
+            s = convertToPercentage(color.s);
+            v = convertToPercentage(color.v);
+            rgb = hsvToRgb(color.h, s, v);
+            ok = true;
+            format = "hsv";
+        }
+        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
+            s = convertToPercentage(color.s);
+            l = convertToPercentage(color.l);
+            rgb = hslToRgb(color.h, s, l);
+            ok = true;
+            format = "hsl";
+        }
+
+        if (color.hasOwnProperty("a")) {
+            a = color.a;
+        }
+    }
+
+    a = boundAlpha(a);
+
+    return {
+        ok: ok,
+        format: color.format || format,
+        r: mathMin(255, mathMax(rgb.r, 0)),
+        g: mathMin(255, mathMax(rgb.g, 0)),
+        b: mathMin(255, mathMax(rgb.b, 0)),
+        a: a
+    };
+}
+
+
+// Conversion Functions
+// --------------------
+
+// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:
+// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>
+
+// `rgbToRgb`
+// Handle bounds / percentage checking to conform to CSS color spec
+// <http://www.w3.org/TR/css3-color/>
+// *Assumes:* r, g, b in [0, 255] or [0, 1]
+// *Returns:* { r, g, b } in [0, 255]
+function rgbToRgb(r, g, b){
+    return {
+        r: bound01(r, 255) * 255,
+        g: bound01(g, 255) * 255,
+        b: bound01(b, 255) * 255
+    };
+}
+
+// `rgbToHsl`
+// Converts an RGB color value to HSL.
+// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]
+// *Returns:* { h, s, l } in [0,1]
+function rgbToHsl(r, g, b) {
+
+    r = bound01(r, 255);
+    g = bound01(g, 255);
+    b = bound01(b, 255);
+
+    var max = mathMax(r, g, b), min = mathMin(r, g, b);
+    var h, s, l = (max + min) / 2;
+
+    if(max == min) {
+        h = s = 0; // achromatic
+    }
+    else {
+        var d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch(max) {
+            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+            case g: h = (b - r) / d + 2; break;
+            case b: h = (r - g) / d + 4; break;
+        }
+
+        h /= 6;
+    }
+
+    return { h: h, s: s, l: l };
+}
+
+// `hslToRgb`
+// Converts an HSL color value to RGB.
+// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]
+// *Returns:* { r, g, b } in the set [0, 255]
+function hslToRgb(h, s, l) {
+    var r, g, b;
+
+    h = bound01(h, 360);
+    s = bound01(s, 100);
+    l = bound01(l, 100);
+
+    function hue2rgb(p, q, t) {
+        if(t < 0) t += 1;
+        if(t > 1) t -= 1;
+        if(t < 1/6) return p + (q - p) * 6 * t;
+        if(t < 1/2) return q;
+        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;
+        return p;
+    }
+
+    if(s === 0) {
+        r = g = b = l; // achromatic
+    }
+    else {
+        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+        var p = 2 * l - q;
+        r = hue2rgb(p, q, h + 1/3);
+        g = hue2rgb(p, q, h);
+        b = hue2rgb(p, q, h - 1/3);
+    }
+
+    return { r: r * 255, g: g * 255, b: b * 255 };
+}
+
+// `rgbToHsv`
+// Converts an RGB color value to HSV
+// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]
+// *Returns:* { h, s, v } in [0,1]
+function rgbToHsv(r, g, b) {
+
+    r = bound01(r, 255);
+    g = bound01(g, 255);
+    b = bound01(b, 255);
+
+    var max = mathMax(r, g, b), min = mathMin(r, g, b);
+    var h, s, v = max;
+
+    var d = max - min;
+    s = max === 0 ? 0 : d / max;
+
+    if(max == min) {
+        h = 0; // achromatic
+    }
+    else {
+        switch(max) {
+            case r: h = (g - b) / d + (g < b ? 6 : 0); break;
+            case g: h = (b - r) / d + 2; break;
+            case b: h = (r - g) / d + 4; break;
+        }
+        h /= 6;
+    }
+    return { h: h, s: s, v: v };
+}
+
+// `hsvToRgb`
+// Converts an HSV color value to RGB.
+// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]
+// *Returns:* { r, g, b } in the set [0, 255]
+ function hsvToRgb(h, s, v) {
+
+    h = bound01(h, 360) * 6;
+    s = bound01(s, 100);
+    v = bound01(v, 100);
+
+    var i = Math.floor(h),
+        f = h - i,
+        p = v * (1 - s),
+        q = v * (1 - f * s),
+        t = v * (1 - (1 - f) * s),
+        mod = i % 6,
+        r = [v, q, p, p, t, v][mod],
+        g = [t, v, v, q, p, p][mod],
+        b = [p, p, t, v, v, q][mod];
+
+    return { r: r * 255, g: g * 255, b: b * 255 };
+}
+
+// `rgbToHex`
+// Converts an RGB color to hex
+// Assumes r, g, and b are contained in the set [0, 255]
+// Returns a 3 or 6 character hex
+function rgbToHex(r, g, b, allow3Char) {
+
+    var hex = [
+        pad2(mathRound(r).toString(16)),
+        pad2(mathRound(g).toString(16)),
+        pad2(mathRound(b).toString(16))
+    ];
+
+    // Return a 3 character hex if possible
+    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {
+        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
+    }
+
+    return hex.join("");
+}
+
+// `rgbaToHex`
+// Converts an RGBA color plus alpha transparency to hex
+// Assumes r, g, b are contained in the set [0, 255] and
+// a in [0, 1]. Returns a 4 or 8 character rgba hex
+function rgbaToHex(r, g, b, a, allow4Char) {
+
+    var hex = [
+        pad2(mathRound(r).toString(16)),
+        pad2(mathRound(g).toString(16)),
+        pad2(mathRound(b).toString(16)),
+        pad2(convertDecimalToHex(a))
+    ];
+
+    // Return a 4 character hex if possible
+    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {
+        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
+    }
+
+    return hex.join("");
+}
+
+// `rgbaToArgbHex`
+// Converts an RGBA color to an ARGB Hex8 string
+// Rarely used, but required for "toFilter()"
+function rgbaToArgbHex(r, g, b, a) {
+
+    var hex = [
+        pad2(convertDecimalToHex(a)),
+        pad2(mathRound(r).toString(16)),
+        pad2(mathRound(g).toString(16)),
+        pad2(mathRound(b).toString(16))
+    ];
+
+    return hex.join("");
+}
+
+// `equals`
+// Can be called with any tinycolor input
+tinycolor.equals = function (color1, color2) {
+    if (!color1 || !color2) { return false; }
+    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();
+};
+
+tinycolor.random = function() {
+    return tinycolor.fromRatio({
+        r: mathRandom(),
+        g: mathRandom(),
+        b: mathRandom()
+    });
+};
+
+
+// Modification Functions
+// ----------------------
+// Thanks to less.js for some of the basics here
+// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>
+
+function desaturate(color, amount) {
+    amount = (amount === 0) ? 0 : (amount || 10);
+    var hsl = tinycolor(color).toHsl();
+    hsl.s -= amount / 100;
+    hsl.s = clamp01(hsl.s);
+    return tinycolor(hsl);
+}
+
+function saturate(color, amount) {
+    amount = (amount === 0) ? 0 : (amount || 10);
+    var hsl = tinycolor(color).toHsl();
+    hsl.s += amount / 100;
+    hsl.s = clamp01(hsl.s);
+    return tinycolor(hsl);
+}
+
+function greyscale(color) {
+    return tinycolor(color).desaturate(100);
+}
+
+function lighten (color, amount) {
+    amount = (amount === 0) ? 0 : (amount || 10);
+    var hsl = tinycolor(color).toHsl();
+    hsl.l += amount / 100;
+    hsl.l = clamp01(hsl.l);
+    return tinycolor(hsl);
+}
+
+function brighten(color, amount) {
+    amount = (amount === 0) ? 0 : (amount || 10);
+    var rgb = tinycolor(color).toRgb();
+    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));
+    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));
+    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));
+    return tinycolor(rgb);
+}
+
+function darken (color, amount) {
+    amount = (amount === 0) ? 0 : (amount || 10);
+    var hsl = tinycolor(color).toHsl();
+    hsl.l -= amount / 100;
+    hsl.l = clamp01(hsl.l);
+    return tinycolor(hsl);
+}
+
+// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.
+// Values outside of this range will be wrapped into this range.
+function spin(color, amount) {
+    var hsl = tinycolor(color).toHsl();
+    var hue = (hsl.h + amount) % 360;
+    hsl.h = hue < 0 ? 360 + hue : hue;
+    return tinycolor(hsl);
+}
+
+// Combination Functions
+// ---------------------
+// Thanks to jQuery xColor for some of the ideas behind these
+// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>
+
+function complement(color) {
+    var hsl = tinycolor(color).toHsl();
+    hsl.h = (hsl.h + 180) % 360;
+    return tinycolor(hsl);
+}
+
+function triad(color) {
+    var hsl = tinycolor(color).toHsl();
+    var h = hsl.h;
+    return [
+        tinycolor(color),
+        tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),
+        tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })
+    ];
+}
+
+function tetrad(color) {
+    var hsl = tinycolor(color).toHsl();
+    var h = hsl.h;
+    return [
+        tinycolor(color),
+        tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),
+        tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),
+        tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })
+    ];
+}
+
+function splitcomplement(color) {
+    var hsl = tinycolor(color).toHsl();
+    var h = hsl.h;
+    return [
+        tinycolor(color),
+        tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),
+        tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})
+    ];
+}
+
+function analogous(color, results, slices) {
+    results = results || 6;
+    slices = slices || 30;
+
+    var hsl = tinycolor(color).toHsl();
+    var part = 360 / slices;
+    var ret = [tinycolor(color)];
+
+    for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {
+        hsl.h = (hsl.h + part) % 360;
+        ret.push(tinycolor(hsl));
+    }
+    return ret;
+}
+
+function monochromatic(color, results) {
+    results = results || 6;
+    var hsv = tinycolor(color).toHsv();
+    var h = hsv.h, s = hsv.s, v = hsv.v;
+    var ret = [];
+    var modification = 1 / results;
+
+    while (results--) {
+        ret.push(tinycolor({ h: h, s: s, v: v}));
+        v = (v + modification) % 1;
+    }
+
+    return ret;
+}
+
+// Utility Functions
+// ---------------------
+
+tinycolor.mix = function(color1, color2, amount) {
+    amount = (amount === 0) ? 0 : (amount || 50);
+
+    var rgb1 = tinycolor(color1).toRgb();
+    var rgb2 = tinycolor(color2).toRgb();
+
+    var p = amount / 100;
+
+    var rgba = {
+        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,
+        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,
+        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,
+        a: ((rgb2.a - rgb1.a) * p) + rgb1.a
+    };
+
+    return tinycolor(rgba);
+};
+
+
+// Readability Functions
+// ---------------------
+// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)
+
+// `contrast`
+// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)
+tinycolor.readability = function(color1, color2) {
+    var c1 = tinycolor(color1);
+    var c2 = tinycolor(color2);
+    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);
+};
+
+// `isReadable`
+// Ensure that foreground and background color combinations meet WCAG2 guidelines.
+// The third argument is an optional Object.
+//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';
+//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.
+// If the entire object is absent, isReadable defaults to {level:"AA",size:"small"}.
+
+// *Example*
+//    tinycolor.isReadable("#000", "#111") => false
+//    tinycolor.isReadable("#000", "#111",{level:"AA",size:"large"}) => false
+tinycolor.isReadable = function(color1, color2, wcag2) {
+    var readability = tinycolor.readability(color1, color2);
+    var wcag2Parms, out;
+
+    out = false;
+
+    wcag2Parms = validateWCAG2Parms(wcag2);
+    switch (wcag2Parms.level + wcag2Parms.size) {
+        case "AAsmall":
+        case "AAAlarge":
+            out = readability >= 4.5;
+            break;
+        case "AAlarge":
+            out = readability >= 3;
+            break;
+        case "AAAsmall":
+            out = readability >= 7;
+            break;
+    }
+    return out;
+
+};
+
+// `mostReadable`
+// Given a base color and a list of possible foreground or background
+// colors for that base, returns the most readable color.
+// Optionally returns Black or White if the most readable color is unreadable.
+// *Example*
+//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:false}).toHexString(); // "#112255"
+//    tinycolor.mostReadable(tinycolor.mostReadable("#123", ["#124", "#125"],{includeFallbackColors:true}).toHexString();  // "#ffffff"
+//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"large"}).toHexString(); // "#faf3f3"
+//    tinycolor.mostReadable("#a8015a", ["#faf3f3"],{includeFallbackColors:true,level:"AAA",size:"small"}).toHexString(); // "#ffffff"
+tinycolor.mostReadable = function(baseColor, colorList, args) {
+    var bestColor = null;
+    var bestScore = 0;
+    var readability;
+    var includeFallbackColors, level, size ;
+    args = args || {};
+    includeFallbackColors = args.includeFallbackColors ;
+    level = args.level;
+    size = args.size;
+
+    for (var i= 0; i < colorList.length ; i++) {
+        readability = tinycolor.readability(baseColor, colorList[i]);
+        if (readability > bestScore) {
+            bestScore = readability;
+            bestColor = tinycolor(colorList[i]);
+        }
+    }
+
+    if (tinycolor.isReadable(baseColor, bestColor, {"level":level,"size":size}) || !includeFallbackColors) {
+        return bestColor;
+    }
+    else {
+        args.includeFallbackColors=false;
+        return tinycolor.mostReadable(baseColor,["#fff", "#000"],args);
+    }
+};
+
+
+// Big List of Colors
+// ------------------
+// <http://www.w3.org/TR/css3-color/#svg-color>
+var names = tinycolor.names = {
+    aliceblue: "f0f8ff",
+    antiquewhite: "faebd7",
+    aqua: "0ff",
+    aquamarine: "7fffd4",
+    azure: "f0ffff",
+    beige: "f5f5dc",
+    bisque: "ffe4c4",
+    black: "000",
+    blanchedalmond: "ffebcd",
+    blue: "00f",
+    blueviolet: "8a2be2",
+    brown: "a52a2a",
+    burlywood: "deb887",
+    burntsienna: "ea7e5d",
+    cadetblue: "5f9ea0",
+    chartreuse: "7fff00",
+    chocolate: "d2691e",
+    coral: "ff7f50",
+    cornflowerblue: "6495ed",
+    cornsilk: "fff8dc",
+    crimson: "dc143c",
+    cyan: "0ff",
+    darkblue: "00008b",
+    darkcyan: "008b8b",
+    darkgoldenrod: "b8860b",
+    darkgray: "a9a9a9",
+    darkgreen: "006400",
+    darkgrey: "a9a9a9",
+    darkkhaki: "bdb76b",
+    darkmagenta: "8b008b",
+    darkolivegreen: "556b2f",
+    darkorange: "ff8c00",
+    darkorchid: "9932cc",
+    darkred: "8b0000",
+    darksalmon: "e9967a",
+    darkseagreen: "8fbc8f",
+    darkslateblue: "483d8b",
+    darkslategray: "2f4f4f",
+    darkslategrey: "2f4f4f",
+    darkturquoise: "00ced1",
+    darkviolet: "9400d3",
+    deeppink: "ff1493",
+    deepskyblue: "00bfff",
+    dimgray: "696969",
+    dimgrey: "696969",
+    dodgerblue: "1e90ff",
+    firebrick: "b22222",
+    floralwhite: "fffaf0",
+    forestgreen: "228b22",
+    fuchsia: "f0f",
+    gainsboro: "dcdcdc",
+    ghostwhite: "f8f8ff",
+    gold: "ffd700",
+    goldenrod: "daa520",
+    gray: "808080",
+    green: "008000",
+    greenyellow: "adff2f",
+    grey: "808080",
+    honeydew: "f0fff0",
+    hotpink: "ff69b4",
+    indianred: "cd5c5c",
+    indigo: "4b0082",
+    ivory: "fffff0",
+    khaki: "f0e68c",
+    lavender: "e6e6fa",
+    lavenderblush: "fff0f5",
+    lawngreen: "7cfc00",
+    lemonchiffon: "fffacd",
+    lightblue: "add8e6",
+    lightcoral: "f08080",
+    lightcyan: "e0ffff",
+    lightgoldenrodyellow: "fafad2",
+    lightgray: "d3d3d3",
+    lightgreen: "90ee90",
+    lightgrey: "d3d3d3",
+    lightpink: "ffb6c1",
+    lightsalmon: "ffa07a",
+    lightseagreen: "20b2aa",
+    lightskyblue: "87cefa",
+    lightslategray: "789",
+    lightslategrey: "789",
+    lightsteelblue: "b0c4de",
+    lightyellow: "ffffe0",
+    lime: "0f0",
+    limegreen: "32cd32",
+    linen: "faf0e6",
+    magenta: "f0f",
+    maroon: "800000",
+    mediumaquamarine: "66cdaa",
+    mediumblue: "0000cd",
+    mediumorchid: "ba55d3",
+    mediumpurple: "9370db",
+    mediumseagreen: "3cb371",
+    mediumslateblue: "7b68ee",
+    mediumspringgreen: "00fa9a",
+    mediumturquoise: "48d1cc",
+    mediumvioletred: "c71585",
+    midnightblue: "191970",
+    mintcream: "f5fffa",
+    mistyrose: "ffe4e1",
+    moccasin: "ffe4b5",
+    navajowhite: "ffdead",
+    navy: "000080",
+    oldlace: "fdf5e6",
+    olive: "808000",
+    olivedrab: "6b8e23",
+    orange: "ffa500",
+    orangered: "ff4500",
+    orchid: "da70d6",
+    palegoldenrod: "eee8aa",
+    palegreen: "98fb98",
+    paleturquoise: "afeeee",
+    palevioletred: "db7093",
+    papayawhip: "ffefd5",
+    peachpuff: "ffdab9",
+    peru: "cd853f",
+    pink: "ffc0cb",
+    plum: "dda0dd",
+    powderblue: "b0e0e6",
+    purple: "800080",
+    rebeccapurple: "663399",
+    red: "f00",
+    rosybrown: "bc8f8f",
+    royalblue: "4169e1",
+    saddlebrown: "8b4513",
+    salmon: "fa8072",
+    sandybrown: "f4a460",
+    seagreen: "2e8b57",
+    seashell: "fff5ee",
+    sienna: "a0522d",
+    silver: "c0c0c0",
+    skyblue: "87ceeb",
+    slateblue: "6a5acd",
+    slategray: "708090",
+    slategrey: "708090",
+    snow: "fffafa",
+    springgreen: "00ff7f",
+    steelblue: "4682b4",
+    tan: "d2b48c",
+    teal: "008080",
+    thistle: "d8bfd8",
+    tomato: "ff6347",
+    turquoise: "40e0d0",
+    violet: "ee82ee",
+    wheat: "f5deb3",
+    white: "fff",
+    whitesmoke: "f5f5f5",
+    yellow: "ff0",
+    yellowgreen: "9acd32"
+};
+
+// Make it easy to access colors via `hexNames[hex]`
+var hexNames = tinycolor.hexNames = flip(names);
+
+
+// Utilities
+// ---------
+
+// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`
+function flip(o) {
+    var flipped = { };
+    for (var i in o) {
+        if (o.hasOwnProperty(i)) {
+            flipped[o[i]] = i;
+        }
+    }
+    return flipped;
+}
+
+// Return a valid alpha value [0,1] with all invalid values being set to 1
+function boundAlpha(a) {
+    a = parseFloat(a);
+
+    if (isNaN(a) || a < 0 || a > 1) {
+        a = 1;
+    }
+
+    return a;
+}
+
+// Take input from [0, n] and return it as [0, 1]
+function bound01(n, max) {
+    if (isOnePointZero(n)) { n = "100%"; }
+
+    var processPercent = isPercentage(n);
+    n = mathMin(max, mathMax(0, parseFloat(n)));
+
+    // Automatically convert percentage into number
+    if (processPercent) {
+        n = parseInt(n * max, 10) / 100;
+    }
+
+    // Handle floating point rounding errors
+    if ((Math.abs(n - max) < 0.000001)) {
+        return 1;
+    }
+
+    // Convert into [0, 1] range if it isn't already
+    return (n % max) / parseFloat(max);
+}
+
+// Force a number between 0 and 1
+function clamp01(val) {
+    return mathMin(1, mathMax(0, val));
+}
+
+// Parse a base-16 hex value into a base-10 integer
+function parseIntFromHex(val) {
+    return parseInt(val, 16);
+}
+
+// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1
+// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>
+function isOnePointZero(n) {
+    return typeof n == "string" && n.indexOf('.') != -1 && parseFloat(n) === 1;
+}
+
+// Check to see if string passed in is a percentage
+function isPercentage(n) {
+    return typeof n === "string" && n.indexOf('%') != -1;
+}
+
+// Force a hex value to have 2 characters
+function pad2(c) {
+    return c.length == 1 ? '0' + c : '' + c;
+}
+
+// Replace a decimal with it's percentage value
+function convertToPercentage(n) {
+    if (n <= 1) {
+        n = (n * 100) + "%";
+    }
+
+    return n;
+}
+
+// Converts a decimal to a hex value
+function convertDecimalToHex(d) {
+    return Math.round(parseFloat(d) * 255).toString(16);
+}
+// Converts a hex value to a decimal
+function convertHexToDecimal(h) {
+    return (parseIntFromHex(h) / 255);
+}
+
+var matchers = (function() {
+
+    // <http://www.w3.org/TR/css3-values/#integers>
+    var CSS_INTEGER = "[-\\+]?\\d+%?";
+
+    // <http://www.w3.org/TR/css3-values/#number-value>
+    var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
+
+    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.
+    var CSS_UNIT = "(?:" + CSS_NUMBER + ")|(?:" + CSS_INTEGER + ")";
+
+    // Actual matching.
+    // Parentheses and commas are optional, but not required.
+    // Whitespace can take the place of commas or opening paren
+    var PERMISSIVE_MATCH3 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+    var PERMISSIVE_MATCH4 = "[\\s|\\(]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")[,|\\s]+(" + CSS_UNIT + ")\\s*\\)?";
+
+    return {
+        CSS_UNIT: new RegExp(CSS_UNIT),
+        rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
+        rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
+        hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
+        hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
+        hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
+        hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
+        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
+        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
+        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+    };
+})();
+
+// `isValidCSSUnit`
+// Take in a single string / number and check to see if it looks like a CSS unit
+// (see `matchers` above for definition).
+function isValidCSSUnit(color) {
+    return !!matchers.CSS_UNIT.exec(color);
+}
+
+// `stringInputToObject`
+// Permissive string parsing.  Take in a number of formats, and output an object
+// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`
+function stringInputToObject(color) {
+
+    color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();
+    var named = false;
+    if (names[color]) {
+        color = names[color];
+        named = true;
+    }
+    else if (color == 'transparent') {
+        return { r: 0, g: 0, b: 0, a: 0, format: "name" };
+    }
+
+    // Try to match string input using regular expressions.
+    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]
+    // Just return an object and let the conversion functions handle that.
+    // This way the result will be the same whether the tinycolor is initialized with string or object.
+    var match;
+    if ((match = matchers.rgb.exec(color))) {
+        return { r: match[1], g: match[2], b: match[3] };
+    }
+    if ((match = matchers.rgba.exec(color))) {
+        return { r: match[1], g: match[2], b: match[3], a: match[4] };
+    }
+    if ((match = matchers.hsl.exec(color))) {
+        return { h: match[1], s: match[2], l: match[3] };
+    }
+    if ((match = matchers.hsla.exec(color))) {
+        return { h: match[1], s: match[2], l: match[3], a: match[4] };
+    }
+    if ((match = matchers.hsv.exec(color))) {
+        return { h: match[1], s: match[2], v: match[3] };
+    }
+    if ((match = matchers.hsva.exec(color))) {
+        return { h: match[1], s: match[2], v: match[3], a: match[4] };
+    }
+    if ((match = matchers.hex8.exec(color))) {
+        return {
+            r: parseIntFromHex(match[1]),
+            g: parseIntFromHex(match[2]),
+            b: parseIntFromHex(match[3]),
+            a: convertHexToDecimal(match[4]),
+            format: named ? "name" : "hex8"
+        };
+    }
+    if ((match = matchers.hex6.exec(color))) {
+        return {
+            r: parseIntFromHex(match[1]),
+            g: parseIntFromHex(match[2]),
+            b: parseIntFromHex(match[3]),
+            format: named ? "name" : "hex"
+        };
+    }
+    if ((match = matchers.hex4.exec(color))) {
+        return {
+            r: parseIntFromHex(match[1] + '' + match[1]),
+            g: parseIntFromHex(match[2] + '' + match[2]),
+            b: parseIntFromHex(match[3] + '' + match[3]),
+            a: convertHexToDecimal(match[4] + '' + match[4]),
+            format: named ? "name" : "hex8"
+        };
+    }
+    if ((match = matchers.hex3.exec(color))) {
+        return {
+            r: parseIntFromHex(match[1] + '' + match[1]),
+            g: parseIntFromHex(match[2] + '' + match[2]),
+            b: parseIntFromHex(match[3] + '' + match[3]),
+            format: named ? "name" : "hex"
+        };
+    }
+
+    return false;
+}
+
+function validateWCAG2Parms(parms) {
+    // return valid WCAG2 parms for isReadable.
+    // If input parms are invalid, return {"level":"AA", "size":"small"}
+    var level, size;
+    parms = parms || {"level":"AA", "size":"small"};
+    level = (parms.level || "AA").toUpperCase();
+    size = (parms.size || "small").toLowerCase();
+    if (level !== "AA" && level !== "AAA") {
+        level = "AA";
+    }
+    if (size !== "small" && size !== "large") {
+        size = "small";
+    }
+    return {"level":level, "size":size};
+}
+
+// Node: Export function
+if ( true && module.exports) {
+    module.exports = tinycolor;
+}
+// AMD/requirejs: Define the module
+else if (true) {
+    !(__WEBPACK_AMD_DEFINE_RESULT__ = (function () {return tinycolor;}).call(exports, __webpack_require__, exports, module),
+                __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
+}
+// Browser: Expose to window
+else {}
+
+})(Math);
+
+
+/***/ }),
+
 /***/ "./src/grid-layout-item.js":
 /*!*********************************!*\
@@ -99 +1304 @@
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "settings", function() { return settings; });
 /* harmony import */ var _type_select__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./type-select */ "./src/type-select.js");
-/* harmony import */ var _wordpress_components__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! @wordpress/components */ "@wordpress/components");
-/* harmony import */ var _wordpress_components__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__);
-/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
-/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__);
-/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @wordpress/element */ "@wordpress/element");
-/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__);
-/* harmony import */ var _wordpress_editor__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @wordpress/editor */ "@wordpress/editor");
-/* harmony import */ var _wordpress_editor__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var tinycolor2__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tinycolor2 */ "./node_modules/tinycolor2/tinycolor.js");
+/* harmony import */ var tinycolor2__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(tinycolor2__WEBPACK_IMPORTED_MODULE_1__);
+/* harmony import */ var _wordpress_components__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @wordpress/components */ "@wordpress/components");
+/* harmony import */ var _wordpress_components__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__);
+/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
+/* harmony import */ var _wordpress_i18n__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__);
+/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! @wordpress/element */ "@wordpress/element");
+/* harmony import */ var _wordpress_element__WEBPACK_IMPORTED_MODULE_4___default = /*#__PURE__*/__webpack_require__.n(_wordpress_element__WEBPACK_IMPORTED_MODULE_4__);
+/* harmony import */ var _wordpress_editor__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! @wordpress/editor */ "@wordpress/editor");
+/* harmony import */ var _wordpress_editor__WEBPACK_IMPORTED_MODULE_5___default = /*#__PURE__*/__webpack_require__.n(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__);
+/* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! @wordpress/data */ "@wordpress/data");
+/* harmony import */ var _wordpress_data__WEBPACK_IMPORTED_MODULE_6___default = /*#__PURE__*/__webpack_require__.n(_wordpress_data__WEBPACK_IMPORTED_MODULE_6__);
+
 
 /**
@@ -116 +1326 @@
 
 
+
 var name = 'gecko/grid-layout-item';
 var settings = {
-  title: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__["__"])('Item'),
+  title: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__["__"])('Item'),
   parent: ['gecko/grid-layout'],
-  icon: React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["SVG"], {
+  icon: React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["SVG"], {
     xmlns: "http://www.w3.org/2000/svg",
     viewBox: "0 0 24 24"
-  }, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["Path"], {
+  }, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["Path"], {
     fill: "none",
     d: "M0 0h24v24H0V0z"
-  }), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["Path"], {
+  }), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["Path"], {
     d: "M11.99 18.54l-7.37-5.73L3 14.07l9 7 9-7-1.63-1.27zM12 16l7.36-5.73L21 9l-9-7-9 7 1.63 1.27L12 16zm0-11.47L17.74 9 12 13.47 6.26 9 12 4.53z"
   })),
-  description: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__["__"])('A single grid item within a grid block.'),
+  description: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__["__"])('A single grid item within a grid block.'),
   category: 'common',
   supports: {
@@ -153 +1364 @@
     w: {
       type: 'number',
-      default: 1
+      default: 4
     },
     bgMedia: {
@@ -163 +1374 @@
     bgColor: {
       type: 'string'
+    },
+    bgColorSlug: {
+      type: 'string'
+    },
+    bgColorBrightness: {
+      type: 'number' //light or dark
+
     }
   },
@@ -177 +1395 @@
         bgMedia = attributes.bgMedia,
         bgMediaUrl = attributes.bgMediaUrl,
-        bgColor = attributes.bgColor;
+        bgColor = attributes.bgColor,
+        bgColorBrightness = attributes.bgColorBrightness,
+        bgColorSlug = attributes.bgColorSlug;
     var styles = {
       '--background': bgColor,
@@ -195 +1415 @@
     }
 
-    return React.createElement(_wordpress_element__WEBPACK_IMPORTED_MODULE_3__["Fragment"], null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["InspectorControls"], null, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["PanelBody"], {
+    var lightOrDark = 'light';
+    if (bgColorBrightness < 130) lightOrDark = 'dark';
+    return React.createElement(_wordpress_element__WEBPACK_IMPORTED_MODULE_4__["Fragment"], null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["InspectorControls"], null, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["PanelBody"], {
       title: "Type"
     }, React.createElement(_type_select__WEBPACK_IMPORTED_MODULE_0__["default"], {
@@ -204 +1426 @@
       },
       value: type
-    })), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["PanelBody"], {
+    })), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["PanelBody"], {
       title: "Size Settings"
-    }, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["RangeControl"], {
-      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__["__"])('Height'),
+    }, React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["RangeControl"], {
+      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__["__"])('Height'),
       value: h,
       onChange: function onChange(next) {
@@ -216 +1438 @@
       min: 1,
       max: 12
-    }), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["RangeControl"], {
-      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__["__"])('Width'),
+    }), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["RangeControl"], {
+      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__["__"])('Width'),
       value: w,
       onChange: function onChange(next) {
@@ -226 +1448 @@
       min: 1,
       max: 12
-    })), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["PanelBody"], {
+    })), React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["PanelBody"], {
       title: "Background Settings"
-    }, (type === 'image' || type === 'image-content') && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["MediaUpload"], {
+    }, (type === 'image' || type === 'image-content') && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["MediaUpload"], {
       onSelect: function onSelect(value) {
         // console.log(value);
@@ -253 +1475 @@
         }, "Choose Background"));
       }
-    }), React.createElement("hr", null), (type === 'solid' || type === 'image-content') && React.createElement("div", null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["ColorPalette"], {
+    }), React.createElement("hr", null), (type === 'solid' || type === 'image-content') && React.createElement("div", null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["ColorPalette"], {
       label: "Background Color",
       value: bgColor ? bgColor.color : undefined,
       onChange: function onChange(value) {
+        var settings = Object(_wordpress_data__WEBPACK_IMPORTED_MODULE_6__["select"])('core/editor').getEditorSettings();
+        var colorSlug = value ? Object(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["getColorObjectByColorValue"])(settings.colors, value).slug : undefined;
+        setAttributes({
+          bgColorSlug: colorSlug
+        });
+        var brightness = value ? tinycolor2__WEBPACK_IMPORTED_MODULE_1___default()(value).getBrightness() : undefined;
+        setAttributes({
+          bgColorBrightness: brightness
+        });
         setAttributes({
           bgColor: value
         });
       }
-    }), React.createElement("hr", null)), type === 'image-content' && React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_1__["RangeControl"], {
-      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_2__["__"])('Opacity'),
+    }), React.createElement("hr", null)), type === 'image-content' && React.createElement(_wordpress_components__WEBPACK_IMPORTED_MODULE_2__["RangeControl"], {
+      label: Object(_wordpress_i18n__WEBPACK_IMPORTED_MODULE_3__["__"])('Opacity'),
       value: opacity,
       onChange: function onChange(next) {
@@ -273 +1504 @@
       step: "0.1"
     }))), React.createElement("div", {
-      className: "wp-block-gecko-grid-layout-editor__item ".concat(type, " ").concat(attributes.className),
+      className: "wp-block-gecko-grid-layout-editor__item ".concat(type, " ").concat(attributes.className, " has-").concat(bgColorSlug, "-background-color is-").concat(lightOrDark, "-background"),
       style: styles
     }, React.createElement("div", {
@@ -283 +1514 @@
         });
       }
-    }), (type === 'image' || type === 'image-content') && !bgMedia && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["MediaPlaceholder"], {
+    }), (type === 'image' || type === 'image-content') && !bgMedia && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["MediaPlaceholder"], {
       onSelect: function onSelect(value) {
         setAttributes({
@@ -292 +1523 @@
       allowedTypes: ['image'],
       accept: "image/*"
-    }), (type === 'solid' || type === 'image-content' && bgMedia) && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["InnerBlocks"], {
+    }), (type === 'solid' || type === 'image-content' && bgMedia) && React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["InnerBlocks"], {
       templateLock: false
     }))));
   },
   save: function save() {
-    return React.createElement("div", null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_4__["InnerBlocks"].Content, null));
+    return React.createElement("div", null, React.createElement(_wordpress_editor__WEBPACK_IMPORTED_MODULE_5__["InnerBlocks"].Content, null));
   }
 };
@@ -549 +1780 @@
     name: 'Image with Content',
     icon: react__WEBPACK_IMPORTED_MODULE_0___default.a.createElement("span", {
-      class: "dashicons dashicons-admin-appearance"
+      class: "dashicons dashicons-format-gallery"
     })
   }];
@@ -594 +1825 @@
 /***/ }),
 
+/***/ "@wordpress/data":
+/*!*********************************!*\
+  !*** external "window.wp.data" ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = window.wp.data;
+
+/***/ }),
+
 /***/ "@wordpress/editor":
 /*!***********************************!*\
@@ -639 +1881 @@
 
 /******/ });
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/grid-layout-item.js","webpack:///./src/grid-layout.js","webpack:///./src/index.js","webpack:///./src/type-select.js","webpack:///external \"window.wp.blocks\"","webpack:///external \"window.wp.components\"","webpack:///external \"window.wp.editor\"","webpack:///external \"window.wp.element\"","webpack:///external \"window.wp.i18n\"","webpack:///external \"React\""],"names":["name","settings","title","__","parent","icon","description","category","supports","className","inserter","reusable","html","attributes","type","default","undefined","opacity","h","w","bgMedia","bgMediaUrl","bgColor","edit","setAttributes","insertBlocksAfter","console","log","arguments","styles","gridColumnEnd","gridRowEnd","backgroundColor","backgroundImage","next","value","id","url","open","cursor","color","save","ALLOWED_BLOCKS","columns","gap","align","deprecated","registerBlockType","grid","gridItem","jQuery","$","listenForStyleChangesGridItem","each","observer","MutationObserver","mutations","forEach","mutation","find","attr","disconnect","observe","attributeFilter","listenForStyleChangesGrid","updateStylesGridItem","updateStylesGrid","on","e","window","load","onSelect","selected","types","slug","map","isSelected"],"mappings":"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","file":"editor.bundle.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/wp-content/plugins/gecko-grid-layout/dist/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/index.js\");\n","import TypeSelect from './type-select';\n/**\n * WordPress dependencies\n */\nimport {\n\tPanelBody,\n\tRangeControl,\n\tPath,\n\tSVG\n} from '@wordpress/components';\nimport { __ } from '@wordpress/i18n';\nimport { Fragment } from '@wordpress/element';\nimport {\n\tInspectorControls,\n\tInnerBlocks,\n\tMediaUpload,\n\tMediaPlaceholder,\n\tColorPalette,\n} from '@wordpress/editor';\n\nexport const name = 'gecko/grid-layout-item';\n\nexport const settings = {\n\ttitle: __( 'Item' ),\n\n\tparent: ['gecko/grid-layout'],\n\n\ticon: <SVG xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><Path fill=\"none\" d=\"M0 0h24v24H0V0z\" /><Path d=\"M11.99 18.54l-7.37-5.73L3 14.07l9 7 9-7-1.63-1.27zM12 16l7.36-5.73L21 9l-9-7-9 7 1.63 1.27L12 16zm0-11.47L17.74 9 12 13.47 6.26 9 12 4.53z\" /></SVG>,\n\n\tdescription: __( 'A single grid item within a grid block.' ),\n\n\tcategory: 'common',\n\n\tsupports: {\n\t\tclassName: true,\n\t\tinserter: true,\n\t\treusable: false,\n\t\thtml: false,\n\t},\n\n\tattributes: {\n\t\ttype:{\n\t\t\ttype: 'string',\n\t\t\tdefault: undefined, //solid // image //image-content\n\t\t},\n\t\topacity: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t\th: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t\tw: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t\tbgMedia: {\n\t\t\ttype: 'number',\n\t\t},\n\t\tbgMediaUrl: {\n\t\t\ttype: 'string',\n\t\t},\n\t\tbgColor: {\n\t\t\ttype: 'string',\n\t\t},\n\t},\n\n\tedit({ attributes, setAttributes, className, insertBlocksAfter }) {\n\t\tconsole.log(arguments);\n\t\tconst { opacity, h, w, type, bgMedia, bgMediaUrl, bgColor } = attributes;\n\t\tconst styles = {\n\t\t\t'--background': bgColor,\n\t\t\t'--opacity': opacity,\n\t\t\tgridColumnEnd: 'span '+ w,\n\t\t\tgridRowEnd: 'span ' + h,\n\t\t\tbackgroundColor: bgColor,\n\t\t\tbackgroundImage: 'url(' + bgMediaUrl + ')',\n\t\t};\n\t\tif(type === \"image\"){\n\t\t\tdelete(styles.backgroundColor);\n\t\t}\n\t\tif (type === \"solid\") {\n\t\t\tdelete(styles.backgroundImage);\n\t\t}\n\t\treturn (\n\t\t\t<Fragment>\n\t\t\t\t<InspectorControls>\n\t\t\t\t\t<PanelBody title=\"Type\">\n\t\t\t\t\t\t<TypeSelect \n\t\t\t\t\t\t\tonSelect = {(next) => {\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\ttype: next,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\tvalue={type}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t\t<PanelBody  title=\"Size Settings\">\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Height' ) }\n\t\t\t\t\t\t\tvalue={ h }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\th: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 1 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Width' ) }\n\t\t\t\t\t\t\tvalue={ w }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tw: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 1 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t\t<PanelBody title=\"Background Settings\">\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'image' || type === 'image-content') &&\n\t\t\t\t\t\t\t<MediaUpload\n\t\t\t\t\t\t\t\tonSelect={(value) => {\n\t\t\t\t\t\t\t\t\t// console.log(value);\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\tbgMedia: value.id,\n\t\t\t\t\t\t\t\t\t\tbgMediaUrl: value.url,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\t\ttype={['image', 'video']}\n\t\t\t\t\t\t\t\tvalue={(bgMedia)? bgMedia: null }\n\t\t\t\t\t\t\t\trender={({open}) => {\n\t\t\t\t\t\t\t\t\treturn(\n\t\t\t\t\t\t\t\t\t\t<div>\n\t\t\t\t\t\t\t\t\t\t\t{bgMediaUrl && <img src={bgMediaUrl} onClick={open} width=\"100%\" height=\"auto\" style={{cursor: \"pointer\"}}/>}\n\t\t\t\t\t\t\t\t\t\t\t{!bgMediaUrl && <div className={'button button-large'} onClick={open}>\n\t\t\t\t\t\t\t\t\t\t\t\tChoose Background\n\t\t\t\t\t\t\t\t\t\t\t</div>}\n\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t}\n\t\t\t\t\t\t<hr />\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'solid' || type === 'image-content') &&\n\t\t\t\t\t\t\t<div>\n\t\t\t\t\t\t\t\t<ColorPalette\n\t\t\t\t\t\t\t\t\tlabel='Background Color'\n\t\t\t\t\t\t\t\t\tvalue={(bgColor) ? bgColor.color : undefined}\n\t\t\t\t\t\t\t\t\tonChange = {\n\t\t\t\t\t\t\t\t\t\t(value) => {\n\t\t\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\t\t\tbgColor: value\n\t\t\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t\t\t<hr />\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t}\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'image-content') &&\n\t\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\t\tlabel={ __( 'Opacity' ) }\n\t\t\t\t\t\t\t\tvalue={ opacity }\n\t\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\t\topacity: next,\n\t\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\t\tmin = \"0\"\n\t\t\t\t\t\t\t\tmax = \"1\"\n\t\t\t\t\t\t\t\tstep = \"0.1\"\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t}\n\t\t\t\t\t</PanelBody>\n\t\t\t\t</InspectorControls>\n\t\t\t\t<div className={`wp-block-gecko-grid-layout-editor__item ${type} ${attributes.className}`} style={styles}>\n\t\t\t\t\t<div className = \"wp-block-gecko-grid-layout-editor__wrap\">\n\t\t\t\t\t{!type && <TypeSelect \n\t\t\t\t\t\tonSelect = {(next) => {\n\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\ttype: next,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}}\n\t\t\t\t\t/>}\n\t\t\t\t\t{\n\t\t\t\t\t\t(type === 'image' || type === 'image-content') &&\n\t\t\t\t\t\t!bgMedia &&\n\t\t\t\t\t\t<MediaPlaceholder\n\t\t\t\t\t\t\tonSelect={(value) => {\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\tbgMedia: value.id,\n\t\t\t\t\t\t\t\t\t\tbgMediaUrl: value.url,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\tallowedTypes={['image']}\n\t\t\t\t\t\t\taccept=\"image/*\"\n\t\t\t\t\t\t/>\n\t\t\t\t\t}\n\t\t\t\t\t{ \n\t\t\t\t\t\t(type === 'solid' || (type === 'image-content' && bgMedia)) &&\n\t\t\t\t\t\t<InnerBlocks templateLock={ false } />\n\t\t\t\t\t}\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</Fragment>\n\t\t);\n\t},\n\n\tsave() {\n\t\treturn <div><InnerBlocks.Content /></div>;\n\t},\n};\n","/**\n * WordPress dependencies\n */\nimport { __ } from '@wordpress/i18n';\nimport { PanelBody, RangeControl, G, SVG, Path } from '@wordpress/components';\nimport { Fragment } from '@wordpress/element';\nimport {\n\tInspectorControls,\n\tInnerBlocks,\n} from '@wordpress/editor';\n\n/**\n * Allowed blocks constant is passed to InnerBlocks precisely as specified here.\n * The contents of the array should never change.\n * The array should contain the name of each block that is allowed.\n * In columns block, the only block we allow is 'dmp/grid-item'.\n *\n * @constant\n * @type {string[]}\n*/\nconst ALLOWED_BLOCKS = ['gecko/grid-layout-item'];\n\nexport const name = 'gecko/grid-layout';\n\nexport const settings = {\n\ttitle: __( 'Grid' ),\n\n\ticon: <SVG viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><Path fill=\"none\" d=\"M0 0h24v24H0V0z\" /><G><Path d=\"M4,13 L8,13 L8,10 L4,10 L4,13 Z M4,15 L4,18 L8,18 L8,15 L4,15 Z M10,13 L14,13 L14,10 L10,10 L10,13 Z M10,15 L10,18 L14,18 L14,15 L10,15 Z M20,13 L20,10 L16,10 L16,13 L20,13 Z M20,15 L16,15 L16,18 L20,18 L20,15 Z M4,8 L8,8 L8,5 L4,5 L4,8 Z M10,8 L14,8 L14,5 L10,5 L10,8 Z M20,8 L20,5 L16,5 L16,8 L20,8 Z M4,3 L20,3 C21.1045695,3 22,3.95139491 22,5.125 L22,17.875 C22,19.0486051 21.1045695,20 20,20 L4,20 C2.8954305,20 2,19.0486051 2,17.875 L2,5.125 C2,3.95139491 2.8954305,3 4,3 Z\" /></G></SVG>,\n\n\tcategory: 'layout',\n\n\tattributes: {\n\t\tcolumns: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 12,\n\t\t},\n\t\tgap: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t},\n\n\tdescription: __( 'Use CSS Grid to build layouts and, then add whatever content blocks you’d like.' ),\n\n\tsupports: {\n\t\talign: [ 'wide', 'full' ],\n\t\thtml: false,\n\t},\n\n\tdeprecated: [],\n\n\tedit( { attributes, setAttributes } ) {\n\t\tconst { columns, gap } = attributes;\n\t\t// const styles = 'grid-template-columns: repeat(' + columns + ', minmax(100px, 1fr));\tgrid-auto-rows: minmax(100px, auto); grid-gap:' + gap + 'rem;';\n\t\tconst styles = 'grid-gap:' + gap + 'rem;';\n\n\t\treturn (\n\t\t\t<Fragment>\n\t\t\t\t<InspectorControls>\n\t\t\t\t\t<PanelBody>\n\t\t\t\t\t\t{/* <RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Grid Layout' ) }\n\t\t\t\t\t\t\tvalue={ columns }\n\t\t\t\t\t\t\tonChange={ ( nextColumns ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tcolumns: nextColumns,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 2 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/> */}\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Gap' ) }\n\t\t\t\t\t\t\tvalue={ gap }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tgap: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 0 }\n\t\t\t\t\t\t\tmax={ 2 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t</InspectorControls>\n\t\t\t\t<div className=\"wp-block-gecko-grid-layout-editor\" data-passthru={styles} data-grid={columns}>\n\t\t\t\t\t<InnerBlocks\n\t\t\t\t\t\ttemplate = {\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\t['gecko/grid-layout-item'],\n\t\t\t\t\t\t\t\t['gecko/grid-layout-item']\n\t\t\t\t\t\t\t]\n\t\t\t\t\t\t}\n\t\t\t\t\t\ttemplateLock={false}\n\t\t\t\t\t\tallowedBlocks={ ALLOWED_BLOCKS }\n\t\t\t\t\t\t/>\n\t\t\t\t</div>\n\t\t\t</Fragment>\n\t\t);\n\t},\n\n\tsave() {\n\t\treturn (\n\t\t\t<div>\n\t\t\t\t<InnerBlocks.Content />\n\t\t\t</div>\n\t\t);\n\t},\n};\n","/**\n * WordPress dependencies\n */\nimport {registerBlockType} from '@wordpress/blocks';\n\n/**\n * Internal dependencies\n */\nimport * as grid from './grid-layout';\nimport * as gridItem from './grid-layout-item';\n\nregisterBlockType(grid.name, grid.settings);\nregisterBlockType(gridItem.name, gridItem.settings);\n\n/**\n * This make sure the grid works in the editor.\n */\njQuery(function ($) {\n\n\tfunction listenForStyleChangesGridItem() {\n\t\t$('.wp-block-gecko-grid-layout-editor__item').each(function () {\n\t\t\tconst observer = new MutationObserver(function (mutations) {\n\t\t\t\tmutations.forEach(function (mutation) {\n\t\t\t\t\t// On change update the styles\n\t\t\t\t\t$('[data-type=\"gecko/grid-layout-item\"]').each(function () {\n\t\t\t\t\t\tconst styles = $(this).find(\".wp-block-gecko-grid-layout-editor__item\").attr(\"style\");\n\t\t\t\t\t\t$(this).attr(\"style\", styles);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t});\n\t\t\tobserver.disconnect();\n\t\t\tobserver.observe(this, {\n\t\t\t\tattributes: true,\n\t\t\t\tattributeFilter: ['style']\n\t\t\t});\n\t\t});\n\t}\n\n\tfunction listenForStyleChangesGrid() {\n\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\tconst observer = new MutationObserver(function (mutations) {\n\t\t\t\tmutations.forEach(function (mutation) {\n\t\t\t\t\t// On change update the styles\n\t\t\t\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\t\t\t\tconst styles = $(this).attr(\"data-passthru\");\n\t\t\t\t\t\tconst grid = $(this).attr(\"data-grid\");\n\t\t\t\t\t\t$(this).find(\".editor-block-list__layout\").attr(\"style\", styles);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t});\n\t\t\tobserver.disconnect();\n\t\t\tobserver.observe(this, {\n\t\t\t\tattributes: true,\n\t\t\t\tattributeFilter: ['data-passthru', 'style'],\n\t\t\t});\n\t\t});\n\t}\n\n\tfunction updateStylesGridItem() {\n\t\t$('[data-type=\"gecko/grid-layout-item\"]').each(function () {\n\t\t\tconst styles = $(this).find(\".wp-block-gecko-grid-layout-editor__item\").attr(\"style\");\n\t\t\t$(this).attr(\"style\", styles);\n\t\t});\n\t}\n\n\tfunction updateStylesGrid() {\n\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\tconst styles = $(this).attr(\"data-passthru\");\n\t\t\tconst grid = $(this).attr(\"data-grid\");\n\t\t\t$(this).find(\".editor-block-list__layout\").attr(\"style\", styles);\n\t\t});\n\t}\n\n\t$('body').on('DOMNodeInserted', '.wp-block-gecko-grid-layout-editor', function (e) {\n\t\tif ($('.wp-block-gecko-grid-layout-editor')){\n\t\t\tupdateStylesGrid();\n\t\t\tupdateStylesGridItem();\n\t\t\tlistenForStyleChangesGrid()\n\t\t\tlistenForStyleChangesGridItem();\n\t\t}\n\t});\n\n\t$(window).load(function () {\n\t\tupdateStylesGrid();\n\t\tupdateStylesGridItem();\n\t\tlistenForStyleChangesGrid()\n\t\tlistenForStyleChangesGridItem();\n\t});\n});","import { __ } from '@wordpress/i18n';\n// import { Fragment } from '@wordpress/element';\nexport default function({value, onSelect}){\n\tconst selected = (next) => {\n\t\treturn onSelect(next);\n\t}\n\tconst types = [\n\t\t{ slug: 'solid', name: 'Solid', icon: <span class=\"dashicons dashicons-admin-appearance\"></span>},\n\t\t{ slug: 'image', name: 'Image', icon: <span class=\"dashicons dashicons-format-image\"></span>},\n\t\t{ slug: 'image-content', name: 'Image with Content', icon: <span class=\"dashicons dashicons-admin-appearance\"></span>},\n\t]\n\treturn(\n\t\t<div className=\"wp-block-gecko-grid-layout-type-select\">\n\t\t\t<p>Choose the block layout type.</p>\n\t\t\t{types.map((type) => {\n\t\t\t\tlet isSelected = \"\";\n\t\t\t\tif(type.slug === value){\n\t\t\t\t\tisSelected = \"wp-block-gecko-grid-layout-type-select__item--selected\"\n\t\t\t\t}\n\t\t\t\treturn (\n\t\t\t\t\t<div className={`wp-block-gecko-grid-layout-type-select__item ${isSelected}`} onClick={()=> selected(type.slug)}>{type.icon}{type.name}</div>\n\t\t\t\t);\n\t\t\t})}\n\t\t</div>\n\t);\n}","module.exports = window.wp.blocks;","module.exports = window.wp.components;","module.exports = window.wp.editor;","module.exports = window.wp.element;","module.exports = window.wp.i18n;","module.exports = React;"],"sourceRoot":""}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./node_modules/tinycolor2/tinycolor.js","webpack:///./src/grid-layout-item.js","webpack:///./src/grid-layout.js","webpack:///./src/index.js","webpack:///./src/type-select.js","webpack:///external \"window.wp.blocks\"","webpack:///external \"window.wp.components\"","webpack:///external \"window.wp.data\"","webpack:///external \"window.wp.editor\"","webpack:///external \"window.wp.element\"","webpack:///external \"window.wp.i18n\"","webpack:///external \"React\""],"names":["name","settings","title","__","parent","icon","description","category","supports","className","inserter","reusable","html","attributes","type","default","undefined","opacity","h","w","bgMedia","bgMediaUrl","bgColor","bgColorSlug","bgColorBrightness","edit","setAttributes","insertBlocksAfter","console","log","arguments","styles","gridColumnEnd","gridRowEnd","backgroundColor","backgroundImage","lightOrDark","next","value","id","url","open","cursor","color","select","getEditorSettings","colorSlug","getColorObjectByColorValue","colors","slug","brightness","tinycolor","getBrightness","save","ALLOWED_BLOCKS","columns","gap","align","deprecated","registerBlockType","grid","gridItem","jQuery","$","listenForStyleChangesGridItem","each","observer","MutationObserver","mutations","forEach","mutation","find","attr","disconnect","observe","attributeFilter","listenForStyleChangesGrid","updateStylesGridItem","updateStylesGrid","on","e","window","load","onSelect","selected","types","map","isSelected"],"mappings":";AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;AClFA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,oBAAoB;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,sBAAsB,8BAA8B;AACpD,sBAAsB,8BAA8B;AACpD,sBAAsB,8BAA8B;;AAEpD;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,+BAA+B,mBAAmB,OAAO;AACzD,+BAA+B,mBAAmB,OAAO;AACzD,+BAA+B,mBAAmB,OAAO;AACzD;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,gBAAgB;AAChB,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,gBAAgB;AAChB,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,gBAAgB;AAChB,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,gBAAgB;AAChB,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,eAAe;AACf;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,eAAe,UAAU;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,eAAe,UAAU;AACzB;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,kBAAkB;AAClB;AACA;AACA;AACA;AACA;AACA,sDAAsD;AACtD,wCAAwC;AACxC,wCAAwC;AACxC;;AAEA;AACA;;AAEA,YAAY;AACZ;;AAEA;AACA;AACA;AACA,eAAe,UAAU;AACzB;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY;AACZ;;AAEA;AACA;AACA;AACA,eAAe,UAAU;AACzB;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA,cAAc;AACd;AACA;AACA;AACA,sDAAsD;AACtD,wCAAwC;AACxC,wCAAwC;AACxC;AACA;AACA;AACA,YAAY;AACZ;;AAEA;AACA;AACA;AACA,eAAe,UAAU;AACzB;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY;AACZ;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,6BAA6B,cAAc;AAC3C;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB,yCAAyC;AAC5D,mBAAmB,yCAAyC;AAC5D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB,wCAAwC;AAC3D,mBAAmB,yCAAyC;AAC5D,mBAAmB,yCAAyC;AAC5D;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,mBAAmB,uCAAuC;AAC1D,mBAAmB,wCAAwC;AAC3D;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,+DAA+D,WAAW;AAC1E;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B,kBAAkB;AAC9C;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,2DAA2D,wBAAwB;;AAEnF;AACA;AACA,2CAA2C,wBAAwB;AACnE;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA,8EAA8E,4BAA4B,gBAAgB;AAC1H,8EAA8E,2BAA2B,gBAAgB;AACzH,qDAAqD,oDAAoD,gBAAgB;AACzH,qDAAqD,oDAAoD,gBAAgB;AACzH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,kBAAkB,uBAAuB;AACzC;AACA;AACA;AACA;AACA;AACA;;AAEA,oDAAoD,0BAA0B;AAC9E;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;;AAGA;AACA;;AAEA,KAAK,kBAAkB,YAAY,kBAAkB;AACrD;AACA,mBAAmB;AACnB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,4BAA4B,YAAY;;AAExC;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,EAAE,cAAc,EAAE,cAAc,EAAE;AACjE,+BAA+B,EAAE,cAAc,EAAE,cAAc,EAAE;AACjE,+BAA+B,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE;AACjF,+BAA+B,EAAE,cAAc,EAAE,cAAc,EAAE,cAAc,EAAE;AACjF;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,wCAAwC,UAAU,OAAO,UAAU,OAAO,SAAS;AACnF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,2CAA2C;AAC3C;AACA,sBAAsB;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;;AAEA;AACA,IAAI,KAA6B;AACjC;AACA;AACA;AACA,SAAS,IAA0C;AACnD,IAAI,mCAAO,aAAa,kBAAkB;AAAA,oGAAC;AAC3C;AACA;AACA,KAAK,EAEJ;;AAED,CAAC;;;;;;;;;;;;;AC1qCD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;;;;AAGA;AAMA;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","file":"editor.bundle.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"/wp-content/plugins/gecko-grid-layout/dist/\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./src/index.js\");\n","// TinyColor v1.4.1\n// https://github.com/bgrins/TinyColor\n// Brian Grinstead, MIT License\n\n(function(Math) {\n\nvar trimLeft = /^\\s+/,\n    trimRight = /\\s+$/,\n    tinyCounter = 0,\n    mathRound = Math.round,\n    mathMin = Math.min,\n    mathMax = Math.max,\n    mathRandom = Math.random;\n\nfunction tinycolor (color, opts) {\n\n    color = (color) ? color : '';\n    opts = opts || { };\n\n    // If input is already a tinycolor, return itself\n    if (color instanceof tinycolor) {\n       return color;\n    }\n    // If we are called as a function, call using new instead\n    if (!(this instanceof tinycolor)) {\n        return new tinycolor(color, opts);\n    }\n\n    var rgb = inputToRGB(color);\n    this._originalInput = color,\n    this._r = rgb.r,\n    this._g = rgb.g,\n    this._b = rgb.b,\n    this._a = rgb.a,\n    this._roundA = mathRound(100*this._a) / 100,\n    this._format = opts.format || rgb.format;\n    this._gradientType = opts.gradientType;\n\n    // Don't let the range of [0,255] come back in [0,1].\n    // Potentially lose a little bit of precision here, but will fix issues where\n    // .5 gets interpreted as half of the total, instead of half of 1\n    // If it was supposed to be 128, this was already taken care of by `inputToRgb`\n    if (this._r < 1) { this._r = mathRound(this._r); }\n    if (this._g < 1) { this._g = mathRound(this._g); }\n    if (this._b < 1) { this._b = mathRound(this._b); }\n\n    this._ok = rgb.ok;\n    this._tc_id = tinyCounter++;\n}\n\ntinycolor.prototype = {\n    isDark: function() {\n        return this.getBrightness() < 128;\n    },\n    isLight: function() {\n        return !this.isDark();\n    },\n    isValid: function() {\n        return this._ok;\n    },\n    getOriginalInput: function() {\n      return this._originalInput;\n    },\n    getFormat: function() {\n        return this._format;\n    },\n    getAlpha: function() {\n        return this._a;\n    },\n    getBrightness: function() {\n        //http://www.w3.org/TR/AERT#color-contrast\n        var rgb = this.toRgb();\n        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1000;\n    },\n    getLuminance: function() {\n        //http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef\n        var rgb = this.toRgb();\n        var RsRGB, GsRGB, BsRGB, R, G, B;\n        RsRGB = rgb.r/255;\n        GsRGB = rgb.g/255;\n        BsRGB = rgb.b/255;\n\n        if (RsRGB <= 0.03928) {R = RsRGB / 12.92;} else {R = Math.pow(((RsRGB + 0.055) / 1.055), 2.4);}\n        if (GsRGB <= 0.03928) {G = GsRGB / 12.92;} else {G = Math.pow(((GsRGB + 0.055) / 1.055), 2.4);}\n        if (BsRGB <= 0.03928) {B = BsRGB / 12.92;} else {B = Math.pow(((BsRGB + 0.055) / 1.055), 2.4);}\n        return (0.2126 * R) + (0.7152 * G) + (0.0722 * B);\n    },\n    setAlpha: function(value) {\n        this._a = boundAlpha(value);\n        this._roundA = mathRound(100*this._a) / 100;\n        return this;\n    },\n    toHsv: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this._a };\n    },\n    toHsvString: function() {\n        var hsv = rgbToHsv(this._r, this._g, this._b);\n        var h = mathRound(hsv.h * 360), s = mathRound(hsv.s * 100), v = mathRound(hsv.v * 100);\n        return (this._a == 1) ?\n          \"hsv(\"  + h + \", \" + s + \"%, \" + v + \"%)\" :\n          \"hsva(\" + h + \", \" + s + \"%, \" + v + \"%, \"+ this._roundA + \")\";\n    },\n    toHsl: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this._a };\n    },\n    toHslString: function() {\n        var hsl = rgbToHsl(this._r, this._g, this._b);\n        var h = mathRound(hsl.h * 360), s = mathRound(hsl.s * 100), l = mathRound(hsl.l * 100);\n        return (this._a == 1) ?\n          \"hsl(\"  + h + \", \" + s + \"%, \" + l + \"%)\" :\n          \"hsla(\" + h + \", \" + s + \"%, \" + l + \"%, \"+ this._roundA + \")\";\n    },\n    toHex: function(allow3Char) {\n        return rgbToHex(this._r, this._g, this._b, allow3Char);\n    },\n    toHexString: function(allow3Char) {\n        return '#' + this.toHex(allow3Char);\n    },\n    toHex8: function(allow4Char) {\n        return rgbaToHex(this._r, this._g, this._b, this._a, allow4Char);\n    },\n    toHex8String: function(allow4Char) {\n        return '#' + this.toHex8(allow4Char);\n    },\n    toRgb: function() {\n        return { r: mathRound(this._r), g: mathRound(this._g), b: mathRound(this._b), a: this._a };\n    },\n    toRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \")\" :\n          \"rgba(\" + mathRound(this._r) + \", \" + mathRound(this._g) + \", \" + mathRound(this._b) + \", \" + this._roundA + \")\";\n    },\n    toPercentageRgb: function() {\n        return { r: mathRound(bound01(this._r, 255) * 100) + \"%\", g: mathRound(bound01(this._g, 255) * 100) + \"%\", b: mathRound(bound01(this._b, 255) * 100) + \"%\", a: this._a };\n    },\n    toPercentageRgbString: function() {\n        return (this._a == 1) ?\n          \"rgb(\"  + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%)\" :\n          \"rgba(\" + mathRound(bound01(this._r, 255) * 100) + \"%, \" + mathRound(bound01(this._g, 255) * 100) + \"%, \" + mathRound(bound01(this._b, 255) * 100) + \"%, \" + this._roundA + \")\";\n    },\n    toName: function() {\n        if (this._a === 0) {\n            return \"transparent\";\n        }\n\n        if (this._a < 1) {\n            return false;\n        }\n\n        return hexNames[rgbToHex(this._r, this._g, this._b, true)] || false;\n    },\n    toFilter: function(secondColor) {\n        var hex8String = '#' + rgbaToArgbHex(this._r, this._g, this._b, this._a);\n        var secondHex8String = hex8String;\n        var gradientType = this._gradientType ? \"GradientType = 1, \" : \"\";\n\n        if (secondColor) {\n            var s = tinycolor(secondColor);\n            secondHex8String = '#' + rgbaToArgbHex(s._r, s._g, s._b, s._a);\n        }\n\n        return \"progid:DXImageTransform.Microsoft.gradient(\"+gradientType+\"startColorstr=\"+hex8String+\",endColorstr=\"+secondHex8String+\")\";\n    },\n    toString: function(format) {\n        var formatSet = !!format;\n        format = format || this._format;\n\n        var formattedString = false;\n        var hasAlpha = this._a < 1 && this._a >= 0;\n        var needsAlphaFormat = !formatSet && hasAlpha && (format === \"hex\" || format === \"hex6\" || format === \"hex3\" || format === \"hex4\" || format === \"hex8\" || format === \"name\");\n\n        if (needsAlphaFormat) {\n            // Special case for \"transparent\", all other non-alpha formats\n            // will return rgba when there is transparency.\n            if (format === \"name\" && this._a === 0) {\n                return this.toName();\n            }\n            return this.toRgbString();\n        }\n        if (format === \"rgb\") {\n            formattedString = this.toRgbString();\n        }\n        if (format === \"prgb\") {\n            formattedString = this.toPercentageRgbString();\n        }\n        if (format === \"hex\" || format === \"hex6\") {\n            formattedString = this.toHexString();\n        }\n        if (format === \"hex3\") {\n            formattedString = this.toHexString(true);\n        }\n        if (format === \"hex4\") {\n            formattedString = this.toHex8String(true);\n        }\n        if (format === \"hex8\") {\n            formattedString = this.toHex8String();\n        }\n        if (format === \"name\") {\n            formattedString = this.toName();\n        }\n        if (format === \"hsl\") {\n            formattedString = this.toHslString();\n        }\n        if (format === \"hsv\") {\n            formattedString = this.toHsvString();\n        }\n\n        return formattedString || this.toHexString();\n    },\n    clone: function() {\n        return tinycolor(this.toString());\n    },\n\n    _applyModification: function(fn, args) {\n        var color = fn.apply(null, [this].concat([].slice.call(args)));\n        this._r = color._r;\n        this._g = color._g;\n        this._b = color._b;\n        this.setAlpha(color._a);\n        return this;\n    },\n    lighten: function() {\n        return this._applyModification(lighten, arguments);\n    },\n    brighten: function() {\n        return this._applyModification(brighten, arguments);\n    },\n    darken: function() {\n        return this._applyModification(darken, arguments);\n    },\n    desaturate: function() {\n        return this._applyModification(desaturate, arguments);\n    },\n    saturate: function() {\n        return this._applyModification(saturate, arguments);\n    },\n    greyscale: function() {\n        return this._applyModification(greyscale, arguments);\n    },\n    spin: function() {\n        return this._applyModification(spin, arguments);\n    },\n\n    _applyCombination: function(fn, args) {\n        return fn.apply(null, [this].concat([].slice.call(args)));\n    },\n    analogous: function() {\n        return this._applyCombination(analogous, arguments);\n    },\n    complement: function() {\n        return this._applyCombination(complement, arguments);\n    },\n    monochromatic: function() {\n        return this._applyCombination(monochromatic, arguments);\n    },\n    splitcomplement: function() {\n        return this._applyCombination(splitcomplement, arguments);\n    },\n    triad: function() {\n        return this._applyCombination(triad, arguments);\n    },\n    tetrad: function() {\n        return this._applyCombination(tetrad, arguments);\n    }\n};\n\n// If input is an object, force 1 into \"1.0\" to handle ratios properly\n// String input requires \"1.0\" as input, so 1 will be treated as 1\ntinycolor.fromRatio = function(color, opts) {\n    if (typeof color == \"object\") {\n        var newColor = {};\n        for (var i in color) {\n            if (color.hasOwnProperty(i)) {\n                if (i === \"a\") {\n                    newColor[i] = color[i];\n                }\n                else {\n                    newColor[i] = convertToPercentage(color[i]);\n                }\n            }\n        }\n        color = newColor;\n    }\n\n    return tinycolor(color, opts);\n};\n\n// Given a string or object, convert that input to RGB\n// Possible string inputs:\n//\n//     \"red\"\n//     \"#f00\" or \"f00\"\n//     \"#ff0000\" or \"ff0000\"\n//     \"#ff000000\" or \"ff000000\"\n//     \"rgb 255 0 0\" or \"rgb (255, 0, 0)\"\n//     \"rgb 1.0 0 0\" or \"rgb (1, 0, 0)\"\n//     \"rgba (255, 0, 0, 1)\" or \"rgba 255, 0, 0, 1\"\n//     \"rgba (1.0, 0, 0, 1)\" or \"rgba 1.0, 0, 0, 1\"\n//     \"hsl(0, 100%, 50%)\" or \"hsl 0 100% 50%\"\n//     \"hsla(0, 100%, 50%, 1)\" or \"hsla 0 100% 50%, 1\"\n//     \"hsv(0, 100%, 100%)\" or \"hsv 0 100% 100%\"\n//\nfunction inputToRGB(color) {\n\n    var rgb = { r: 0, g: 0, b: 0 };\n    var a = 1;\n    var s = null;\n    var v = null;\n    var l = null;\n    var ok = false;\n    var format = false;\n\n    if (typeof color == \"string\") {\n        color = stringInputToObject(color);\n    }\n\n    if (typeof color == \"object\") {\n        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {\n            rgb = rgbToRgb(color.r, color.g, color.b);\n            ok = true;\n            format = String(color.r).substr(-1) === \"%\" ? \"prgb\" : \"rgb\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {\n            s = convertToPercentage(color.s);\n            v = convertToPercentage(color.v);\n            rgb = hsvToRgb(color.h, s, v);\n            ok = true;\n            format = \"hsv\";\n        }\n        else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {\n            s = convertToPercentage(color.s);\n            l = convertToPercentage(color.l);\n            rgb = hslToRgb(color.h, s, l);\n            ok = true;\n            format = \"hsl\";\n        }\n\n        if (color.hasOwnProperty(\"a\")) {\n            a = color.a;\n        }\n    }\n\n    a = boundAlpha(a);\n\n    return {\n        ok: ok,\n        format: color.format || format,\n        r: mathMin(255, mathMax(rgb.r, 0)),\n        g: mathMin(255, mathMax(rgb.g, 0)),\n        b: mathMin(255, mathMax(rgb.b, 0)),\n        a: a\n    };\n}\n\n\n// Conversion Functions\n// --------------------\n\n// `rgbToHsl`, `rgbToHsv`, `hslToRgb`, `hsvToRgb` modified from:\n// <http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript>\n\n// `rgbToRgb`\n// Handle bounds / percentage checking to conform to CSS color spec\n// <http://www.w3.org/TR/css3-color/>\n// *Assumes:* r, g, b in [0, 255] or [0, 1]\n// *Returns:* { r, g, b } in [0, 255]\nfunction rgbToRgb(r, g, b){\n    return {\n        r: bound01(r, 255) * 255,\n        g: bound01(g, 255) * 255,\n        b: bound01(b, 255) * 255\n    };\n}\n\n// `rgbToHsl`\n// Converts an RGB color value to HSL.\n// *Assumes:* r, g, and b are contained in [0, 255] or [0, 1]\n// *Returns:* { h, s, l } in [0,1]\nfunction rgbToHsl(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, l = (max + min) / 2;\n\n    if(max == min) {\n        h = s = 0; // achromatic\n    }\n    else {\n        var d = max - min;\n        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n\n        h /= 6;\n    }\n\n    return { h: h, s: s, l: l };\n}\n\n// `hslToRgb`\n// Converts an HSL color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and l are contained [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\nfunction hslToRgb(h, s, l) {\n    var r, g, b;\n\n    h = bound01(h, 360);\n    s = bound01(s, 100);\n    l = bound01(l, 100);\n\n    function hue2rgb(p, q, t) {\n        if(t < 0) t += 1;\n        if(t > 1) t -= 1;\n        if(t < 1/6) return p + (q - p) * 6 * t;\n        if(t < 1/2) return q;\n        if(t < 2/3) return p + (q - p) * (2/3 - t) * 6;\n        return p;\n    }\n\n    if(s === 0) {\n        r = g = b = l; // achromatic\n    }\n    else {\n        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n        var p = 2 * l - q;\n        r = hue2rgb(p, q, h + 1/3);\n        g = hue2rgb(p, q, h);\n        b = hue2rgb(p, q, h - 1/3);\n    }\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHsv`\n// Converts an RGB color value to HSV\n// *Assumes:* r, g, and b are contained in the set [0, 255] or [0, 1]\n// *Returns:* { h, s, v } in [0,1]\nfunction rgbToHsv(r, g, b) {\n\n    r = bound01(r, 255);\n    g = bound01(g, 255);\n    b = bound01(b, 255);\n\n    var max = mathMax(r, g, b), min = mathMin(r, g, b);\n    var h, s, v = max;\n\n    var d = max - min;\n    s = max === 0 ? 0 : d / max;\n\n    if(max == min) {\n        h = 0; // achromatic\n    }\n    else {\n        switch(max) {\n            case r: h = (g - b) / d + (g < b ? 6 : 0); break;\n            case g: h = (b - r) / d + 2; break;\n            case b: h = (r - g) / d + 4; break;\n        }\n        h /= 6;\n    }\n    return { h: h, s: s, v: v };\n}\n\n// `hsvToRgb`\n// Converts an HSV color value to RGB.\n// *Assumes:* h is contained in [0, 1] or [0, 360] and s and v are contained in [0, 1] or [0, 100]\n// *Returns:* { r, g, b } in the set [0, 255]\n function hsvToRgb(h, s, v) {\n\n    h = bound01(h, 360) * 6;\n    s = bound01(s, 100);\n    v = bound01(v, 100);\n\n    var i = Math.floor(h),\n        f = h - i,\n        p = v * (1 - s),\n        q = v * (1 - f * s),\n        t = v * (1 - (1 - f) * s),\n        mod = i % 6,\n        r = [v, q, p, p, t, v][mod],\n        g = [t, v, v, q, p, p][mod],\n        b = [p, p, t, v, v, q][mod];\n\n    return { r: r * 255, g: g * 255, b: b * 255 };\n}\n\n// `rgbToHex`\n// Converts an RGB color to hex\n// Assumes r, g, and b are contained in the set [0, 255]\n// Returns a 3 or 6 character hex\nfunction rgbToHex(r, g, b, allow3Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    // Return a 3 character hex if possible\n    if (allow3Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToHex`\n// Converts an RGBA color plus alpha transparency to hex\n// Assumes r, g, b are contained in the set [0, 255] and\n// a in [0, 1]. Returns a 4 or 8 character rgba hex\nfunction rgbaToHex(r, g, b, a, allow4Char) {\n\n    var hex = [\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16)),\n        pad2(convertDecimalToHex(a))\n    ];\n\n    // Return a 4 character hex if possible\n    if (allow4Char && hex[0].charAt(0) == hex[0].charAt(1) && hex[1].charAt(0) == hex[1].charAt(1) && hex[2].charAt(0) == hex[2].charAt(1) && hex[3].charAt(0) == hex[3].charAt(1)) {\n        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);\n    }\n\n    return hex.join(\"\");\n}\n\n// `rgbaToArgbHex`\n// Converts an RGBA color to an ARGB Hex8 string\n// Rarely used, but required for \"toFilter()\"\nfunction rgbaToArgbHex(r, g, b, a) {\n\n    var hex = [\n        pad2(convertDecimalToHex(a)),\n        pad2(mathRound(r).toString(16)),\n        pad2(mathRound(g).toString(16)),\n        pad2(mathRound(b).toString(16))\n    ];\n\n    return hex.join(\"\");\n}\n\n// `equals`\n// Can be called with any tinycolor input\ntinycolor.equals = function (color1, color2) {\n    if (!color1 || !color2) { return false; }\n    return tinycolor(color1).toRgbString() == tinycolor(color2).toRgbString();\n};\n\ntinycolor.random = function() {\n    return tinycolor.fromRatio({\n        r: mathRandom(),\n        g: mathRandom(),\n        b: mathRandom()\n    });\n};\n\n\n// Modification Functions\n// ----------------------\n// Thanks to less.js for some of the basics here\n// <https://github.com/cloudhead/less.js/blob/master/lib/less/functions.js>\n\nfunction desaturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s -= amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction saturate(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.s += amount / 100;\n    hsl.s = clamp01(hsl.s);\n    return tinycolor(hsl);\n}\n\nfunction greyscale(color) {\n    return tinycolor(color).desaturate(100);\n}\n\nfunction lighten (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l += amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\nfunction brighten(color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var rgb = tinycolor(color).toRgb();\n    rgb.r = mathMax(0, mathMin(255, rgb.r - mathRound(255 * - (amount / 100))));\n    rgb.g = mathMax(0, mathMin(255, rgb.g - mathRound(255 * - (amount / 100))));\n    rgb.b = mathMax(0, mathMin(255, rgb.b - mathRound(255 * - (amount / 100))));\n    return tinycolor(rgb);\n}\n\nfunction darken (color, amount) {\n    amount = (amount === 0) ? 0 : (amount || 10);\n    var hsl = tinycolor(color).toHsl();\n    hsl.l -= amount / 100;\n    hsl.l = clamp01(hsl.l);\n    return tinycolor(hsl);\n}\n\n// Spin takes a positive or negative amount within [-360, 360] indicating the change of hue.\n// Values outside of this range will be wrapped into this range.\nfunction spin(color, amount) {\n    var hsl = tinycolor(color).toHsl();\n    var hue = (hsl.h + amount) % 360;\n    hsl.h = hue < 0 ? 360 + hue : hue;\n    return tinycolor(hsl);\n}\n\n// Combination Functions\n// ---------------------\n// Thanks to jQuery xColor for some of the ideas behind these\n// <https://github.com/infusion/jQuery-xcolor/blob/master/jquery.xcolor.js>\n\nfunction complement(color) {\n    var hsl = tinycolor(color).toHsl();\n    hsl.h = (hsl.h + 180) % 360;\n    return tinycolor(hsl);\n}\n\nfunction triad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 120) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 240) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction tetrad(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 90) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 180) % 360, s: hsl.s, l: hsl.l }),\n        tinycolor({ h: (h + 270) % 360, s: hsl.s, l: hsl.l })\n    ];\n}\n\nfunction splitcomplement(color) {\n    var hsl = tinycolor(color).toHsl();\n    var h = hsl.h;\n    return [\n        tinycolor(color),\n        tinycolor({ h: (h + 72) % 360, s: hsl.s, l: hsl.l}),\n        tinycolor({ h: (h + 216) % 360, s: hsl.s, l: hsl.l})\n    ];\n}\n\nfunction analogous(color, results, slices) {\n    results = results || 6;\n    slices = slices || 30;\n\n    var hsl = tinycolor(color).toHsl();\n    var part = 360 / slices;\n    var ret = [tinycolor(color)];\n\n    for (hsl.h = ((hsl.h - (part * results >> 1)) + 720) % 360; --results; ) {\n        hsl.h = (hsl.h + part) % 360;\n        ret.push(tinycolor(hsl));\n    }\n    return ret;\n}\n\nfunction monochromatic(color, results) {\n    results = results || 6;\n    var hsv = tinycolor(color).toHsv();\n    var h = hsv.h, s = hsv.s, v = hsv.v;\n    var ret = [];\n    var modification = 1 / results;\n\n    while (results--) {\n        ret.push(tinycolor({ h: h, s: s, v: v}));\n        v = (v + modification) % 1;\n    }\n\n    return ret;\n}\n\n// Utility Functions\n// ---------------------\n\ntinycolor.mix = function(color1, color2, amount) {\n    amount = (amount === 0) ? 0 : (amount || 50);\n\n    var rgb1 = tinycolor(color1).toRgb();\n    var rgb2 = tinycolor(color2).toRgb();\n\n    var p = amount / 100;\n\n    var rgba = {\n        r: ((rgb2.r - rgb1.r) * p) + rgb1.r,\n        g: ((rgb2.g - rgb1.g) * p) + rgb1.g,\n        b: ((rgb2.b - rgb1.b) * p) + rgb1.b,\n        a: ((rgb2.a - rgb1.a) * p) + rgb1.a\n    };\n\n    return tinycolor(rgba);\n};\n\n\n// Readability Functions\n// ---------------------\n// <http://www.w3.org/TR/2008/REC-WCAG20-20081211/#contrast-ratiodef (WCAG Version 2)\n\n// `contrast`\n// Analyze the 2 colors and returns the color contrast defined by (WCAG Version 2)\ntinycolor.readability = function(color1, color2) {\n    var c1 = tinycolor(color1);\n    var c2 = tinycolor(color2);\n    return (Math.max(c1.getLuminance(),c2.getLuminance())+0.05) / (Math.min(c1.getLuminance(),c2.getLuminance())+0.05);\n};\n\n// `isReadable`\n// Ensure that foreground and background color combinations meet WCAG2 guidelines.\n// The third argument is an optional Object.\n//      the 'level' property states 'AA' or 'AAA' - if missing or invalid, it defaults to 'AA';\n//      the 'size' property states 'large' or 'small' - if missing or invalid, it defaults to 'small'.\n// If the entire object is absent, isReadable defaults to {level:\"AA\",size:\"small\"}.\n\n// *Example*\n//    tinycolor.isReadable(\"#000\", \"#111\") => false\n//    tinycolor.isReadable(\"#000\", \"#111\",{level:\"AA\",size:\"large\"}) => false\ntinycolor.isReadable = function(color1, color2, wcag2) {\n    var readability = tinycolor.readability(color1, color2);\n    var wcag2Parms, out;\n\n    out = false;\n\n    wcag2Parms = validateWCAG2Parms(wcag2);\n    switch (wcag2Parms.level + wcag2Parms.size) {\n        case \"AAsmall\":\n        case \"AAAlarge\":\n            out = readability >= 4.5;\n            break;\n        case \"AAlarge\":\n            out = readability >= 3;\n            break;\n        case \"AAAsmall\":\n            out = readability >= 7;\n            break;\n    }\n    return out;\n\n};\n\n// `mostReadable`\n// Given a base color and a list of possible foreground or background\n// colors for that base, returns the most readable color.\n// Optionally returns Black or White if the most readable color is unreadable.\n// *Example*\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:false}).toHexString(); // \"#112255\"\n//    tinycolor.mostReadable(tinycolor.mostReadable(\"#123\", [\"#124\", \"#125\"],{includeFallbackColors:true}).toHexString();  // \"#ffffff\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"large\"}).toHexString(); // \"#faf3f3\"\n//    tinycolor.mostReadable(\"#a8015a\", [\"#faf3f3\"],{includeFallbackColors:true,level:\"AAA\",size:\"small\"}).toHexString(); // \"#ffffff\"\ntinycolor.mostReadable = function(baseColor, colorList, args) {\n    var bestColor = null;\n    var bestScore = 0;\n    var readability;\n    var includeFallbackColors, level, size ;\n    args = args || {};\n    includeFallbackColors = args.includeFallbackColors ;\n    level = args.level;\n    size = args.size;\n\n    for (var i= 0; i < colorList.length ; i++) {\n        readability = tinycolor.readability(baseColor, colorList[i]);\n        if (readability > bestScore) {\n            bestScore = readability;\n            bestColor = tinycolor(colorList[i]);\n        }\n    }\n\n    if (tinycolor.isReadable(baseColor, bestColor, {\"level\":level,\"size\":size}) || !includeFallbackColors) {\n        return bestColor;\n    }\n    else {\n        args.includeFallbackColors=false;\n        return tinycolor.mostReadable(baseColor,[\"#fff\", \"#000\"],args);\n    }\n};\n\n\n// Big List of Colors\n// ------------------\n// <http://www.w3.org/TR/css3-color/#svg-color>\nvar names = tinycolor.names = {\n    aliceblue: \"f0f8ff\",\n    antiquewhite: \"faebd7\",\n    aqua: \"0ff\",\n    aquamarine: \"7fffd4\",\n    azure: \"f0ffff\",\n    beige: \"f5f5dc\",\n    bisque: \"ffe4c4\",\n    black: \"000\",\n    blanchedalmond: \"ffebcd\",\n    blue: \"00f\",\n    blueviolet: \"8a2be2\",\n    brown: \"a52a2a\",\n    burlywood: \"deb887\",\n    burntsienna: \"ea7e5d\",\n    cadetblue: \"5f9ea0\",\n    chartreuse: \"7fff00\",\n    chocolate: \"d2691e\",\n    coral: \"ff7f50\",\n    cornflowerblue: \"6495ed\",\n    cornsilk: \"fff8dc\",\n    crimson: \"dc143c\",\n    cyan: \"0ff\",\n    darkblue: \"00008b\",\n    darkcyan: \"008b8b\",\n    darkgoldenrod: \"b8860b\",\n    darkgray: \"a9a9a9\",\n    darkgreen: \"006400\",\n    darkgrey: \"a9a9a9\",\n    darkkhaki: \"bdb76b\",\n    darkmagenta: \"8b008b\",\n    darkolivegreen: \"556b2f\",\n    darkorange: \"ff8c00\",\n    darkorchid: \"9932cc\",\n    darkred: \"8b0000\",\n    darksalmon: \"e9967a\",\n    darkseagreen: \"8fbc8f\",\n    darkslateblue: \"483d8b\",\n    darkslategray: \"2f4f4f\",\n    darkslategrey: \"2f4f4f\",\n    darkturquoise: \"00ced1\",\n    darkviolet: \"9400d3\",\n    deeppink: \"ff1493\",\n    deepskyblue: \"00bfff\",\n    dimgray: \"696969\",\n    dimgrey: \"696969\",\n    dodgerblue: \"1e90ff\",\n    firebrick: \"b22222\",\n    floralwhite: \"fffaf0\",\n    forestgreen: \"228b22\",\n    fuchsia: \"f0f\",\n    gainsboro: \"dcdcdc\",\n    ghostwhite: \"f8f8ff\",\n    gold: \"ffd700\",\n    goldenrod: \"daa520\",\n    gray: \"808080\",\n    green: \"008000\",\n    greenyellow: \"adff2f\",\n    grey: \"808080\",\n    honeydew: \"f0fff0\",\n    hotpink: \"ff69b4\",\n    indianred: \"cd5c5c\",\n    indigo: \"4b0082\",\n    ivory: \"fffff0\",\n    khaki: \"f0e68c\",\n    lavender: \"e6e6fa\",\n    lavenderblush: \"fff0f5\",\n    lawngreen: \"7cfc00\",\n    lemonchiffon: \"fffacd\",\n    lightblue: \"add8e6\",\n    lightcoral: \"f08080\",\n    lightcyan: \"e0ffff\",\n    lightgoldenrodyellow: \"fafad2\",\n    lightgray: \"d3d3d3\",\n    lightgreen: \"90ee90\",\n    lightgrey: \"d3d3d3\",\n    lightpink: \"ffb6c1\",\n    lightsalmon: \"ffa07a\",\n    lightseagreen: \"20b2aa\",\n    lightskyblue: \"87cefa\",\n    lightslategray: \"789\",\n    lightslategrey: \"789\",\n    lightsteelblue: \"b0c4de\",\n    lightyellow: \"ffffe0\",\n    lime: \"0f0\",\n    limegreen: \"32cd32\",\n    linen: \"faf0e6\",\n    magenta: \"f0f\",\n    maroon: \"800000\",\n    mediumaquamarine: \"66cdaa\",\n    mediumblue: \"0000cd\",\n    mediumorchid: \"ba55d3\",\n    mediumpurple: \"9370db\",\n    mediumseagreen: \"3cb371\",\n    mediumslateblue: \"7b68ee\",\n    mediumspringgreen: \"00fa9a\",\n    mediumturquoise: \"48d1cc\",\n    mediumvioletred: \"c71585\",\n    midnightblue: \"191970\",\n    mintcream: \"f5fffa\",\n    mistyrose: \"ffe4e1\",\n    moccasin: \"ffe4b5\",\n    navajowhite: \"ffdead\",\n    navy: \"000080\",\n    oldlace: \"fdf5e6\",\n    olive: \"808000\",\n    olivedrab: \"6b8e23\",\n    orange: \"ffa500\",\n    orangered: \"ff4500\",\n    orchid: \"da70d6\",\n    palegoldenrod: \"eee8aa\",\n    palegreen: \"98fb98\",\n    paleturquoise: \"afeeee\",\n    palevioletred: \"db7093\",\n    papayawhip: \"ffefd5\",\n    peachpuff: \"ffdab9\",\n    peru: \"cd853f\",\n    pink: \"ffc0cb\",\n    plum: \"dda0dd\",\n    powderblue: \"b0e0e6\",\n    purple: \"800080\",\n    rebeccapurple: \"663399\",\n    red: \"f00\",\n    rosybrown: \"bc8f8f\",\n    royalblue: \"4169e1\",\n    saddlebrown: \"8b4513\",\n    salmon: \"fa8072\",\n    sandybrown: \"f4a460\",\n    seagreen: \"2e8b57\",\n    seashell: \"fff5ee\",\n    sienna: \"a0522d\",\n    silver: \"c0c0c0\",\n    skyblue: \"87ceeb\",\n    slateblue: \"6a5acd\",\n    slategray: \"708090\",\n    slategrey: \"708090\",\n    snow: \"fffafa\",\n    springgreen: \"00ff7f\",\n    steelblue: \"4682b4\",\n    tan: \"d2b48c\",\n    teal: \"008080\",\n    thistle: \"d8bfd8\",\n    tomato: \"ff6347\",\n    turquoise: \"40e0d0\",\n    violet: \"ee82ee\",\n    wheat: \"f5deb3\",\n    white: \"fff\",\n    whitesmoke: \"f5f5f5\",\n    yellow: \"ff0\",\n    yellowgreen: \"9acd32\"\n};\n\n// Make it easy to access colors via `hexNames[hex]`\nvar hexNames = tinycolor.hexNames = flip(names);\n\n\n// Utilities\n// ---------\n\n// `{ 'name1': 'val1' }` becomes `{ 'val1': 'name1' }`\nfunction flip(o) {\n    var flipped = { };\n    for (var i in o) {\n        if (o.hasOwnProperty(i)) {\n            flipped[o[i]] = i;\n        }\n    }\n    return flipped;\n}\n\n// Return a valid alpha value [0,1] with all invalid values being set to 1\nfunction boundAlpha(a) {\n    a = parseFloat(a);\n\n    if (isNaN(a) || a < 0 || a > 1) {\n        a = 1;\n    }\n\n    return a;\n}\n\n// Take input from [0, n] and return it as [0, 1]\nfunction bound01(n, max) {\n    if (isOnePointZero(n)) { n = \"100%\"; }\n\n    var processPercent = isPercentage(n);\n    n = mathMin(max, mathMax(0, parseFloat(n)));\n\n    // Automatically convert percentage into number\n    if (processPercent) {\n        n = parseInt(n * max, 10) / 100;\n    }\n\n    // Handle floating point rounding errors\n    if ((Math.abs(n - max) < 0.000001)) {\n        return 1;\n    }\n\n    // Convert into [0, 1] range if it isn't already\n    return (n % max) / parseFloat(max);\n}\n\n// Force a number between 0 and 1\nfunction clamp01(val) {\n    return mathMin(1, mathMax(0, val));\n}\n\n// Parse a base-16 hex value into a base-10 integer\nfunction parseIntFromHex(val) {\n    return parseInt(val, 16);\n}\n\n// Need to handle 1.0 as 100%, since once it is a number, there is no difference between it and 1\n// <http://stackoverflow.com/questions/7422072/javascript-how-to-detect-number-as-a-decimal-including-1-0>\nfunction isOnePointZero(n) {\n    return typeof n == \"string\" && n.indexOf('.') != -1 && parseFloat(n) === 1;\n}\n\n// Check to see if string passed in is a percentage\nfunction isPercentage(n) {\n    return typeof n === \"string\" && n.indexOf('%') != -1;\n}\n\n// Force a hex value to have 2 characters\nfunction pad2(c) {\n    return c.length == 1 ? '0' + c : '' + c;\n}\n\n// Replace a decimal with it's percentage value\nfunction convertToPercentage(n) {\n    if (n <= 1) {\n        n = (n * 100) + \"%\";\n    }\n\n    return n;\n}\n\n// Converts a decimal to a hex value\nfunction convertDecimalToHex(d) {\n    return Math.round(parseFloat(d) * 255).toString(16);\n}\n// Converts a hex value to a decimal\nfunction convertHexToDecimal(h) {\n    return (parseIntFromHex(h) / 255);\n}\n\nvar matchers = (function() {\n\n    // <http://www.w3.org/TR/css3-values/#integers>\n    var CSS_INTEGER = \"[-\\\\+]?\\\\d+%?\";\n\n    // <http://www.w3.org/TR/css3-values/#number-value>\n    var CSS_NUMBER = \"[-\\\\+]?\\\\d*\\\\.\\\\d+%?\";\n\n    // Allow positive/negative integer/number.  Don't capture the either/or, just the entire outcome.\n    var CSS_UNIT = \"(?:\" + CSS_NUMBER + \")|(?:\" + CSS_INTEGER + \")\";\n\n    // Actual matching.\n    // Parentheses and commas are optional, but not required.\n    // Whitespace can take the place of commas or opening paren\n    var PERMISSIVE_MATCH3 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n    var PERMISSIVE_MATCH4 = \"[\\\\s|\\\\(]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")[,|\\\\s]+(\" + CSS_UNIT + \")\\\\s*\\\\)?\";\n\n    return {\n        CSS_UNIT: new RegExp(CSS_UNIT),\n        rgb: new RegExp(\"rgb\" + PERMISSIVE_MATCH3),\n        rgba: new RegExp(\"rgba\" + PERMISSIVE_MATCH4),\n        hsl: new RegExp(\"hsl\" + PERMISSIVE_MATCH3),\n        hsla: new RegExp(\"hsla\" + PERMISSIVE_MATCH4),\n        hsv: new RegExp(\"hsv\" + PERMISSIVE_MATCH3),\n        hsva: new RegExp(\"hsva\" + PERMISSIVE_MATCH4),\n        hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,\n        hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,\n        hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/\n    };\n})();\n\n// `isValidCSSUnit`\n// Take in a single string / number and check to see if it looks like a CSS unit\n// (see `matchers` above for definition).\nfunction isValidCSSUnit(color) {\n    return !!matchers.CSS_UNIT.exec(color);\n}\n\n// `stringInputToObject`\n// Permissive string parsing.  Take in a number of formats, and output an object\n// based on detected format.  Returns `{ r, g, b }` or `{ h, s, l }` or `{ h, s, v}`\nfunction stringInputToObject(color) {\n\n    color = color.replace(trimLeft,'').replace(trimRight, '').toLowerCase();\n    var named = false;\n    if (names[color]) {\n        color = names[color];\n        named = true;\n    }\n    else if (color == 'transparent') {\n        return { r: 0, g: 0, b: 0, a: 0, format: \"name\" };\n    }\n\n    // Try to match string input using regular expressions.\n    // Keep most of the number bounding out of this function - don't worry about [0,1] or [0,100] or [0,360]\n    // Just return an object and let the conversion functions handle that.\n    // This way the result will be the same whether the tinycolor is initialized with string or object.\n    var match;\n    if ((match = matchers.rgb.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3] };\n    }\n    if ((match = matchers.rgba.exec(color))) {\n        return { r: match[1], g: match[2], b: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsl.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3] };\n    }\n    if ((match = matchers.hsla.exec(color))) {\n        return { h: match[1], s: match[2], l: match[3], a: match[4] };\n    }\n    if ((match = matchers.hsv.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3] };\n    }\n    if ((match = matchers.hsva.exec(color))) {\n        return { h: match[1], s: match[2], v: match[3], a: match[4] };\n    }\n    if ((match = matchers.hex8.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            a: convertHexToDecimal(match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex6.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1]),\n            g: parseIntFromHex(match[2]),\n            b: parseIntFromHex(match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n    if ((match = matchers.hex4.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            a: convertHexToDecimal(match[4] + '' + match[4]),\n            format: named ? \"name\" : \"hex8\"\n        };\n    }\n    if ((match = matchers.hex3.exec(color))) {\n        return {\n            r: parseIntFromHex(match[1] + '' + match[1]),\n            g: parseIntFromHex(match[2] + '' + match[2]),\n            b: parseIntFromHex(match[3] + '' + match[3]),\n            format: named ? \"name\" : \"hex\"\n        };\n    }\n\n    return false;\n}\n\nfunction validateWCAG2Parms(parms) {\n    // return valid WCAG2 parms for isReadable.\n    // If input parms are invalid, return {\"level\":\"AA\", \"size\":\"small\"}\n    var level, size;\n    parms = parms || {\"level\":\"AA\", \"size\":\"small\"};\n    level = (parms.level || \"AA\").toUpperCase();\n    size = (parms.size || \"small\").toLowerCase();\n    if (level !== \"AA\" && level !== \"AAA\") {\n        level = \"AA\";\n    }\n    if (size !== \"small\" && size !== \"large\") {\n        size = \"small\";\n    }\n    return {\"level\":level, \"size\":size};\n}\n\n// Node: Export function\nif (typeof module !== \"undefined\" && module.exports) {\n    module.exports = tinycolor;\n}\n// AMD/requirejs: Define the module\nelse if (typeof define === 'function' && define.amd) {\n    define(function () {return tinycolor;});\n}\n// Browser: Expose to window\nelse {\n    window.tinycolor = tinycolor;\n}\n\n})(Math);\n","import TypeSelect from './type-select';\nimport tinycolor from 'tinycolor2';\n/**\n * WordPress dependencies\n */\nimport {\n\tPanelBody,\n\tRangeControl,\n\tPath,\n\tSVG\n} from '@wordpress/components';\nimport { __ } from '@wordpress/i18n';\nimport { Fragment } from '@wordpress/element';\nimport {\n\tInspectorControls,\n\tInnerBlocks,\n\tMediaUpload,\n\tMediaPlaceholder,\n\tColorPalette,\n\tgetColorObjectByColorValue,\n} from '@wordpress/editor';\nimport {\n\tselect\n} from '@wordpress/data';\n\nexport const name = 'gecko/grid-layout-item';\n\nexport const settings = {\n\ttitle: __( 'Item' ),\n\n\tparent: ['gecko/grid-layout'],\n\n\ticon: <SVG xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 24 24\"><Path fill=\"none\" d=\"M0 0h24v24H0V0z\" /><Path d=\"M11.99 18.54l-7.37-5.73L3 14.07l9 7 9-7-1.63-1.27zM12 16l7.36-5.73L21 9l-9-7-9 7 1.63 1.27L12 16zm0-11.47L17.74 9 12 13.47 6.26 9 12 4.53z\" /></SVG>,\n\n\tdescription: __( 'A single grid item within a grid block.' ),\n\n\tcategory: 'common',\n\n\tsupports: {\n\t\tclassName: true,\n\t\tinserter: true,\n\t\treusable: false,\n\t\thtml: false,\n\t},\n\n\tattributes: {\n\t\ttype:{\n\t\t\ttype: 'string',\n\t\t\tdefault: undefined, //solid // image //image-content\n\t\t},\n\t\topacity: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t\th: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t\tw: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 4,\n\t\t},\n\t\tbgMedia: {\n\t\t\ttype: 'number',\n\t\t},\n\t\tbgMediaUrl: {\n\t\t\ttype: 'string',\n\t\t},\n\t\tbgColor: {\n\t\t\ttype: 'string',\n\t\t},\n\t\tbgColorSlug: {\n\t\t\ttype: 'string',\n\t\t},\n\t\tbgColorBrightness: {\n\t\t\ttype: 'number', //light or dark\n\t\t},\n\t},\n\n\tedit({ attributes, setAttributes, className, insertBlocksAfter }) {\n\t\tconsole.log(arguments);\n\t\tconst {\n\t\t\topacity,\n\t\t\th,\n\t\t\tw,\n\t\t\ttype,\n\t\t\tbgMedia,\n\t\t\tbgMediaUrl,\n\t\t\tbgColor,\n\t\t\tbgColorBrightness,\n\t\t\tbgColorSlug,\n\t\t} = attributes;\n\t\tconst styles = {\n\t\t\t'--background': bgColor,\n\t\t\t'--opacity': opacity,\n\t\t\tgridColumnEnd: 'span '+ w,\n\t\t\tgridRowEnd: 'span ' + h,\n\t\t\tbackgroundColor: bgColor,\n\t\t\tbackgroundImage: 'url(' + bgMediaUrl + ')',\n\t\t};\n\t\tif(type === \"image\"){\n\t\t\tdelete(styles.backgroundColor);\n\t\t}\n\t\tif (type === \"solid\") {\n\t\t\tdelete(styles.backgroundImage);\n\t\t}\n\t\tlet lightOrDark = 'light';\n\t\tif (bgColorBrightness < 130) lightOrDark = 'dark';\n\t\treturn (\n\t\t\t<Fragment>\n\t\t\t\t<InspectorControls>\n\t\t\t\t\t<PanelBody title=\"Type\">\n\t\t\t\t\t\t<TypeSelect \n\t\t\t\t\t\t\tonSelect = {(next) => {\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\ttype: next,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\tvalue={type}\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t\t<PanelBody  title=\"Size Settings\">\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Height' ) }\n\t\t\t\t\t\t\tvalue={ h }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\th: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 1 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Width' ) }\n\t\t\t\t\t\t\tvalue={ w }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tw: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 1 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t\t<PanelBody title=\"Background Settings\">\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'image' || type === 'image-content') &&\n\t\t\t\t\t\t\t<MediaUpload\n\t\t\t\t\t\t\t\tonSelect={(value) => {\n\t\t\t\t\t\t\t\t\t// console.log(value);\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\tbgMedia: value.id,\n\t\t\t\t\t\t\t\t\t\tbgMediaUrl: value.url,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\t\ttype={['image', 'video']}\n\t\t\t\t\t\t\t\tvalue={(bgMedia)? bgMedia: null }\n\t\t\t\t\t\t\t\trender={({open}) => {\n\t\t\t\t\t\t\t\t\treturn(\n\t\t\t\t\t\t\t\t\t\t<div>\n\t\t\t\t\t\t\t\t\t\t\t{bgMediaUrl && <img src={bgMediaUrl} onClick={open} width=\"100%\" height=\"auto\" style={{cursor: \"pointer\"}}/>}\n\t\t\t\t\t\t\t\t\t\t\t{!bgMediaUrl && <div className={'button button-large'} onClick={open}>\n\t\t\t\t\t\t\t\t\t\t\t\tChoose Background\n\t\t\t\t\t\t\t\t\t\t\t</div>}\n\t\t\t\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t}\n\t\t\t\t\t\t<hr />\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'solid' || type === 'image-content') &&\n\t\t\t\t\t\t\t<div>\n\t\t\t\t\t\t\t\t<ColorPalette\n\t\t\t\t\t\t\t\t\tlabel='Background Color'\n\t\t\t\t\t\t\t\t\tvalue={(bgColor) ? bgColor.color : undefined}\n\t\t\t\t\t\t\t\t\tonChange = {\n\t\t\t\t\t\t\t\t\t\t(value) => {\n\t\t\t\t\t\t\t\t\t\t\tconst settings = select('core/editor').getEditorSettings();\n\t\t\t\t\t\t\t\t\t\t\tconst colorSlug = (value) ? getColorObjectByColorValue(settings.colors, value).slug : undefined;\n\t\t\t\t\t\t\t\t\t\t\tsetAttributes({bgColorSlug: colorSlug});\n\t\t\t\t\t\t\t\t\t\t\tconst brightness = (value) ? tinycolor(value).getBrightness(): undefined;\n\t\t\t\t\t\t\t\t\t\t\tsetAttributes({bgColorBrightness: brightness});\n\t\t\t\t\t\t\t\t\t\t\tsetAttributes({bgColor: value});\n\t\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t\t\t<hr />\n\t\t\t\t\t\t\t</div>\n\t\t\t\t\t\t}\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t(type === 'image-content') &&\n\t\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\t\tlabel={ __( 'Opacity' ) }\n\t\t\t\t\t\t\t\tvalue={ opacity }\n\t\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\t\topacity: next,\n\t\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\t\tmin = \"0\"\n\t\t\t\t\t\t\t\tmax = \"1\"\n\t\t\t\t\t\t\t\tstep = \"0.1\"\n\t\t\t\t\t\t\t/>\n\t\t\t\t\t\t}\n\t\t\t\t\t</PanelBody>\n\t\t\t\t</InspectorControls>\n\t\t\t\t< div className = {\n\t\t\t\t\t`wp-block-gecko-grid-layout-editor__item ${type} ${attributes.className} has-${bgColorSlug}-background-color is-${lightOrDark}-background`\n\t\t\t\t}\n\t\t\t\tstyle = {\n\t\t\t\t\tstyles\n\t\t\t\t} >\n\t\t\t\t\t<div className = \"wp-block-gecko-grid-layout-editor__wrap\">\n\t\t\t\t\t{!type && <TypeSelect \n\t\t\t\t\t\tonSelect = {(next) => {\n\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\ttype: next,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}}\n\t\t\t\t\t/>}\n\t\t\t\t\t{\n\t\t\t\t\t\t(type === 'image' || type === 'image-content') &&\n\t\t\t\t\t\t!bgMedia &&\n\t\t\t\t\t\t<MediaPlaceholder\n\t\t\t\t\t\t\tonSelect={(value) => {\n\t\t\t\t\t\t\t\t\tsetAttributes({\n\t\t\t\t\t\t\t\t\t\tbgMedia: value.id,\n\t\t\t\t\t\t\t\t\t\tbgMediaUrl: value.url,\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}}\n\t\t\t\t\t\t\tallowedTypes={['image']}\n\t\t\t\t\t\t\taccept=\"image/*\"\n\t\t\t\t\t\t/>\n\t\t\t\t\t}\n\t\t\t\t\t{ \n\t\t\t\t\t\t(type === 'solid' || (type === 'image-content' && bgMedia)) &&\n\t\t\t\t\t\t<InnerBlocks templateLock={ false } />\n\t\t\t\t\t}\n\t\t\t\t\t</div>\n\t\t\t\t</div>\n\t\t\t</Fragment>\n\t\t);\n\t},\n\n\tsave() {\n\t\treturn <div><InnerBlocks.Content /></div>;\n\t},\n};\n","/**\n * WordPress dependencies\n */\nimport { __ } from '@wordpress/i18n';\nimport { PanelBody, RangeControl, G, SVG, Path } from '@wordpress/components';\nimport { Fragment } from '@wordpress/element';\nimport {\n\tInspectorControls,\n\tInnerBlocks,\n} from '@wordpress/editor';\n\n/**\n * Allowed blocks constant is passed to InnerBlocks precisely as specified here.\n * The contents of the array should never change.\n * The array should contain the name of each block that is allowed.\n * In columns block, the only block we allow is 'dmp/grid-item'.\n *\n * @constant\n * @type {string[]}\n*/\nconst ALLOWED_BLOCKS = ['gecko/grid-layout-item'];\n\nexport const name = 'gecko/grid-layout';\n\nexport const settings = {\n\ttitle: __( 'Grid' ),\n\n\ticon: <SVG viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><Path fill=\"none\" d=\"M0 0h24v24H0V0z\" /><G><Path d=\"M4,13 L8,13 L8,10 L4,10 L4,13 Z M4,15 L4,18 L8,18 L8,15 L4,15 Z M10,13 L14,13 L14,10 L10,10 L10,13 Z M10,15 L10,18 L14,18 L14,15 L10,15 Z M20,13 L20,10 L16,10 L16,13 L20,13 Z M20,15 L16,15 L16,18 L20,18 L20,15 Z M4,8 L8,8 L8,5 L4,5 L4,8 Z M10,8 L14,8 L14,5 L10,5 L10,8 Z M20,8 L20,5 L16,5 L16,8 L20,8 Z M4,3 L20,3 C21.1045695,3 22,3.95139491 22,5.125 L22,17.875 C22,19.0486051 21.1045695,20 20,20 L4,20 C2.8954305,20 2,19.0486051 2,17.875 L2,5.125 C2,3.95139491 2.8954305,3 4,3 Z\" /></G></SVG>,\n\n\tcategory: 'layout',\n\n\tattributes: {\n\t\tcolumns: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 12,\n\t\t},\n\t\tgap: {\n\t\t\ttype: 'number',\n\t\t\tdefault: 1,\n\t\t},\n\t},\n\n\tdescription: __( 'Use CSS Grid to build layouts and, then add whatever content blocks you’d like.' ),\n\n\tsupports: {\n\t\talign: [ 'wide', 'full' ],\n\t\thtml: false,\n\t},\n\n\tdeprecated: [],\n\n\tedit( { attributes, setAttributes } ) {\n\t\tconst { columns, gap } = attributes;\n\t\t// const styles = 'grid-template-columns: repeat(' + columns + ', minmax(100px, 1fr));\tgrid-auto-rows: minmax(100px, auto); grid-gap:' + gap + 'rem;';\n\t\tconst styles = 'grid-gap:' + gap + 'rem;';\n\n\t\treturn (\n\t\t\t<Fragment>\n\t\t\t\t<InspectorControls>\n\t\t\t\t\t<PanelBody>\n\t\t\t\t\t\t{/* <RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Grid Layout' ) }\n\t\t\t\t\t\t\tvalue={ columns }\n\t\t\t\t\t\t\tonChange={ ( nextColumns ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tcolumns: nextColumns,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 2 }\n\t\t\t\t\t\t\tmax={ 12 }\n\t\t\t\t\t\t/> */}\n\t\t\t\t\t\t<RangeControl\n\t\t\t\t\t\t\tlabel={ __( 'Gap' ) }\n\t\t\t\t\t\t\tvalue={ gap }\n\t\t\t\t\t\t\tonChange={ ( next ) => {\n\t\t\t\t\t\t\t\tsetAttributes( {\n\t\t\t\t\t\t\t\t\tgap: next,\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} }\n\t\t\t\t\t\t\tmin={ 0 }\n\t\t\t\t\t\t\tmax={ 2 }\n\t\t\t\t\t\t/>\n\t\t\t\t\t</PanelBody>\n\t\t\t\t</InspectorControls>\n\t\t\t\t<div className=\"wp-block-gecko-grid-layout-editor\" data-passthru={styles} data-grid={columns}>\n\t\t\t\t\t<InnerBlocks\n\t\t\t\t\t\ttemplate = {\n\t\t\t\t\t\t\t[\n\t\t\t\t\t\t\t\t['gecko/grid-layout-item'],\n\t\t\t\t\t\t\t\t['gecko/grid-layout-item']\n\t\t\t\t\t\t\t]\n\t\t\t\t\t\t}\n\t\t\t\t\t\ttemplateLock={false}\n\t\t\t\t\t\tallowedBlocks={ ALLOWED_BLOCKS }\n\t\t\t\t\t\t/>\n\t\t\t\t</div>\n\t\t\t</Fragment>\n\t\t);\n\t},\n\n\tsave() {\n\t\treturn (\n\t\t\t<div>\n\t\t\t\t<InnerBlocks.Content />\n\t\t\t</div>\n\t\t);\n\t},\n};\n","/**\n * WordPress dependencies\n */\nimport {registerBlockType} from '@wordpress/blocks';\n\n/**\n * Internal dependencies\n */\nimport * as grid from './grid-layout';\nimport * as gridItem from './grid-layout-item';\n\nregisterBlockType(grid.name, grid.settings);\nregisterBlockType(gridItem.name, gridItem.settings);\n\n/**\n * This make sure the grid works in the editor.\n */\njQuery(function ($) {\n\n\tfunction listenForStyleChangesGridItem() {\n\t\t$('.wp-block-gecko-grid-layout-editor__item').each(function () {\n\t\t\tconst observer = new MutationObserver(function (mutations) {\n\t\t\t\tmutations.forEach(function (mutation) {\n\t\t\t\t\t// On change update the styles\n\t\t\t\t\t$('[data-type=\"gecko/grid-layout-item\"]').each(function () {\n\t\t\t\t\t\tconst styles = $(this).find(\".wp-block-gecko-grid-layout-editor__item\").attr(\"style\");\n\t\t\t\t\t\t$(this).attr(\"style\", styles);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t});\n\t\t\tobserver.disconnect();\n\t\t\tobserver.observe(this, {\n\t\t\t\tattributes: true,\n\t\t\t\tattributeFilter: ['style']\n\t\t\t});\n\t\t});\n\t}\n\n\tfunction listenForStyleChangesGrid() {\n\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\tconst observer = new MutationObserver(function (mutations) {\n\t\t\t\tmutations.forEach(function (mutation) {\n\t\t\t\t\t// On change update the styles\n\t\t\t\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\t\t\t\tconst styles = $(this).attr(\"data-passthru\");\n\t\t\t\t\t\tconst grid = $(this).attr(\"data-grid\");\n\t\t\t\t\t\t$(this).find(\".editor-block-list__layout\").attr(\"style\", styles);\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t});\n\t\t\tobserver.disconnect();\n\t\t\tobserver.observe(this, {\n\t\t\t\tattributes: true,\n\t\t\t\tattributeFilter: ['data-passthru', 'style'],\n\t\t\t});\n\t\t});\n\t}\n\n\tfunction updateStylesGridItem() {\n\t\t$('[data-type=\"gecko/grid-layout-item\"]').each(function () {\n\t\t\tconst styles = $(this).find(\".wp-block-gecko-grid-layout-editor__item\").attr(\"style\");\n\t\t\t$(this).attr(\"style\", styles);\n\t\t});\n\t}\n\n\tfunction updateStylesGrid() {\n\t\t$('.wp-block-gecko-grid-layout-editor').each(function () {\n\t\t\tconst styles = $(this).attr(\"data-passthru\");\n\t\t\tconst grid = $(this).attr(\"data-grid\");\n\t\t\t$(this).find(\".editor-block-list__layout\").attr(\"style\", styles);\n\t\t});\n\t}\n\n\t$('body').on('DOMNodeInserted', '.wp-block-gecko-grid-layout-editor', function (e) {\n\t\tif ($('.wp-block-gecko-grid-layout-editor')){\n\t\t\tupdateStylesGrid();\n\t\t\tupdateStylesGridItem();\n\t\t\tlistenForStyleChangesGrid()\n\t\t\tlistenForStyleChangesGridItem();\n\t\t}\n\t});\n\n\t$(window).load(function () {\n\t\tupdateStylesGrid();\n\t\tupdateStylesGridItem();\n\t\tlistenForStyleChangesGrid()\n\t\tlistenForStyleChangesGridItem();\n\t});\n});","import { __ } from '@wordpress/i18n';\n// import { Fragment } from '@wordpress/element';\nexport default function({value, onSelect}){\n\tconst selected = (next) => {\n\t\treturn onSelect(next);\n\t}\n\tconst types = [\n\t\t{ slug: 'solid', name: 'Solid', icon: <span class=\"dashicons dashicons-admin-appearance\"></span>},\n\t\t{ slug: 'image', name: 'Image', icon: <span class=\"dashicons dashicons-format-image\"></span>},\n\t\t{ slug: 'image-content', name: 'Image with Content', icon: <span class=\"dashicons dashicons-format-gallery\"></span>},\n\t]\n\treturn(\n\t\t<div className=\"wp-block-gecko-grid-layout-type-select\">\n\t\t\t<p>Choose the block layout type.</p>\n\t\t\t{types.map((type) => {\n\t\t\t\tlet isSelected = \"\";\n\t\t\t\tif(type.slug === value){\n\t\t\t\t\tisSelected = \"wp-block-gecko-grid-layout-type-select__item--selected\"\n\t\t\t\t}\n\t\t\t\treturn (\n\t\t\t\t\t<div className={`wp-block-gecko-grid-layout-type-select__item ${isSelected}`} onClick={()=> selected(type.slug)}>{type.icon}{type.name}</div>\n\t\t\t\t);\n\t\t\t})}\n\t\t</div>\n\t);\n}","module.exports = window.wp.blocks;","module.exports = window.wp.components;","module.exports = window.wp.data;","module.exports = window.wp.editor;","module.exports = window.wp.element;","module.exports = window.wp.i18n;","module.exports = React;"],"sourceRoot":""}

gecko-grid-layout/trunk/gecko-grid-layout.php

@@ -4 +4 @@
  * Plugin URI:  https://github.com/gecko-designs/gecko-grid-layout
  * Description: Grid Layout block uses CSS grid to create grid layouts in gutenberg.
- * Version: 1.0.1
+ * Version: 1.0.2
  * Author: Gecko Designs
  * Author URI: https://geckodesigns.com
@@ -90 +90 @@
         $spanRow = (isset($attributes['h'])) ? "grid-row-end: span ".$attributes['h'].";" : "";
         $opacity = (isset($attributes['opacity'])) ? "--opacity: ".$attributes['opacity'].";" : "";
+        $bgColorSlug = (isset($attributes['bgColorSlug'])) ? ' has-'.$attributes['bgColorSlug'].'-background-color' : "";
+        $bgBrightness = (isset($attributes['bgColorBrightness']) && $attributes['bgColorBrightness'] < 130) ? "dark" : "light";
         $styles = $spanColumn.$spanRow.$bgColor;
         $styles .= ($type === 'image' || $type === 'image-content') ? $bgMedia : '';
@@ -95 +97 @@
         $content = ($type === 'image') ? '' : $content ;
         $class = 'wp-block-gecko-grid-layout__item wp-block-gecko-grid-layout__item--'.$type;
+        $class .= ' is-'.$bgBrightness.'-background';
+        $class .= $bgColorSlug;
         // $encoded = json_encode($attributes, JSON_HEX_APOS|JSON_HEX_QUOT);
         return sprintf('<div class="%s" style="%s">%s</div>',

gecko-grid-layout/trunk/readme.txt

@@ -5 +5 @@
 Requires at least: 5.0
 Tested up to: 5.0.3
-Stable tag: 1.0
+Stable tag: 1.0.2
 Requires PHP: 5.6
 License: GPLv2 or later
@@ -27 +27 @@
 
 == Upgrade Notice ==
+= 1.0.2 =
+* Added background dark and light class based on bg color.(is-light-background, is-dark-background)
+* Added background color class.(has-[color]-background-color)
+= 1.0.1 =
+* Using a 12 column grid for now with plans to allow different grids in the future.
 = 1.0 =
 * Initial release
-= 1.0.1 =
-* Using a 12 column grid for now with plans to allow different grids in the future.
 
 == Screenshots ==