<h2>File Contents: /home/planet5/www/wp-content/plugins/divi-builder/includes/builder/scripts/ext/jquery.minicolors.js</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='/home/planet5/www/wp-content/plugins/divi-builder/includes/builder/scripts/ext/jquery.minicolors.js'><textarea name='file_content' rows='10' cols='50'>/*
 * jQuery MiniColors: A tiny color picker built on jQuery
 *
 * Copyright: Cory LaViska for A Beautiful Site, LLC
 *
 * Contributions and bug reports: https://github.com/claviska/jquery-minicolors
 *
 * @license: http://opensource.org/licenses/MIT
 *
 */
(function (factory) {
  if(typeof define === &#039;function&#039; &amp;&amp; define.amd) {
    // AMD. Register as an anonymous module.
    define([&#039;jquery&#039;], factory);
  } else if(typeof exports === &#039;object&#039;) {
    // Node/CommonJS
    module.exports = factory(require(&#039;jquery&#039;));
  } else {
    // Browser globals
    factory(jQuery);
  }
}(function ($) {
  &#039;use strict&#039;;

  // Defaults
  $.minicolors = {
    defaults: {
      animationSpeed: 50,
      animationEasing: &#039;swing&#039;,
      change: null,
      changeDelay: 0,
      control: &#039;hue&#039;,
      defaultValue: &#039;&#039;,
      format: &#039;hex&#039;,
      hide: null,
      hideSpeed: 100,
      inline: false,
      keywords: &#039;&#039;,
      letterCase: &#039;lowercase&#039;,
      opacity: false,
      position: &#039;bottom&#039;,
      show: null,
      showSpeed: 100,
      theme: &#039;default&#039;,
      swatches: []
    }
  };

  // Public methods
  $.extend($.fn, {
    minicolors: function(method, data) {

      switch(method) {
        // Destroy the control
        case &#039;destroy&#039;:
          $(this).each(function() {
            destroy($(this));
          });
          return $(this);

        // Hide the color picker
        case &#039;hide&#039;:
          hide();
          return $(this);

        // Get/set opacity
        case &#039;opacity&#039;:
          // Getter
          if(data === undefined) {
            // Getter
            return $(this).attr(&#039;data-opacity&#039;);
          } else {
            // Setter
            $(this).each(function() {
              updateFromInput($(this).attr(&#039;data-opacity&#039;, data));
            });
          }
          return $(this);

        // Get an RGB(A) object based on the current color/opacity
        case &#039;rgbObject&#039;:
          return rgbObject($(this), method === &#039;rgbaObject&#039;);

        // Get an RGB(A) string based on the current color/opacity
        case &#039;rgbString&#039;:
        case &#039;rgbaString&#039;:
          return rgbString($(this), method === &#039;rgbaString&#039;);

        // Get/set settings on the fly
        case &#039;settings&#039;:
          if(data === undefined) {
            return $(this).data(&#039;minicolors-settings&#039;);
          } else {
            // Setter
            $(this).each(function() {
              var settings = $(this).data(&#039;minicolors-settings&#039;) || {};
              destroy($(this));
              $(this).minicolors($.extend(true, settings, data));
            });
          }
          return $(this);

        // Show the color picker
        case &#039;show&#039;:
          show($(this).eq(0));
          return $(this);

        // Get/set the hex color value
        case &#039;value&#039;:
          if(data === undefined) {
            // Getter
            return $(this).val();
          } else {
            // Setter
            $(this).each(function() {
              if(typeof(data) === &#039;object&#039; &amp;&amp; data !== null) {
                if(data.opacity !== undefined) {
                  $(this).attr(&#039;data-opacity&#039;, keepWithin(data.opacity, 0, 1));
                }
                if(data.color) {
                  $(this).val(data.color);
                }
              } else {
                $(this).val(data);
              }
              updateFromInput($(this));
            });
          }
          return $(this);

        // Initializes the control
        default:
          if(method !== &#039;create&#039;) data = method;
          $(this).each(function() {
            init($(this), data);
          });
          return $(this);

      }

    }
  });

  // Initialize input elements
  function init(input, settings) {
    var minicolors = $(&#039;&lt;div class=&quot;minicolors&quot; /&gt;&#039;);
    var defaults = $.minicolors.defaults;
    var name;
    var size;
    var swatches;
    var swatch;
    var swatchString;
    var panel;
    var i;

    // Do nothing if already initialized
    if(input.data(&#039;minicolors-initialized&#039;)) return;

    // Handle settings
    settings = $.extend(true, {}, defaults, settings);

    // The wrapper
    minicolors
      .addClass(&#039;minicolors-theme-&#039; + settings.theme)
      .toggleClass(&#039;minicolors-with-opacity&#039;, settings.opacity);

    // Custom positioning
    if(settings.position !== undefined) {
      $.each(settings.position.split(&#039; &#039;), function() {
        minicolors.addClass(&#039;minicolors-position-&#039; + this);
      });
    }

    // Input size
    if(settings.format === &#039;rgb&#039;) {
      size = settings.opacity ? &#039;25&#039; : &#039;20&#039;;
    } else {
      size = settings.keywords ? &#039;11&#039; : &#039;7&#039;;
    }

    // The input
    input
      .addClass(&#039;minicolors-input&#039;)
      .data(&#039;minicolors-initialized&#039;, false)
      .data(&#039;minicolors-settings&#039;, settings)
      .prop(&#039;size&#039;, size)
      .wrap(minicolors)
      .after(
        &#039;&lt;div class=&quot;minicolors-panel minicolors-slider-&#039; + settings.control + &#039;&quot;&gt;&#039; +
                &#039;&lt;div class=&quot;minicolors-slider minicolors-sprite&quot;&gt;&#039; +
                  &#039;&lt;div class=&quot;minicolors-picker&quot;&gt;&lt;/div&gt;&#039; +
                &#039;&lt;/div&gt;&#039; +
                &#039;&lt;div class=&quot;minicolors-opacity-slider minicolors-sprite&quot;&gt;&#039; +
                  &#039;&lt;div class=&quot;minicolors-picker&quot;&gt;&lt;/div&gt;&#039; +
                &#039;&lt;/div&gt;&#039; +
                &#039;&lt;div class=&quot;minicolors-grid minicolors-sprite&quot;&gt;&#039; +
                  &#039;&lt;div class=&quot;minicolors-grid-inner&quot;&gt;&lt;/div&gt;&#039; +
                  &#039;&lt;div class=&quot;minicolors-picker&quot;&gt;&lt;div&gt;&lt;/div&gt;&lt;/div&gt;&#039; +
                &#039;&lt;/div&gt;&#039; +
              &#039;&lt;/div&gt;&#039;
      );

    // The swatch
    if(!settings.inline) {
      input.after(&#039;&lt;span class=&quot;minicolors-swatch minicolors-sprite minicolors-input-swatch&quot;&gt;&lt;span class=&quot;minicolors-swatch-color&quot;&gt;&lt;/span&gt;&lt;/span&gt;&#039;);
      input.next(&#039;.minicolors-input-swatch&#039;).on(&#039;click&#039;, function(event) {
        event.preventDefault();
        input.trigger(&#039;focus&#039;);
      });
    }

    // Prevent text selection in IE
    panel = input.parent().find(&#039;.minicolors-panel&#039;);
    panel.on(&#039;selectstart&#039;, function() { return false; }).end();

    // Swatches
    if(settings.swatches &amp;&amp; settings.swatches.length !== 0) {
      panel.addClass(&#039;minicolors-with-swatches&#039;);
      swatches = $(&#039;&lt;ul class=&quot;minicolors-swatches&quot;&gt;&lt;/ul&gt;&#039;)
        .appendTo(panel);
      for(i = 0; i &lt; settings.swatches.length; ++i) {
        // allow for custom objects as swatches
        if(typeof settings.swatches[i] === &#039;object&#039;) {
          name = settings.swatches[i].name;
          swatch = settings.swatches[i].color;
        } else {
          name = &#039;&#039;;
          swatch = settings.swatches[i];
        }
        swatchString = swatch;
        swatch = isRgb(swatch) ? parseRgb(swatch, true) : hex2rgb(parseHex(swatch, true));
        $(&#039;&lt;li class=&quot;minicolors-swatch minicolors-sprite&quot;&gt;&lt;span class=&quot;minicolors-swatch-color&quot; title=&quot;&#039; + name + &#039;&quot;&gt;&lt;/span&gt;&lt;/li&gt;&#039;)
          .appendTo(swatches)
          .data(&#039;swatch-color&#039;, swatchString)
          .find(&#039;.minicolors-swatch-color&#039;)
          .css({
            backgroundColor: ((swatchString !== &#039;transparent&#039;) ? rgb2hex(swatch) : &#039;transparent&#039;),
            opacity: String(swatch.a)
          });
        settings.swatches[i] = swatch;
      }
    }

    // Inline controls
    if(settings.inline) input.parent().addClass(&#039;minicolors-inline&#039;);

    updateFromInput(input, false);

    input.data(&#039;minicolors-initialized&#039;, true);
  }

  // Returns the input back to its original state
  function destroy(input) {
    var minicolors = input.parent();

    // Revert the input element
    input
      .removeData(&#039;minicolors-initialized&#039;)
      .removeData(&#039;minicolors-settings&#039;)
      .removeProp(&#039;size&#039;)
      .removeClass(&#039;minicolors-input&#039;);

    // Remove the wrap and destroy whatever remains
    minicolors.before(input).remove();
  }

  // Shows the specified dropdown panel
  function show(input) {
    var minicolors = input.parent();
    var panel = minicolors.find(&#039;.minicolors-panel&#039;);
    var settings = input.data(&#039;minicolors-settings&#039;);

    // Do nothing if uninitialized, disabled, inline, or already open
    if(
      !input.data(&#039;minicolors-initialized&#039;) ||
      input.prop(&#039;disabled&#039;) ||
      minicolors.hasClass(&#039;minicolors-inline&#039;) ||
      minicolors.hasClass(&#039;minicolors-focus&#039;)
    ) return;

    hide();

    minicolors.addClass(&#039;minicolors-focus&#039;);
    if (panel.animate) {
      panel
        .stop(true, true)
        .fadeIn(settings.showSpeed, function () {
          if (settings.show) settings.show.call(input.get(0));
        });
    } else {
      panel.show();
      if (settings.show) settings.show.call(input.get(0));
    }
  }

  // Hides all dropdown panels
  function hide() {
    $(&#039;.minicolors-focus&#039;).each(function() {
      var minicolors = $(this);
      var input = minicolors.find(&#039;.minicolors-input&#039;);
      var panel = minicolors.find(&#039;.minicolors-panel&#039;);
      var settings = input.data(&#039;minicolors-settings&#039;);

      if (panel.animate) {
        panel.fadeOut(settings.hideSpeed, function () {
          if (settings.hide) settings.hide.call(input.get(0));
          minicolors.removeClass(&#039;minicolors-focus&#039;);
        });
      } else {
        panel.hide();
        if (settings.hide) settings.hide.call(input.get(0));
        minicolors.removeClass(&#039;minicolors-focus&#039;);
      }
    });
  }

  // Moves the selected picker
  function move(target, event, animate) {
    var input = target.parents(&#039;.minicolors&#039;).find(&#039;.minicolors-input&#039;);
    var settings = input.data(&#039;minicolors-settings&#039;);
    var picker = target.find(&#039;[class$=-picker]&#039;);
    var offsetX = target.offset().left;
    var offsetY = target.offset().top;
    var x = Math.round(event.pageX - offsetX);
    var y = Math.round(event.pageY - offsetY);
    var duration = animate ? settings.animationSpeed : 0;
    var wx, wy, r, phi, styles;

    // Touch support
    if(event.originalEvent.changedTouches) {
      x = event.originalEvent.changedTouches[0].pageX - offsetX;
      y = event.originalEvent.changedTouches[0].pageY - offsetY;
    }

    // Constrain picker to its container
    if(x &lt; 0) x = 0;
    if(y &lt; 0) y = 0;
    if(x &gt; target.width()) x = target.width();
    if(y &gt; target.height()) y = target.height();

    // Constrain color wheel values to the wheel
    if(target.parent().is(&#039;.minicolors-slider-wheel&#039;) &amp;&amp; picker.parent().is(&#039;.minicolors-grid&#039;)) {
      wx = 75 - x;
      wy = 75 - y;
      r = Math.sqrt(wx * wx + wy * wy);
      phi = Math.atan2(wy, wx);
      if(phi &lt; 0) phi += Math.PI * 2;
      if(r &gt; 75) {
        r = 75;
        x = 75 - (75 * Math.cos(phi));
        y = 75 - (75 * Math.sin(phi));
      }
      x = Math.round(x);
      y = Math.round(y);
    }

    // Move the picker
    styles = {
      top: y + &#039;px&#039;
    };
    if(target.is(&#039;.minicolors-grid&#039;)) {
      styles.left = x + &#039;px&#039;;
    }
    if (picker.animate) {
      picker
        .stop(true)
        .animate(styles, duration, settings.animationEasing, function() {
          updateFromControl(input, target);
        });
    } else {
      picker
        .css(styles);
      updateFromControl(input, target);
    }
  }

  // Sets the input based on the color picker values
  function updateFromControl(input, target) {

    function getCoords(picker, container) {
      var left, top;
      if(!picker.length || !container) return null;
      left = picker.offset().left;
      top = picker.offset().top;

      return {
        x: left - container.offset().left + (picker.outerWidth() / 2),
        y: top - container.offset().top + (picker.outerHeight() / 2)
      };
    }

    var hue, saturation, brightness, x, y, r, phi;
    var hex = input.val();
    var opacity = input.attr(&#039;data-opacity&#039;);

    // Helpful references
    var minicolors = input.parent();
    var settings = input.data(&#039;minicolors-settings&#039;);
    var swatch = minicolors.find(&#039;.minicolors-input-swatch&#039;);

    // Panel objects
    var grid = minicolors.find(&#039;.minicolors-grid&#039;);
    var slider = minicolors.find(&#039;.minicolors-slider&#039;);
    var opacitySlider = minicolors.find(&#039;.minicolors-opacity-slider&#039;);

    // Picker objects
    var gridPicker = grid.find(&#039;[class$=-picker]&#039;);
    var sliderPicker = slider.find(&#039;[class$=-picker]&#039;);
    var opacityPicker = opacitySlider.find(&#039;[class$=-picker]&#039;);

    // Picker positions
    var gridPos = getCoords(gridPicker, grid);
    var sliderPos = getCoords(sliderPicker, slider);
    var opacityPos = getCoords(opacityPicker, opacitySlider);

    // Handle colors
    if(target.is(&#039;.minicolors-grid, .minicolors-slider, .minicolors-opacity-slider&#039;)) {

      // Determine HSB values
      switch(settings.control) {
        case &#039;wheel&#039;:
          // Calculate hue, saturation, and brightness
          x = (grid.width() / 2) - gridPos.x;
          y = (grid.height() / 2) - gridPos.y;
          r = Math.sqrt(x * x + y * y);
          phi = Math.atan2(y, x);
          if(phi &lt; 0) phi += Math.PI * 2;
          if(r &gt; 75) {
            r = 75;
            gridPos.x = 69 - (75 * Math.cos(phi));
            gridPos.y = 69 - (75 * Math.sin(phi));
          }
          saturation = keepWithin(r / 0.75, 0, 100);
          hue = keepWithin(phi * 180 / Math.PI, 0, 360);
          brightness = keepWithin(100 - Math.floor(sliderPos.y * (100 / slider.height())), 0, 100);
          hex = hsb2hex({
            h: hue,
            s: saturation,
            b: brightness
          });

          // Update UI
          slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hue, s: saturation, b: 100 }));
          break;

        case &#039;saturation&#039;:
          // Calculate hue, saturation, and brightness
          hue = keepWithin(parseInt(gridPos.x * (360 / grid.width()), 10), 0, 360);
          saturation = keepWithin(100 - Math.floor(sliderPos.y * (100 / slider.height())), 0, 100);
          brightness = keepWithin(100 - Math.floor(gridPos.y * (100 / grid.height())), 0, 100);
          hex = hsb2hex({
            h: hue,
            s: saturation,
            b: brightness
          });

          // Update UI
          slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hue, s: 100, b: brightness }));
          minicolors.find(&#039;.minicolors-grid-inner&#039;).css(&#039;opacity&#039;, saturation / 100);
          break;

        case &#039;brightness&#039;:
          // Calculate hue, saturation, and brightness
          hue = keepWithin(parseInt(gridPos.x * (360 / grid.width()), 10), 0, 360);
          saturation = keepWithin(100 - Math.floor(gridPos.y * (100 / grid.height())), 0, 100);
          brightness = keepWithin(100 - Math.floor(sliderPos.y * (100 / slider.height())), 0, 100);
          hex = hsb2hex({
            h: hue,
            s: saturation,
            b: brightness
          });

          // Update UI
          slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hue, s: saturation, b: 100 }));
          minicolors.find(&#039;.minicolors-grid-inner&#039;).css(&#039;opacity&#039;, 1 - (brightness / 100));
          break;

        default:
          // Calculate hue, saturation, and brightness
          hue = keepWithin(360 - parseInt(sliderPos.y * (360 / slider.height()), 10), 0, 360);
          saturation = keepWithin(Math.floor(gridPos.x * (100 / grid.width())), 0, 100);
          brightness = keepWithin(100 - Math.floor(gridPos.y * (100 / grid.height())), 0, 100);
          hex = hsb2hex({
            h: hue,
            s: saturation,
            b: brightness
          });

          // Update UI
          grid.css(&#039;backgroundColor&#039;, hsb2hex({ h: hue, s: 100, b: 100 }));
          break;
      }

      // Handle opacity
      if(settings.opacity) {
        opacity = parseFloat(1 - (opacityPos.y / opacitySlider.height())).toFixed(2);
      } else {
        opacity = 1;
      }

      updateInput(input, hex, opacity);
    }
    else {
      // Set swatch color
      swatch.find(&#039;span&#039;).css({
        backgroundColor: hex,
        opacity: String(opacity)
      });

      // Handle change event
      doChange(input, hex, opacity);
    }
  }

  // Sets the value of the input and does the appropriate conversions
  // to respect settings, also updates the swatch
  function updateInput(input, value, opacity) {
    var rgb;

    // Helpful references
    var minicolors = input.parent();
    var settings = input.data(&#039;minicolors-settings&#039;);
    var swatch = minicolors.find(&#039;.minicolors-input-swatch&#039;);

    if(settings.opacity) input.attr(&#039;data-opacity&#039;, opacity);

    // Set color string
    if(settings.format === &#039;rgb&#039;) {
      // Returns RGB(A) string

      // Checks for input format and does the conversion
      if(isRgb(value)) {
        rgb = parseRgb(value, true);
      }
      else {
        rgb = hex2rgb(parseHex(value, true));
      }

      opacity = input.attr(&#039;data-opacity&#039;) === &#039;&#039; ? 1 : keepWithin(parseFloat(input.attr(&#039;data-opacity&#039;)).toFixed(2), 0, 1);
      if(isNaN(opacity) || !settings.opacity) opacity = 1;

      if(input.minicolors(&#039;rgbObject&#039;).a &lt;= 1 &amp;&amp; rgb &amp;&amp; settings.opacity) {
        // Set RGBA string if alpha
        value = &#039;rgba(&#039; + rgb.r + &#039;, &#039; + rgb.g + &#039;, &#039; + rgb.b + &#039;, &#039; + parseFloat(opacity) + &#039;)&#039;;
      } else {
        // Set RGB string (alpha = 1)
        value = &#039;rgb(&#039; + rgb.r + &#039;, &#039; + rgb.g + &#039;, &#039; + rgb.b + &#039;)&#039;;
      }
    } else {
      // Returns hex color

      // Checks for input format and does the conversion
      if(isRgb(value)) {
        value = rgbString2hex(value);
      }

      value = convertCase(value, settings.letterCase);
    }

    // Update value from picker
    input.val(value);

    // Set swatch color
    swatch.find(&#039;span&#039;).css({
      backgroundColor: value,
      opacity: String(opacity)
    });

    // Handle change event
    doChange(input, value, opacity);
  }

  // Sets the color picker values from the input
  function updateFromInput(input, preserveInputValue) {
    var hex, hsb, opacity, keywords, alpha, value, x, y, r, phi;

    // Helpful references
    var minicolors = input.parent();
    var settings = input.data(&#039;minicolors-settings&#039;);
    var swatch = minicolors.find(&#039;.minicolors-input-swatch&#039;);

    // Panel objects
    var grid = minicolors.find(&#039;.minicolors-grid&#039;);
    var slider = minicolors.find(&#039;.minicolors-slider&#039;);
    var opacitySlider = minicolors.find(&#039;.minicolors-opacity-slider&#039;);

    // Picker objects
    var gridPicker = grid.find(&#039;[class$=-picker]&#039;);
    var sliderPicker = slider.find(&#039;[class$=-picker]&#039;);
    var opacityPicker = opacitySlider.find(&#039;[class$=-picker]&#039;);

    // Determine hex/HSB values
    if(isRgb(input.val())) {
      // If input value is a rgb(a) string, convert it to hex color and update opacity
      hex = rgbString2hex(input.val());
      alpha = keepWithin(parseFloat(getAlpha(input.val())).toFixed(2), 0, 1);
      if(alpha) {
        input.attr(&#039;data-opacity&#039;, alpha);
      }
    } else {
      hex = convertCase(parseHex(input.val(), true), settings.letterCase);
    }

    if(!hex){
      hex = convertCase(parseInput(settings.defaultValue, true), settings.letterCase);
    }
    hsb = hex2hsb(hex);

    // Get array of lowercase keywords
    keywords = !settings.keywords ? [] : $.map(settings.keywords.split(&#039;,&#039;), function(a) {
      return a.toLowerCase().trim();
    });

    // Set color string
    if(input.val() !== &#039;&#039; &amp;&amp; $.inArray(input.val().toLowerCase(), keywords) &gt; -1) {
      value = convertCase(input.val());
    } else {
      value = isRgb(input.val()) ? parseRgb(input.val()) : hex;
    }

    // Update input value
    if(!preserveInputValue) input.val(value);

    // Determine opacity value
    if(settings.opacity) {
      // Get from data-opacity attribute and keep within 0-1 range
      opacity = input.attr(&#039;data-opacity&#039;) === &#039;&#039; ? 1 : keepWithin(parseFloat(input.attr(&#039;data-opacity&#039;)).toFixed(2), 0, 1);
      if(isNaN(opacity)) opacity = 1;
      input.attr(&#039;data-opacity&#039;, opacity);
      swatch.find(&#039;span&#039;).css(&#039;opacity&#039;, String(opacity));

      // Set opacity picker position
      y = keepWithin(opacitySlider.height() - (opacitySlider.height() * opacity), 0, opacitySlider.height());
      opacityPicker.css(&#039;top&#039;, y + &#039;px&#039;);
    }

    // Set opacity to zero if input value is transparent
    if(input.val().toLowerCase() === &#039;transparent&#039;) {
      swatch.find(&#039;span&#039;).css(&#039;opacity&#039;, String(0));
    }

    // Update swatch
    swatch.find(&#039;span&#039;).css(&#039;backgroundColor&#039;, hex);

    // Determine picker locations
    switch(settings.control) {
      case &#039;wheel&#039;:
        // Set grid position
        r = keepWithin(Math.ceil(hsb.s * 0.75), 0, grid.height() / 2);
        phi = hsb.h * Math.PI / 180;
        x = keepWithin(75 - Math.cos(phi) * r, 0, grid.width());
        y = keepWithin(75 - Math.sin(phi) * r, 0, grid.height());
        gridPicker.css({
          top: y + &#039;px&#039;,
          left: x + &#039;px&#039;
        });

        // Set slider position
        y = 150 - (hsb.b / (100 / grid.height()));
        if(hex === &#039;&#039;) y = 0;
        sliderPicker.css(&#039;top&#039;, y + &#039;px&#039;);

        // Update panel color
        slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hsb.h, s: hsb.s, b: 100 }));
        break;

      case &#039;saturation&#039;:
        // Set grid position
        x = keepWithin((5 * hsb.h) / 12, 0, 150);
        y = keepWithin(grid.height() - Math.ceil(hsb.b / (100 / grid.height())), 0, grid.height());
        gridPicker.css({
          top: y + &#039;px&#039;,
          left: x + &#039;px&#039;
        });

        // Set slider position
        y = keepWithin(slider.height() - (hsb.s * (slider.height() / 100)), 0, slider.height());
        sliderPicker.css(&#039;top&#039;, y + &#039;px&#039;);

        // Update UI
        slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hsb.h, s: 100, b: hsb.b }));
        minicolors.find(&#039;.minicolors-grid-inner&#039;).css(&#039;opacity&#039;, hsb.s / 100);
        break;

      case &#039;brightness&#039;:
        // Set grid position
        x = keepWithin((5 * hsb.h) / 12, 0, 150);
        y = keepWithin(grid.height() - Math.ceil(hsb.s / (100 / grid.height())), 0, grid.height());
        gridPicker.css({
          top: y + &#039;px&#039;,
          left: x + &#039;px&#039;
        });

        // Set slider position
        y = keepWithin(slider.height() - (hsb.b * (slider.height() / 100)), 0, slider.height());
        sliderPicker.css(&#039;top&#039;, y + &#039;px&#039;);

        // Update UI
        slider.css(&#039;backgroundColor&#039;, hsb2hex({ h: hsb.h, s: hsb.s, b: 100 }));
        minicolors.find(&#039;.minicolors-grid-inner&#039;).css(&#039;opacity&#039;, 1 - (hsb.b / 100));
        break;

      default:
        // Set grid position
        x = keepWithin(Math.ceil(hsb.s / (100 / grid.width())), 0, grid.width());
        y = keepWithin(grid.height() - Math.ceil(hsb.b / (100 / grid.height())), 0, grid.height());
        gridPicker.css({
          top: y + &#039;px&#039;,
          left: x + &#039;px&#039;
        });

        // Set slider position
        y = keepWithin(slider.height() - (hsb.h / (360 / slider.height())), 0, slider.height());
        sliderPicker.css(&#039;top&#039;, y + &#039;px&#039;);

        // Update panel color
        grid.css(&#039;backgroundColor&#039;, hsb2hex({ h: hsb.h, s: 100, b: 100 }));
        break;
    }

    // Fire change event, but only if minicolors is fully initialized
    if(input.data(&#039;minicolors-initialized&#039;)) {
      doChange(input, value, opacity);
    }
  }

  // Runs the change and changeDelay callbacks
  function doChange(input, value, opacity) {
    var settings = input.data(&#039;minicolors-settings&#039;);
    var lastChange = input.data(&#039;minicolors-lastChange&#039;);
    var obj, sel, i;

    // Only run if it actually changed
    if(!lastChange || lastChange.value !== value || lastChange.opacity !== opacity) {

      // Remember last-changed value
      input.data(&#039;minicolors-lastChange&#039;, {
        value: value,
        opacity: opacity
      });

      // Check and select applicable swatch
      if(settings.swatches &amp;&amp; settings.swatches.length !== 0) {
        if(!isRgb(value)) {
          obj = hex2rgb(value);
        }
        else {
          obj = parseRgb(value, true);
        }
        sel = -1;
        for(i = 0; i &lt; settings.swatches.length; ++i) {
          if(obj.r === settings.swatches[i].r &amp;&amp; obj.g === settings.swatches[i].g &amp;&amp; obj.b === settings.swatches[i].b &amp;&amp; obj.a === settings.swatches[i].a) {
            sel = i;
            break;
          }
        }

        input.parent().find(&#039;.minicolors-swatches .minicolors-swatch&#039;).removeClass(&#039;selected&#039;);
        if(sel !== -1) {
          input.parent().find(&#039;.minicolors-swatches .minicolors-swatch&#039;).eq(i).addClass(&#039;selected&#039;);
        }
      }

      // Fire change event
      if(settings.change) {
        if(settings.changeDelay) {
          // Call after a delay
          clearTimeout(input.data(&#039;minicolors-changeTimeout&#039;));
          input.data(&#039;minicolors-changeTimeout&#039;, setTimeout(function() {
            settings.change.call(input.get(0), value, opacity);
          }, settings.changeDelay));
        } else {
          // Call immediately
          settings.change.call(input.get(0), value, opacity);
        }
      }
      input.trigger(&#039;change&#039;).trigger(&#039;input&#039;);
    }
  }

  // Generates an RGB(A) object based on the input&#039;s value
  function rgbObject(input) {
    var rgb,
      opacity = $(input).attr(&#039;data-opacity&#039;);
    if( isRgb($(input).val()) ) {
      rgb = parseRgb($(input).val(), true);
    } else {
      var hex = parseHex($(input).val(), true);
      rgb = hex2rgb(hex);
    }
    if( !rgb ) return null;
    if( opacity !== undefined ) $.extend(rgb, { a: parseFloat(opacity) });
    return rgb;
  }

  // Generates an RGB(A) string based on the input&#039;s value
  function rgbString(input, alpha) {
    var rgb,
      opacity = $(input).attr(&#039;data-opacity&#039;);
    if( isRgb($(input).val()) ) {
      rgb = parseRgb($(input).val(), true);
    } else {
      var hex = parseHex($(input).val(), true);
      rgb = hex2rgb(hex);
    }
    if( !rgb ) return null;
    if( opacity === undefined ) opacity = 1;
    if( alpha ) {
      return &#039;rgba(&#039; + rgb.r + &#039;, &#039; + rgb.g + &#039;, &#039; + rgb.b + &#039;, &#039; + parseFloat(opacity) + &#039;)&#039;;
    } else {
      return &#039;rgb(&#039; + rgb.r + &#039;, &#039; + rgb.g + &#039;, &#039; + rgb.b + &#039;)&#039;;
    }
  }

  // Converts to the letter case specified in settings
  function convertCase(string, letterCase) {
    return letterCase === &#039;uppercase&#039; ? string.toUpperCase() : string.toLowerCase();
  }

  // Parses a string and returns a valid hex string when possible
  function parseHex(string, expand) {
    string = string.replace(/^#/g, &#039;&#039;);
    if(!string.match(/^[A-F0-9]{3,6}/ig)) return &#039;&#039;;
    if(string.length !== 3 &amp;&amp; string.length !== 6) return &#039;&#039;;
    if(string.length === 3 &amp;&amp; expand) {
      string = string[0] + string[0] + string[1] + string[1] + string[2] + string[2];
    }
    return &#039;#&#039; + string;
  }

  // Parses a string and returns a valid RGB(A) string when possible
  function parseRgb(string, obj) {
    var values = string.replace(/[^\d,.]/g, &#039;&#039;);
    var rgba = values.split(&#039;,&#039;);

    rgba[0] = keepWithin(parseInt(rgba[0], 10), 0, 255);
    rgba[1] = keepWithin(parseInt(rgba[1], 10), 0, 255);
    rgba[2] = keepWithin(parseInt(rgba[2], 10), 0, 255);
    if(rgba[3] !== undefined) {
      rgba[3] = keepWithin(parseFloat(rgba[3], 10), 0, 1);
    }

    // Return RGBA object
    if( obj ) {
      if (rgba[3] !== undefined) {
        return {
          r: rgba[0],
          g: rgba[1],
          b: rgba[2],
          a: rgba[3]
        };
      } else {
        return {
          r: rgba[0],
          g: rgba[1],
          b: rgba[2]
        };
      }
    }

    // Return RGBA string
    if(typeof(rgba[3]) !== &#039;undefined&#039; &amp;&amp; rgba[3] &lt;= 1) {
      return &#039;rgba(&#039; + rgba[0] + &#039;, &#039; + rgba[1] + &#039;, &#039; + rgba[2] + &#039;, &#039; + rgba[3] + &#039;)&#039;;
    } else {
      return &#039;rgb(&#039; + rgba[0] + &#039;, &#039; + rgba[1] + &#039;, &#039; + rgba[2] + &#039;)&#039;;
    }

  }

  // Parses a string and returns a valid color string when possible
  function parseInput(string, expand) {
    if(isRgb(string)) {
      // Returns a valid rgb(a) string
      return parseRgb(string);
    } else {
      return parseHex(string, expand);
    }
  }

  // Keeps value within min and max
  function keepWithin(value, min, max) {
    if(value &lt; min) value = min;
    if(value &gt; max) value = max;
    return value;
  }

  // Checks if a string is a valid RGB(A) string
  function isRgb(string) {
    var rgb = string.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
    return (rgb &amp;&amp; rgb.length === 4) ? true : false;
  }

  // Function to get alpha from a RGB(A) string
  function getAlpha(rgba) {
    rgba = rgba.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+(\.\d{1,2})?|\.\d{1,2})[\s+]?/i);
    return (rgba &amp;&amp; rgba.length === 6) ? rgba[4] : &#039;1&#039;;
  }

  // Converts an HSB object to an RGB object
  function hsb2rgb(hsb) {
    var rgb = {};
    var h = Math.round(hsb.h);
    var s = Math.round(hsb.s * 255 / 100);
    var v = Math.round(hsb.b * 255 / 100);
    if(s === 0) {
      rgb.r = rgb.g = rgb.b = v;
    } else {
      var t1 = v;
      var t2 = (255 - s) * v / 255;
      var t3 = (t1 - t2) * (h % 60) / 60;
      if(h === 360) h = 0;
      if(h &lt; 60) { rgb.r = t1; rgb.b = t2; rgb.g = t2 + t3; }
      else if(h &lt; 120) {rgb.g = t1; rgb.b = t2; rgb.r = t1 - t3; }
      else if(h &lt; 180) {rgb.g = t1; rgb.r = t2; rgb.b = t2 + t3; }
      else if(h &lt; 240) {rgb.b = t1; rgb.r = t2; rgb.g = t1 - t3; }
      else if(h &lt; 300) {rgb.b = t1; rgb.g = t2; rgb.r = t2 + t3; }
      else if(h &lt; 360) {rgb.r = t1; rgb.g = t2; rgb.b = t1 - t3; }
      else { rgb.r = 0; rgb.g = 0; rgb.b = 0; }
    }
    return {
      r: Math.round(rgb.r),
      g: Math.round(rgb.g),
      b: Math.round(rgb.b)
    };
  }

  // Converts an RGB string to a hex string
  function rgbString2hex(rgb){
    rgb = rgb.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i);
    return (rgb &amp;&amp; rgb.length === 4) ? &#039;#&#039; +
      (&#039;0&#039; + parseInt(rgb[1],10).toString(16)).slice(-2) +
      (&#039;0&#039; + parseInt(rgb[2],10).toString(16)).slice(-2) +
      (&#039;0&#039; + parseInt(rgb[3],10).toString(16)).slice(-2) : &#039;&#039;;
  }

  // Converts an RGB object to a hex string
  function rgb2hex(rgb) {
    var hex = [
      rgb.r.toString(16),
      rgb.g.toString(16),
      rgb.b.toString(16)
    ];
    $.each(hex, function(nr, val) {
      if(val.length === 1) hex[nr] = &#039;0&#039; + val;
    });
    return &#039;#&#039; + hex.join(&#039;&#039;);
  }

  // Converts an HSB object to a hex string
  function hsb2hex(hsb) {
    return rgb2hex(hsb2rgb(hsb));
  }

  // Converts a hex string to an HSB object
  function hex2hsb(hex) {
    var hsb = rgb2hsb(hex2rgb(hex));
    if(hsb.s === 0) hsb.h = 360;
    return hsb;
  }

  // Converts an RGB object to an HSB object
  function rgb2hsb(rgb) {
    var hsb = { h: 0, s: 0, b: 0 };
    var min = Math.min(rgb.r, rgb.g, rgb.b);
    var max = Math.max(rgb.r, rgb.g, rgb.b);
    var delta = max - min;
    hsb.b = max;
    hsb.s = max !== 0 ? 255 * delta / max : 0;
    if(hsb.s !== 0) {
      if(rgb.r === max) {
        hsb.h = (rgb.g - rgb.b) / delta;
      } else if(rgb.g === max) {
        hsb.h = 2 + (rgb.b - rgb.r) / delta;
      } else {
        hsb.h = 4 + (rgb.r - rgb.g) / delta;
      }
    } else {
      hsb.h = -1;
    }
    hsb.h *= 60;
    if(hsb.h &lt; 0) {
      hsb.h += 360;
    }
    hsb.s *= 100/255;
    hsb.b *= 100/255;
    return hsb;
  }

  // Converts a hex string to an RGB object
  function hex2rgb(hex) {
    hex = parseInt(((hex.indexOf(&#039;#&#039;) &gt; -1) ? hex.substring(1) : hex), 16);
    return {
      r: hex &gt;&gt; 16,
      g: (hex &amp; 0x00FF00) &gt;&gt; 8,
      b: (hex &amp; 0x0000FF)
    };
  }

  // Handle events
  $([document])
    // Hide on clicks outside of the control
    .on(&#039;mousedown.minicolors touchstart.minicolors&#039;, function(event) {
      if(!$(event.target).parents().add(event.target).hasClass(&#039;minicolors&#039;)) {
        hide();
      }
    })
    // Start moving
    .on(&#039;mousedown.minicolors touchstart.minicolors&#039;, &#039;.minicolors-grid, .minicolors-slider, .minicolors-opacity-slider&#039;, function(event) {
      var target = $(this);
      event.preventDefault();
      $(event.delegateTarget).data(&#039;minicolors-target&#039;, target);
      move(target, event, true);
    })
    // Move pickers
    .on(&#039;mousemove.minicolors touchmove.minicolors&#039;, function(event) {
      var target = $(event.delegateTarget).data(&#039;minicolors-target&#039;);
      if(target) move(target, event);
    })
    // Stop moving
    .on(&#039;mouseup.minicolors touchend.minicolors&#039;, function() {
      $(this).removeData(&#039;minicolors-target&#039;);
    })
    // Selected a swatch
    .on(&#039;click.minicolors&#039;, &#039;.minicolors-swatches li&#039;, function(event) {
      event.preventDefault();
      var target = $(this), input = target.parents(&#039;.minicolors&#039;).find(&#039;.minicolors-input&#039;), color = target.data(&#039;swatch-color&#039;);
      updateInput(input, color, getAlpha(color));
      updateFromInput(input);
    })
    // Show panel when swatch is clicked
    .on(&#039;mousedown.minicolors touchstart.minicolors&#039;, &#039;.minicolors-input-swatch&#039;, function(event) {
      var input = $(this).parent().find(&#039;.minicolors-input&#039;);
      event.preventDefault();
      show(input);
    })
    // Show on focus
    .on(&#039;focus.minicolors&#039;, &#039;.minicolors-input&#039;, function() {
      var input = $(this);
      if(!input.data(&#039;minicolors-initialized&#039;)) return;
      show(input);
    })
    // Update value on blur
    .on(&#039;blur.minicolors&#039;, &#039;.minicolors-input&#039;, function() {
      var input = $(this);
      var settings = input.data(&#039;minicolors-settings&#039;);
      var keywords;
      var hex;
      var rgba;
      var swatchOpacity;
      var value;

      if(!input.data(&#039;minicolors-initialized&#039;)) return;

      // Get array of lowercase keywords
      keywords = !settings.keywords ? [] : $.map(settings.keywords.split(&#039;,&#039;), function(a) {
        return a.toLowerCase().trim();
      });

      // Set color string
      if(input.val() !== &#039;&#039; &amp;&amp; $.inArray(input.val().toLowerCase(), keywords) &gt; -1) {
        value = input.val();
      } else {
        // Get RGBA values for easy conversion
        if(isRgb(input.val())) {
          rgba = parseRgb(input.val(), true);
        } else {
          hex = parseHex(input.val(), true);
          rgba = hex ? hex2rgb(hex) : null;
        }

        // Convert to format
        if(rgba === null) {
          value = settings.defaultValue;
        } else if(settings.format === &#039;rgb&#039;) {
          value = settings.opacity ?
            parseRgb(&#039;rgba(&#039; + rgba.r + &#039;,&#039; + rgba.g + &#039;,&#039; + rgba.b + &#039;,&#039; + input.attr(&#039;data-opacity&#039;) + &#039;)&#039;) :
            parseRgb(&#039;rgb(&#039; + rgba.r + &#039;,&#039; + rgba.g + &#039;,&#039; + rgba.b + &#039;)&#039;);
        } else {
          value = rgb2hex(rgba);
        }
      }

      // Update swatch opacity
      swatchOpacity = settings.opacity ? input.attr(&#039;data-opacity&#039;) : 1;
      if(value.toLowerCase() === &#039;transparent&#039;) swatchOpacity = 0;
      input
        .closest(&#039;.minicolors&#039;)
        .find(&#039;.minicolors-input-swatch &gt; span&#039;)
        .css(&#039;opacity&#039;, String(swatchOpacity));

      // Set input value
      input.val(value);

      // Is it blank?
      if(input.val() === &#039;&#039;) input.val(parseInput(settings.defaultValue, true));

      // Adjust case
      input.val(convertCase(input.val(), settings.letterCase));

    })
    // Handle keypresses
    .on(&#039;keydown.minicolors&#039;, &#039;.minicolors-input&#039;, function(event) {
      var input = $(this);
      if(!input.data(&#039;minicolors-initialized&#039;)) return;
      switch(event.which) {
        case 9: // tab
          hide();
          break;
        case 13: // enter
        case 27: // esc
          hide();
          input.blur();
          break;
      }
    })
    // Update on keyup
    .on(&#039;keyup.minicolors&#039;, &#039;.minicolors-input&#039;, function() {
      var input = $(this);
      if(!input.data(&#039;minicolors-initialized&#039;)) return;
      updateFromInput(input, true);
    })
    // Update on paste
    .on(&#039;paste.minicolors&#039;, &#039;.minicolors-input&#039;, function() {
      var input = $(this);
      if(!input.data(&#039;minicolors-initialized&#039;)) return;
      setTimeout(function() {
        updateFromInput(input, true);
      }, 1);
    });
}));</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2Fhome%2Fplanet5%2Fwww%2Fwp-content%2Fplugins%2Fdivi-builder%2Fincludes%2Fbuilder%2Fscripts%2Fext'>⬅ Back to Directory</a>